From ff3716b5435f36644aa77f696f878d48faf1f906 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=AD=99=E6=B5=A9=E6=9E=97?= Date: Fri, 19 Jul 2024 10:29:45 +0800 Subject: [PATCH 1/6] =?UTF-8?q?ddp-server=20=E6=94=BE=E8=87=B3creator?= =?UTF-8?q?=E4=B8=8B=20=EF=BC=88#6964=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- creator/packages/ddp-server/README.md | 4 + creator/packages/ddp-server/crossbar.js | 167 ++ creator/packages/ddp-server/crossbar_tests.js | 49 + .../packages/ddp-server/livedata_server.js | 1772 +++++++++++++++++ .../ddp-server/livedata_server_tests.js | 411 ++++ creator/packages/ddp-server/package.js | 60 + .../packages/ddp-server/server_convenience.js | 22 + .../packages/ddp-server/session_view_tests.js | 393 ++++ creator/packages/ddp-server/stream_server.js | 184 ++ creator/packages/ddp-server/writefence.js | 131 ++ .../programs/server/packages/ddp-server.js | 4 +- .../server/packages/ddp-server.js.map | 2 +- .../programs/server/packages/modules.js | 26 +- ...27de16d6eab9175efa4d52871e8cc6588f4811.js} | 4 +- ...eab9175efa4d52871e8cc6588f4811.stats.json} | 6 +- .../programs/web.browser.legacy/program.json | 18 +- ...27de16d6eab9175efa4d52871e8cc6588f4811.js} | 4 +- ...eab9175efa4d52871e8cc6588f4811.stats.json} | 6 +- .../bundle/programs/web.browser/program.json | 18 +- ...7fd9820c5c4cf898af8b1c4a65e09c854f6d33.js} | 4 +- ...5c4cf898af8b1c4a65e09c854f6d33.stats.json} | 6 +- .../bundle/programs/web.cordova/program.json | 18 +- server/bundle/star.json | 2 +- 23 files changed, 3252 insertions(+), 59 deletions(-) create mode 100644 creator/packages/ddp-server/README.md create mode 100644 creator/packages/ddp-server/crossbar.js create mode 100644 creator/packages/ddp-server/crossbar_tests.js create mode 100644 creator/packages/ddp-server/livedata_server.js create mode 100644 creator/packages/ddp-server/livedata_server_tests.js create mode 100644 creator/packages/ddp-server/package.js create mode 100755 creator/packages/ddp-server/server_convenience.js create mode 100644 creator/packages/ddp-server/session_view_tests.js create mode 100644 creator/packages/ddp-server/stream_server.js create mode 100644 creator/packages/ddp-server/writefence.js rename server/bundle/programs/web.browser.legacy/{79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js => 7d27de16d6eab9175efa4d52871e8cc6588f4811.js} (99%) rename server/bundle/programs/web.browser.legacy/{79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json => 7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json} (99%) rename server/bundle/programs/web.browser/{79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js => 7d27de16d6eab9175efa4d52871e8cc6588f4811.js} (99%) rename server/bundle/programs/web.browser/{79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json => 7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json} (99%) rename server/bundle/programs/web.cordova/{562208cdca3e6c297f81857edf4a42d67cc7b014.js => 717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js} (99%) rename server/bundle/programs/web.cordova/{562208cdca3e6c297f81857edf4a42d67cc7b014.stats.json => 717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json} (99%) diff --git a/creator/packages/ddp-server/README.md b/creator/packages/ddp-server/README.md new file mode 100644 index 0000000000..21d2ac4c84 --- /dev/null +++ b/creator/packages/ddp-server/README.md @@ -0,0 +1,4 @@ +# ddp-server +[Source code of released version](https://github.com/meteor/meteor/tree/master/packages/ddp-server) | [Source code of development version](https://github.com/meteor/meteor/tree/devel/packages/ddp-server) +*** + diff --git a/creator/packages/ddp-server/crossbar.js b/creator/packages/ddp-server/crossbar.js new file mode 100644 index 0000000000..6672059f99 --- /dev/null +++ b/creator/packages/ddp-server/crossbar.js @@ -0,0 +1,167 @@ +// A "crossbar" is a class that provides structured notification registration. +// See _match for the definition of how a notification matches a trigger. +// All notifications and triggers must have a string key named 'collection'. + +DDPServer._Crossbar = function (options) { + var self = this; + options = options || {}; + + self.nextId = 1; + // map from collection name (string) -> listener id -> object. each object has + // keys 'trigger', 'callback'. As a hack, the empty string means "no + // collection". + self.listenersByCollection = {}; + self.listenersByCollectionCount = {}; + self.factPackage = options.factPackage || "livedata"; + self.factName = options.factName || null; +}; + +_.extend(DDPServer._Crossbar.prototype, { + // msg is a trigger or a notification + _collectionForMessage: function (msg) { + var self = this; + if (! _.has(msg, 'collection')) { + return ''; + } else if (typeof(msg.collection) === 'string') { + if (msg.collection === '') + throw Error("Message has empty collection!"); + return msg.collection; + } else { + throw Error("Message has non-string collection!"); + } + }, + + // Listen for notification that match 'trigger'. A notification + // matches if it has the key-value pairs in trigger as a + // subset. When a notification matches, call 'callback', passing + // the actual notification. + // + // Returns a listen handle, which is an object with a method + // stop(). Call stop() to stop listening. + // + // XXX It should be legal to call fire() from inside a listen() + // callback? + listen: function (trigger, callback) { + var self = this; + var id = self.nextId++; + + var collection = self._collectionForMessage(trigger); + var record = {trigger: EJSON.clone(trigger), callback: callback}; + if (! _.has(self.listenersByCollection, collection)) { + self.listenersByCollection[collection] = {}; + self.listenersByCollectionCount[collection] = 0; + } + self.listenersByCollection[collection][id] = record; + self.listenersByCollectionCount[collection]++; + + if (self.factName && Package['facts-base']) { + Package['facts-base'].Facts.incrementServerFact( + self.factPackage, self.factName, 1); + } + + return { + stop: function () { + if (self.factName && Package['facts-base']) { + Package['facts-base'].Facts.incrementServerFact( + self.factPackage, self.factName, -1); + } + delete self.listenersByCollection[collection][id]; + self.listenersByCollectionCount[collection]--; + if (self.listenersByCollectionCount[collection] === 0) { + delete self.listenersByCollection[collection]; + delete self.listenersByCollectionCount[collection]; + } + } + }; + }, + + // Fire the provided 'notification' (an object whose attribute + // values are all JSON-compatibile) -- inform all matching listeners + // (registered with listen()). + // + // If fire() is called inside a write fence, then each of the + // listener callbacks will be called inside the write fence as well. + // + // The listeners may be invoked in parallel, rather than serially. + fire: function (notification) { + var self = this; + + var collection = self._collectionForMessage(notification); + + if (! _.has(self.listenersByCollection, collection)) { + return; + } + + var listenersForCollection = self.listenersByCollection[collection]; + var callbackIds = []; + _.each(listenersForCollection, function (l, id) { + if (self._matches(notification, l.trigger)) { + callbackIds.push(id); + } + }); + + // Listener callbacks can yield, so we need to first find all the ones that + // match in a single iteration over self.listenersByCollection (which can't + // be mutated during this iteration), and then invoke the matching + // callbacks, checking before each call to ensure they haven't stopped. + // Note that we don't have to check that + // self.listenersByCollection[collection] still === listenersForCollection, + // because the only way that stops being true is if listenersForCollection + // first gets reduced down to the empty object (and then never gets + // increased again). + _.each(callbackIds, function (id) { + if (_.has(listenersForCollection, id)) { + listenersForCollection[id].callback(notification); + } + }); + }, + + // A notification matches a trigger if all keys that exist in both are equal. + // + // Examples: + // N:{collection: "C"} matches T:{collection: "C"} + // (a non-targeted write to a collection matches a + // non-targeted query) + // N:{collection: "C", id: "X"} matches T:{collection: "C"} + // (a targeted write to a collection matches a non-targeted query) + // N:{collection: "C"} matches T:{collection: "C", id: "X"} + // (a non-targeted write to a collection matches a + // targeted query) + // N:{collection: "C", id: "X"} matches T:{collection: "C", id: "X"} + // (a targeted write to a collection matches a targeted query targeted + // at the same document) + // N:{collection: "C", id: "X"} does not match T:{collection: "C", id: "Y"} + // (a targeted write to a collection does not match a targeted query + // targeted at a different document) + _matches: function (notification, trigger) { + // Most notifications that use the crossbar have a string `collection` and + // maybe an `id` that is a string or ObjectID. We're already dividing up + // triggers by collection, but let's fast-track "nope, different ID" (and + // avoid the overly generic EJSON.equals). This makes a noticeable + // performance difference; see https://github.com/meteor/meteor/pull/3697 + if (typeof(notification.id) === 'string' && + typeof(trigger.id) === 'string' && + notification.id !== trigger.id) { + return false; + } + if (notification.id instanceof MongoID.ObjectID && + trigger.id instanceof MongoID.ObjectID && + ! notification.id.equals(trigger.id)) { + return false; + } + + return _.all(trigger, function (triggerValue, key) { + return !_.has(notification, key) || + EJSON.equals(triggerValue, notification[key]); + }); + } +}); + +// The "invalidation crossbar" is a specific instance used by the DDP server to +// implement write fence notifications. Listener callbacks on this crossbar +// should call beginWrite on the current write fence before they return, if they +// want to delay the write fence from firing (ie, the DDP method-data-updated +// message from being sent). +DDPServer._InvalidationCrossbar = new DDPServer._Crossbar({ + factName: "invalidation-crossbar-listeners" +}); diff --git a/creator/packages/ddp-server/crossbar_tests.js b/creator/packages/ddp-server/crossbar_tests.js new file mode 100644 index 0000000000..cf42351798 --- /dev/null +++ b/creator/packages/ddp-server/crossbar_tests.js @@ -0,0 +1,49 @@ +// White box tests of invalidation crossbar matching function. +// Note: the current crossbar match function is designed specifically +// to ensure that a modification that targets a specific ID does not +// notify a query that is watching a different specific ID. (And to +// keep separate collections separate.) Other than that, there's no +// deep meaning to the matching function, and it could be changed later +// as long as it preserves that property. +Tinytest.add('livedata - crossbar', function (test) { + var crossbar = new DDPServer._Crossbar; + test.isTrue(crossbar._matches({collection: "C"}, + {collection: "C"})); + test.isTrue(crossbar._matches({collection: "C", id: "X"}, + {collection: "C"})); + test.isTrue(crossbar._matches({collection: "C"}, + {collection: "C", id: "X"})); + test.isTrue(crossbar._matches({collection: "C", id: "X"}, + {collection: "C"})); + + test.isFalse(crossbar._matches({collection: "C", id: "X"}, + {collection: "C", id: "Y"})); + + // Test that stopped listens definitely don't fire. + var calledFirst = false; + var calledSecond = false; + var trigger = {collection: "C"}; + var secondHandle; + crossbar.listen(trigger, function (notification) { + // This test assumes that listeners will be called in the order + // registered. It's not wrong for the crossbar to do something different, + // but the test won't be valid in that case, so make it fail so we notice. + calledFirst = true; + if (calledSecond) { + test.fail({ + type: "test_assumption_failed", + message: "test assumed that listeners would be called in the order registered" + }); + } else { + secondHandle.stop(); + } + }); + secondHandle = crossbar.listen(trigger, function (notification) { + // This should not get invoked, because it should be stopped by the other + // listener! + calledSecond = true; + }); + crossbar.fire(trigger); + test.isTrue(calledFirst); + test.isFalse(calledSecond); +}); diff --git a/creator/packages/ddp-server/livedata_server.js b/creator/packages/ddp-server/livedata_server.js new file mode 100644 index 0000000000..7de0f1517d --- /dev/null +++ b/creator/packages/ddp-server/livedata_server.js @@ -0,0 +1,1772 @@ +DDPServer = {}; + +var Fiber = Npm.require('fibers'); + +// This file contains classes: +// * Session - The server's connection to a single DDP client +// * Subscription - A single subscription for a single client +// * Server - An entire server that may talk to > 1 client. A DDP endpoint. +// +// Session and Subscription are file scope. For now, until we freeze +// the interface, Server is package scope (in the future it should be +// exported.) + +// Represents a single document in a SessionCollectionView +var SessionDocumentView = function () { + var self = this; + self.existsIn = new Set(); // set of subscriptionHandle + self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence] +}; + +DDPServer._SessionDocumentView = SessionDocumentView; + + +_.extend(SessionDocumentView.prototype, { + + getFields: function () { + var self = this; + var ret = {}; + self.dataByKey.forEach(function (precedenceList, key) { + ret[key] = precedenceList[0].value; + }); + return ret; + }, + + clearField: function (subscriptionHandle, key, changeCollector) { + var self = this; + // Publish API ignores _id if present in fields + if (key === "_id") + return; + var precedenceList = self.dataByKey.get(key); + + // It's okay to clear fields that didn't exist. No need to throw + // an error. + if (!precedenceList) + return; + + var removedValue = undefined; + for (var i = 0; i < precedenceList.length; i++) { + var precedence = precedenceList[i]; + if (precedence.subscriptionHandle === subscriptionHandle) { + // The view's value can only change if this subscription is the one that + // used to have precedence. + if (i === 0) + removedValue = precedence.value; + precedenceList.splice(i, 1); + break; + } + } + if (precedenceList.length === 0) { + self.dataByKey.delete(key); + changeCollector[key] = undefined; + } else if (removedValue !== undefined && + !EJSON.equals(removedValue, precedenceList[0].value)) { + changeCollector[key] = precedenceList[0].value; + } + }, + + changeField: function (subscriptionHandle, key, value, + changeCollector, isAdd) { + var self = this; + // Publish API ignores _id if present in fields + if (key === "_id") + return; + + // Don't share state with the data passed in by the user. + value = EJSON.clone(value); + + if (!self.dataByKey.has(key)) { + self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle, + value: value}]); + changeCollector[key] = value; + return; + } + var precedenceList = self.dataByKey.get(key); + var elt; + if (!isAdd) { + elt = precedenceList.find(function (precedence) { + return precedence.subscriptionHandle === subscriptionHandle; + }); + } + + if (elt) { + if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) { + // this subscription is changing the value of this field. + changeCollector[key] = value; + } + elt.value = value; + } else { + // this subscription is newly caring about this field + precedenceList.push({subscriptionHandle: subscriptionHandle, value: value}); + } + + } +}); + +/** + * Represents a client's view of a single collection + * @param {String} collectionName Name of the collection it represents + * @param {Object.} sessionCallbacks The callbacks for added, changed, removed + * @class SessionCollectionView + */ +var SessionCollectionView = function (collectionName, sessionCallbacks) { + var self = this; + self.collectionName = collectionName; + self.documents = new Map(); + self.callbacks = sessionCallbacks; +}; + +DDPServer._SessionCollectionView = SessionCollectionView; + + +_.extend(SessionCollectionView.prototype, { + + isEmpty: function () { + var self = this; + return self.documents.size === 0; + }, + + diff: function (previous) { + var self = this; + DiffSequence.diffMaps(previous.documents, self.documents, { + both: _.bind(self.diffDocument, self), + + rightOnly: function (id, nowDV) { + self.callbacks.added(self.collectionName, id, nowDV.getFields()); + }, + + leftOnly: function (id, prevDV) { + self.callbacks.removed(self.collectionName, id); + } + }); + }, + + diffDocument: function (id, prevDV, nowDV) { + var self = this; + var fields = {}; + DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), { + both: function (key, prev, now) { + if (!EJSON.equals(prev, now)) + fields[key] = now; + }, + rightOnly: function (key, now) { + fields[key] = now; + }, + leftOnly: function(key, prev) { + fields[key] = undefined; + } + }); + self.callbacks.changed(self.collectionName, id, fields); + }, + + added: function (subscriptionHandle, id, fields) { + var self = this; + var docView = self.documents.get(id); + var added = false; + if (!docView) { + added = true; + docView = new SessionDocumentView(); + self.documents.set(id, docView); + } + docView.existsIn.add(subscriptionHandle); + var changeCollector = {}; + _.each(fields, function (value, key) { + docView.changeField( + subscriptionHandle, key, value, changeCollector, true); + }); + if (added) + self.callbacks.added(self.collectionName, id, changeCollector); + else + self.callbacks.changed(self.collectionName, id, changeCollector); + }, + + changed: function (subscriptionHandle, id, changed) { + var self = this; + var changedResult = {}; + var docView = self.documents.get(id); + if (!docView) + throw new Error("Could not find element with id " + id + " to change"); + _.each(changed, function (value, key) { + if (value === undefined) + docView.clearField(subscriptionHandle, key, changedResult); + else + docView.changeField(subscriptionHandle, key, value, changedResult); + }); + self.callbacks.changed(self.collectionName, id, changedResult); + }, + + removed: function (subscriptionHandle, id) { + var self = this; + var docView = self.documents.get(id); + if (!docView) { + var err = new Error("Removed nonexistent document " + id); + throw err; + } + docView.existsIn.delete(subscriptionHandle); + if (docView.existsIn.size === 0) { + // it is gone from everyone + self.callbacks.removed(self.collectionName, id); + self.documents.delete(id); + } else { + var changed = {}; + // remove this subscription from every precedence list + // and record the changes + docView.dataByKey.forEach(function (precedenceList, key) { + docView.clearField(subscriptionHandle, key, changed); + }); + + self.callbacks.changed(self.collectionName, id, changed); + } + } +}); + +/******************************************************************************/ +/* Session */ +/******************************************************************************/ + +var Session = function (server, version, socket, options) { + var self = this; + self.id = Random.id(); + + self.server = server; + self.version = version; + + self.initialized = false; + self.socket = socket; + + // set to null when the session is destroyed. multiple places below + // use this to determine if the session is alive or not. + self.inQueue = new Meteor._DoubleEndedQueue(); + + self.blocked = false; + self.workerRunning = false; + + // Sub objects for active subscriptions + self._namedSubs = new Map(); + self._universalSubs = []; + + self.userId = null; + + self.collectionViews = new Map(); + + // Set this to false to not send messages when collectionViews are + // modified. This is done when rerunning subs in _setUserId and those messages + // are calculated via a diff instead. + self._isSending = true; + + // If this is true, don't start a newly-created universal publisher on this + // session. The session will take care of starting it when appropriate. + self._dontStartNewUniversalSubs = false; + + // when we are rerunning subscriptions, any ready messages + // we want to buffer up for when we are done rerunning subscriptions + self._pendingReady = []; + + // List of callbacks to call when this connection is closed. + self._closeCallbacks = []; + + + // XXX HACK: If a sockjs connection, save off the URL. This is + // temporary and will go away in the near future. + self._socketUrl = socket.url; + + // Allow tests to disable responding to pings. + self._respondToPings = options.respondToPings; + + // This object is the public interface to the session. In the public + // API, it is called the `connection` object. Internally we call it + // a `connectionHandle` to avoid ambiguity. + self.connectionHandle = { + id: self.id, + close: function () { + self.close(); + }, + onClose: function (fn) { + var cb = Meteor.bindEnvironment(fn, "connection onClose callback"); + if (self.inQueue) { + self._closeCallbacks.push(cb); + } else { + // if we're already closed, call the callback. + Meteor.defer(cb); + } + }, + clientAddress: self._clientAddress(), + httpHeaders: self.socket.headers + }; + + self.send({ msg: 'connected', session: self.id }); + + // On initial connect, spin up all the universal publishers. + Fiber(function () { + self.startUniversalSubs(); + }).run(); + + if (version !== 'pre1' && options.heartbeatInterval !== 0) { + // We no longer need the low level timeout because we have heartbeating. + socket.setWebsocketTimeout(0); + + self.heartbeat = new DDPCommon.Heartbeat({ + heartbeatInterval: options.heartbeatInterval, + heartbeatTimeout: options.heartbeatTimeout, + onTimeout: function () { + self.close(); + }, + sendPing: function () { + self.send({msg: 'ping'}); + } + }); + self.heartbeat.start(); + } + + Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact( + "livedata", "sessions", 1); +}; + +_.extend(Session.prototype, { + + sendReady: function (subscriptionIds) { + var self = this; + if (self._isSending) + self.send({msg: "ready", subs: subscriptionIds}); + else { + _.each(subscriptionIds, function (subscriptionId) { + self._pendingReady.push(subscriptionId); + }); + } + }, + + sendAdded: function (collectionName, id, fields) { + var self = this; + if (self._isSending) + self.send({msg: "added", collection: collectionName, id: id, fields: fields}); + }, + + sendChanged: function (collectionName, id, fields) { + var self = this; + if (_.isEmpty(fields)) + return; + + if (self._isSending) { + self.send({ + msg: "changed", + collection: collectionName, + id: id, + fields: fields + }); + } + }, + + sendRemoved: function (collectionName, id) { + var self = this; + if (self._isSending) + self.send({msg: "removed", collection: collectionName, id: id}); + }, + + getSendCallbacks: function () { + var self = this; + return { + added: _.bind(self.sendAdded, self), + changed: _.bind(self.sendChanged, self), + removed: _.bind(self.sendRemoved, self) + }; + }, + + getCollectionView: function (collectionName) { + var self = this; + var ret = self.collectionViews.get(collectionName); + if (!ret) { + ret = new SessionCollectionView(collectionName, + self.getSendCallbacks()); + self.collectionViews.set(collectionName, ret); + } + return ret; + }, + + added: function (subscriptionHandle, collectionName, id, fields) { + var self = this; + var view = self.getCollectionView(collectionName); + view.added(subscriptionHandle, id, fields); + }, + + removed: function (subscriptionHandle, collectionName, id) { + var self = this; + var view = self.getCollectionView(collectionName); + view.removed(subscriptionHandle, id); + if (view.isEmpty()) { + self.collectionViews.delete(collectionName); + } + }, + + changed: function (subscriptionHandle, collectionName, id, fields) { + var self = this; + var view = self.getCollectionView(collectionName); + view.changed(subscriptionHandle, id, fields); + }, + + startUniversalSubs: function () { + var self = this; + // Make a shallow copy of the set of universal handlers and start them. If + // additional universal publishers start while we're running them (due to + // yielding), they will run separately as part of Server.publish. + var handlers = _.clone(self.server.universal_publish_handlers); + _.each(handlers, function (handler) { + self._startSubscription(handler); + }); + }, + + // Destroy this session and unregister it at the server. + close: function () { + var self = this; + + // Destroy this session, even if it's not registered at the + // server. Stop all processing and tear everything down. If a socket + // was attached, close it. + + // Already destroyed. + if (! self.inQueue) + return; + + // Drop the merge box data immediately. + self.inQueue = null; + self.collectionViews = new Map(); + + if (self.heartbeat) { + self.heartbeat.stop(); + self.heartbeat = null; + } + + if (self.socket) { + self.socket.close(); + self.socket._meteorSession = null; + } + + Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact( + "livedata", "sessions", -1); + + Meteor.defer(function () { + // stop callbacks can yield, so we defer this on close. + // sub._isDeactivated() detects that we set inQueue to null and + // treats it as semi-deactivated (it will ignore incoming callbacks, etc). + self._deactivateAllSubscriptions(); + + // Defer calling the close callbacks, so that the caller closing + // the session isn't waiting for all the callbacks to complete. + _.each(self._closeCallbacks, function (callback) { + callback(); + }); + }); + + // Unregister the session. + self.server._removeSession(self); + }, + + // Send a message (doing nothing if no socket is connected right now.) + // It should be a JSON object (it will be stringified.) + send: function (msg) { + var self = this; + if (self.socket) { + if (Meteor._printSentDDP) + Meteor._debug("Sent DDP", DDPCommon.stringifyDDP(msg)); + self.socket.send(DDPCommon.stringifyDDP(msg)); + } + }, + + // Send a connection error. + sendError: function (reason, offendingMessage) { + var self = this; + var msg = {msg: 'error', reason: reason}; + if (offendingMessage) + msg.offendingMessage = offendingMessage; + self.send(msg); + }, + + // Process 'msg' as an incoming message. (But as a guard against + // race conditions during reconnection, ignore the message if + // 'socket' is not the currently connected socket.) + // + // We run the messages from the client one at a time, in the order + // given by the client. The message handler is passed an idempotent + // function 'unblock' which it may call to allow other messages to + // begin running in parallel in another fiber (for example, a method + // that wants to yield.) Otherwise, it is automatically unblocked + // when it returns. + // + // Actually, we don't have to 'totally order' the messages in this + // way, but it's the easiest thing that's correct. (unsub needs to + // be ordered against sub, methods need to be ordered against each + // other.) + processMessage: function (msg_in) { + var self = this; + if (!self.inQueue) // we have been destroyed. + return; + + // Respond to ping and pong messages immediately without queuing. + // If the negotiated DDP version is "pre1" which didn't support + // pings, preserve the "pre1" behavior of responding with a "bad + // request" for the unknown messages. + // + // Fibers are needed because heartbeat uses Meteor.setTimeout, which + // needs a Fiber. We could actually use regular setTimeout and avoid + // these new fibers, but it is easier to just make everything use + // Meteor.setTimeout and not think too hard. + // + // Any message counts as receiving a pong, as it demonstrates that + // the client is still alive. + if (self.heartbeat) { + Fiber(function () { + self.heartbeat.messageReceived(); + }).run(); + } + + if (self.version !== 'pre1' && msg_in.msg === 'ping') { + if (self._respondToPings) + self.send({msg: "pong", id: msg_in.id}); + return; + } + if (self.version !== 'pre1' && msg_in.msg === 'pong') { + // Since everything is a pong, nothing to do + return; + } + + self.inQueue.push(msg_in); + if (self.workerRunning) + return; + self.workerRunning = true; + + var processNext = function () { + var msg = self.inQueue && self.inQueue.shift(); + if (!msg) { + self.workerRunning = false; + return; + } + + Fiber(function () { + var blocked = true; + + var unblock = function () { + if (!blocked) + return; // idempotent + blocked = false; + processNext(); + }; + + self.server.onMessageHook.each(function (callback) { + callback(msg, self); + return true; + }); + + if (_.has(self.protocol_handlers, msg.msg)) + self.protocol_handlers[msg.msg].call(self, msg, unblock); + else + self.sendError('Bad request', msg); + unblock(); // in case the handler didn't already do it + }).run(); + }; + + processNext(); + }, + + protocol_handlers: { + sub: function (msg) { + var self = this; + + // reject malformed messages + if (typeof (msg.id) !== "string" || + typeof (msg.name) !== "string" || + (('params' in msg) && !(msg.params instanceof Array))) { + self.sendError("Malformed subscription", msg); + return; + } + + if (!self.server.publish_handlers[msg.name]) { + self.send({ + msg: 'nosub', id: msg.id, + error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)}); + return; + } + + if (self._namedSubs.has(msg.id)) + // subs are idempotent, or rather, they are ignored if a sub + // with that id already exists. this is important during + // reconnect. + return; + + // XXX It'd be much better if we had generic hooks where any package can + // hook into subscription handling, but in the mean while we special case + // ddp-rate-limiter package. This is also done for weak requirements to + // add the ddp-rate-limiter package in case we don't have Accounts. A + // user trying to use the ddp-rate-limiter must explicitly require it. + if (Package['ddp-rate-limiter']) { + var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter; + var rateLimiterInput = { + userId: self.userId, + clientAddress: self.connectionHandle.clientAddress, + type: "subscription", + name: msg.name, + connectionId: self.id + }; + + DDPRateLimiter._increment(rateLimiterInput); + var rateLimitResult = DDPRateLimiter._check(rateLimiterInput); + if (!rateLimitResult.allowed) { + self.send({ + msg: 'nosub', id: msg.id, + error: new Meteor.Error( + 'too-many-requests', + DDPRateLimiter.getErrorMessage(rateLimitResult), + {timeToReset: rateLimitResult.timeToReset}) + }); + return; + } + } + + var handler = self.server.publish_handlers[msg.name]; + + self._startSubscription(handler, msg.id, msg.params, msg.name); + + }, + + unsub: function (msg) { + var self = this; + + self._stopSubscription(msg.id); + }, + + method: function (msg, unblock) { + var self = this; + + // reject malformed messages + // For now, we silently ignore unknown attributes, + // for forwards compatibility. + if (typeof (msg.id) !== "string" || + typeof (msg.method) !== "string" || + (('params' in msg) && !(msg.params instanceof Array)) || + (('randomSeed' in msg) && (typeof msg.randomSeed !== "string"))) { + self.sendError("Malformed method invocation", msg); + return; + } + + var randomSeed = msg.randomSeed || null; + + // set up to mark the method as satisfied once all observers + // (and subscriptions) have reacted to any writes that were + // done. + var fence = new DDPServer._WriteFence; + fence.onAllCommitted(function () { + // Retire the fence so that future writes are allowed. + // This means that callbacks like timers are free to use + // the fence, and if they fire before it's armed (for + // example, because the method waits for them) their + // writes will be included in the fence. + fence.retire(); + self.send({ + msg: 'updated', methods: [msg.id]}); + }); + + // find the handler + var handler = self.server.method_handlers[msg.method]; + if (!handler) { + self.send({ + msg: 'result', id: msg.id, + error: new Meteor.Error(404, `Method '${msg.method}' not found`)}); + fence.arm(); + return; + } + + var setUserId = function(userId) { + self._setUserId(userId); + }; + + var invocation = new DDPCommon.MethodInvocation({ + isSimulation: false, + userId: self.userId, + setUserId: setUserId, + unblock: unblock, + connection: self.connectionHandle, + randomSeed: randomSeed + }); + + const promise = new Promise((resolve, reject) => { + // XXX It'd be better if we could hook into method handlers better but + // for now, we need to check if the ddp-rate-limiter exists since we + // have a weak requirement for the ddp-rate-limiter package to be added + // to our application. + if (Package['ddp-rate-limiter']) { + var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter; + var rateLimiterInput = { + userId: self.userId, + clientAddress: self.connectionHandle.clientAddress, + type: "method", + name: msg.method, + connectionId: self.id + }; + DDPRateLimiter._increment(rateLimiterInput); + var rateLimitResult = DDPRateLimiter._check(rateLimiterInput) + if (!rateLimitResult.allowed) { + reject(new Meteor.Error( + "too-many-requests", + DDPRateLimiter.getErrorMessage(rateLimitResult), + {timeToReset: rateLimitResult.timeToReset} + )); + return; + } + } + + resolve(DDPServer._CurrentWriteFence.withValue( + fence, + () => DDP._CurrentMethodInvocation.withValue( + invocation, + () => maybeAuditArgumentChecks( + handler, invocation, msg.params, + "call to '" + msg.method + "'" + ) + ) + )); + }); + + function finish() { + fence.arm(); + unblock(); + } + + const payload = { + msg: "result", + id: msg.id + }; + + promise.then((result) => { + finish(); + if (result !== undefined) { + payload.result = result; + } + self.send(payload); + }, (exception) => { + finish(); + payload.error = wrapInternalException( + exception, + `while invoking method '${msg.method}'` + ); + self.send(payload); + }); + } + }, + + _eachSub: function (f) { + var self = this; + self._namedSubs.forEach(f); + self._universalSubs.forEach(f); + }, + + _diffCollectionViews: function (beforeCVs) { + var self = this; + DiffSequence.diffMaps(beforeCVs, self.collectionViews, { + both: function (collectionName, leftValue, rightValue) { + rightValue.diff(leftValue); + }, + rightOnly: function (collectionName, rightValue) { + rightValue.documents.forEach(function (docView, id) { + self.sendAdded(collectionName, id, docView.getFields()); + }); + }, + leftOnly: function (collectionName, leftValue) { + leftValue.documents.forEach(function (doc, id) { + self.sendRemoved(collectionName, id); + }); + } + }); + }, + + // Sets the current user id in all appropriate contexts and reruns + // all subscriptions + _setUserId: function(userId) { + var self = this; + + if (userId !== null && typeof userId !== "string") + throw new Error("setUserId must be called on string or null, not " + + typeof userId); + + // Prevent newly-created universal subscriptions from being added to our + // session; they will be found below when we call startUniversalSubs. + // + // (We don't have to worry about named subscriptions, because we only add + // them when we process a 'sub' message. We are currently processing a + // 'method' message, and the method did not unblock, because it is illegal + // to call setUserId after unblock. Thus we cannot be concurrently adding a + // new named subscription.) + self._dontStartNewUniversalSubs = true; + + // Prevent current subs from updating our collectionViews and call their + // stop callbacks. This may yield. + self._eachSub(function (sub) { + sub._deactivate(); + }); + + // All subs should now be deactivated. Stop sending messages to the client, + // save the state of the published collections, reset to an empty view, and + // update the userId. + self._isSending = false; + var beforeCVs = self.collectionViews; + self.collectionViews = new Map(); + self.userId = userId; + + // _setUserId is normally called from a Meteor method with + // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not + // expected to be set inside a publish function, so we temporary unset it. + // Inside a publish function DDP._CurrentPublicationInvocation is set. + DDP._CurrentMethodInvocation.withValue(undefined, function () { + // Save the old named subs, and reset to having no subscriptions. + var oldNamedSubs = self._namedSubs; + self._namedSubs = new Map(); + self._universalSubs = []; + + oldNamedSubs.forEach(function (sub, subscriptionId) { + var newSub = sub._recreate(); + self._namedSubs.set(subscriptionId, newSub); + // nb: if the handler throws or calls this.error(), it will in fact + // immediately send its 'nosub'. This is OK, though. + newSub._runHandler(); + }); + + // Allow newly-created universal subs to be started on our connection in + // parallel with the ones we're spinning up here, and spin up universal + // subs. + self._dontStartNewUniversalSubs = false; + self.startUniversalSubs(); + }); + + // Start sending messages again, beginning with the diff from the previous + // state of the world to the current state. No yields are allowed during + // this diff, so that other changes cannot interleave. + Meteor._noYieldsAllowed(function () { + self._isSending = true; + self._diffCollectionViews(beforeCVs); + if (!_.isEmpty(self._pendingReady)) { + self.sendReady(self._pendingReady); + self._pendingReady = []; + } + }); + }, + + _startSubscription: function (handler, subId, params, name) { + var self = this; + + var sub = new Subscription( + self, handler, subId, params, name); + if (subId) + self._namedSubs.set(subId, sub); + else + self._universalSubs.push(sub); + + sub._runHandler(); + }, + + // tear down specified subscription + _stopSubscription: function (subId, error) { + var self = this; + + var subName = null; + if (subId) { + var maybeSub = self._namedSubs.get(subId); + if (maybeSub) { + subName = maybeSub._name; + maybeSub._removeAllDocuments(); + maybeSub._deactivate(); + self._namedSubs.delete(subId); + } + } + + var response = {msg: 'nosub', id: subId}; + + if (error) { + response.error = wrapInternalException( + error, + subName ? ("from sub " + subName + " id " + subId) + : ("from sub id " + subId)); + } + + self.send(response); + }, + + // tear down all subscriptions. Note that this does NOT send removed or nosub + // messages, since we assume the client is gone. + _deactivateAllSubscriptions: function () { + var self = this; + + self._namedSubs.forEach(function (sub, id) { + sub._deactivate(); + }); + self._namedSubs = new Map(); + + self._universalSubs.forEach(function (sub) { + sub._deactivate(); + }); + self._universalSubs = []; + }, + + // Determine the remote client's IP address, based on the + // HTTP_FORWARDED_COUNT environment variable representing how many + // proxies the server is behind. + _clientAddress: function () { + var self = this; + + // For the reported client address for a connection to be correct, + // the developer must set the HTTP_FORWARDED_COUNT environment + // variable to an integer representing the number of hops they + // expect in the `x-forwarded-for` header. E.g., set to "1" if the + // server is behind one proxy. + // + // This could be computed once at startup instead of every time. + var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0; + + if (httpForwardedCount === 0) + return self.socket.remoteAddress; + + var forwardedFor = self.socket.headers["x-forwarded-for"]; + if (! _.isString(forwardedFor)) + return null; + forwardedFor = forwardedFor.trim().split(/\s*,\s*/); + + // Typically the first value in the `x-forwarded-for` header is + // the original IP address of the client connecting to the first + // proxy. However, the end user can easily spoof the header, in + // which case the first value(s) will be the fake IP address from + // the user pretending to be a proxy reporting the original IP + // address value. By counting HTTP_FORWARDED_COUNT back from the + // end of the list, we ensure that we get the IP address being + // reported by *our* first proxy. + + if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length) + return null; + + return forwardedFor[forwardedFor.length - httpForwardedCount]; + } +}); + +/******************************************************************************/ +/* Subscription */ +/******************************************************************************/ + +// ctor for a sub handle: the input to each publish function + +// Instance name is this because it's usually referred to as this inside a +// publish +/** + * @summary The server's side of a subscription + * @class Subscription + * @instanceName this + * @showInstanceName true + */ +var Subscription = function ( + session, handler, subscriptionId, params, name) { + var self = this; + self._session = session; // type is Session + + /** + * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription. + * @locus Server + * @name connection + * @memberOf Subscription + * @instance + */ + self.connection = session.connectionHandle; // public API object + + self._handler = handler; + + // my subscription ID (generated by client, undefined for universal subs). + self._subscriptionId = subscriptionId; + // undefined for universal subs + self._name = name; + + self._params = params || []; + + // Only named subscriptions have IDs, but we need some sort of string + // internally to keep track of all subscriptions inside + // SessionDocumentViews. We use this subscriptionHandle for that. + if (self._subscriptionId) { + self._subscriptionHandle = 'N' + self._subscriptionId; + } else { + self._subscriptionHandle = 'U' + Random.id(); + } + + // has _deactivate been called? + self._deactivated = false; + + // stop callbacks to g/c this sub. called w/ zero arguments. + self._stopCallbacks = []; + + // the set of (collection, documentid) that this subscription has + // an opinion about + self._documents = new Map(); + + // remember if we are ready. + self._ready = false; + + // Part of the public API: the user of this sub. + + /** + * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in. + * @locus Server + * @memberOf Subscription + * @name userId + * @instance + */ + self.userId = session.userId; + + // For now, the id filter is going to default to + // the to/from DDP methods on MongoID, to + // specifically deal with mongo/minimongo ObjectIds. + + // Later, you will be able to make this be "raw" + // if you want to publish a collection that you know + // just has strings for keys and no funny business, to + // a ddp consumer that isn't minimongo + + self._idFilter = { + idStringify: MongoID.idStringify, + idParse: MongoID.idParse + }; + + Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact( + "livedata", "subscriptions", 1); +}; + +_.extend(Subscription.prototype, { + _runHandler: function () { + // XXX should we unblock() here? Either before running the publish + // function, or before running _publishCursor. + // + // Right now, each publish function blocks all future publishes and + // methods waiting on data from Mongo (or whatever else the function + // blocks on). This probably slows page load in common cases. + + var self = this; + try { + var res = DDP._CurrentPublicationInvocation.withValue( + self, + () => maybeAuditArgumentChecks( + self._handler, self, EJSON.clone(self._params), + // It's OK that this would look weird for universal subscriptions, + // because they have no arguments so there can never be an + // audit-argument-checks failure. + "publisher '" + self._name + "'" + ) + ); + } catch (e) { + self.error(e); + return; + } + + // Did the handler call this.error or this.stop? + if (self._isDeactivated()) + return; + + self._publishHandlerResult(res); + }, + + _publishHandlerResult: function (res) { + // SPECIAL CASE: Instead of writing their own callbacks that invoke + // this.added/changed/ready/etc, the user can just return a collection + // cursor or array of cursors from the publish function; we call their + // _publishCursor method which starts observing the cursor and publishes the + // results. Note that _publishCursor does NOT call ready(). + // + // XXX This uses an undocumented interface which only the Mongo cursor + // interface publishes. Should we make this interface public and encourage + // users to implement it themselves? Arguably, it's unnecessary; users can + // already write their own functions like + // var publishMyReactiveThingy = function (name, handler) { + // Meteor.publish(name, function () { + // var reactiveThingy = handler(); + // reactiveThingy.publishMe(); + // }); + // }; + + var self = this; + var isCursor = function (c) { + return c && c._publishCursor; + }; + if (isCursor(res)) { + try { + res._publishCursor(self); + } catch (e) { + self.error(e); + return; + } + // _publishCursor only returns after the initial added callbacks have run. + // mark subscription as ready. + self.ready(); + } else if (_.isArray(res)) { + // check all the elements are cursors + if (! _.all(res, isCursor)) { + self.error(new Error("Publish function returned an array of non-Cursors")); + return; + } + // find duplicate collection names + // XXX we should support overlapping cursors, but that would require the + // merge box to allow overlap within a subscription + var collectionNames = {}; + for (var i = 0; i < res.length; ++i) { + var collectionName = res[i]._getCollectionName(); + if (_.has(collectionNames, collectionName)) { + self.error(new Error( + "Publish function returned multiple cursors for collection " + + collectionName)); + return; + } + collectionNames[collectionName] = true; + }; + + try { + _.each(res, function (cur) { + cur._publishCursor(self); + }); + } catch (e) { + self.error(e); + return; + } + self.ready(); + } else if (res) { + // truthy values other than cursors or arrays are probably a + // user mistake (possible returning a Mongo document via, say, + // `coll.findOne()`). + self.error(new Error("Publish function can only return a Cursor or " + + "an array of Cursors")); + } + }, + + // This calls all stop callbacks and prevents the handler from updating any + // SessionCollectionViews further. It's used when the user unsubscribes or + // disconnects, as well as during setUserId re-runs. It does *NOT* send + // removed messages for the published objects; if that is necessary, call + // _removeAllDocuments first. + _deactivate: function() { + var self = this; + if (self._deactivated) + return; + self._deactivated = true; + self._callStopCallbacks(); + Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact( + "livedata", "subscriptions", -1); + }, + + _callStopCallbacks: function () { + var self = this; + // tell listeners, so they can clean up + var callbacks = self._stopCallbacks; + self._stopCallbacks = []; + _.each(callbacks, function (callback) { + callback(); + }); + }, + + // Send remove messages for every document. + _removeAllDocuments: function () { + var self = this; + Meteor._noYieldsAllowed(function () { + self._documents.forEach(function (collectionDocs, collectionName) { + collectionDocs.forEach(function (strId) { + self.removed(collectionName, self._idFilter.idParse(strId)); + }); + }); + }); + }, + + // Returns a new Subscription for the same session with the same + // initial creation parameters. This isn't a clone: it doesn't have + // the same _documents cache, stopped state or callbacks; may have a + // different _subscriptionHandle, and gets its userId from the + // session, not from this object. + _recreate: function () { + var self = this; + return new Subscription( + self._session, self._handler, self._subscriptionId, self._params, + self._name); + }, + + /** + * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error). + * @locus Server + * @param {Error} error The error to pass to the client. + * @instance + * @memberOf Subscription + */ + error: function (error) { + var self = this; + if (self._isDeactivated()) + return; + self._session._stopSubscription(self._subscriptionId, error); + }, + + // Note that while our DDP client will notice that you've called stop() on the + // server (and clean up its _subscriptions table) we don't actually provide a + // mechanism for an app to notice this (the subscribe onError callback only + // triggers if there is an error). + + /** + * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error. + * @locus Server + * @instance + * @memberOf Subscription + */ + stop: function () { + var self = this; + if (self._isDeactivated()) + return; + self._session._stopSubscription(self._subscriptionId); + }, + + /** + * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped. + * @locus Server + * @memberOf Subscription + * @instance + * @param {Function} func The callback function + */ + onStop: function (callback) { + var self = this; + callback = Meteor.bindEnvironment(callback, 'onStop callback', self); + if (self._isDeactivated()) + callback(); + else + self._stopCallbacks.push(callback); + }, + + // This returns true if the sub has been deactivated, *OR* if the session was + // destroyed but the deferred call to _deactivateAllSubscriptions hasn't + // happened yet. + _isDeactivated: function () { + var self = this; + return self._deactivated || self._session.inQueue === null; + }, + + /** + * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set. + * @locus Server + * @memberOf Subscription + * @instance + * @param {String} collection The name of the collection that contains the new document. + * @param {String} id The new document's ID. + * @param {Object} fields The fields in the new document. If `_id` is present it is ignored. + */ + added: function (collectionName, id, fields) { + var self = this; + if (self._isDeactivated()) + return; + id = self._idFilter.idStringify(id); + let ids = self._documents.get(collectionName); + if (ids == null) { + ids = new Set(); + self._documents.set(collectionName, ids); + } + ids.add(id); + self._session.added(self._subscriptionHandle, collectionName, id, fields); + }, + + /** + * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified. + * @locus Server + * @memberOf Subscription + * @instance + * @param {String} collection The name of the collection that contains the changed document. + * @param {String} id The changed document's ID. + * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored. + */ + changed: function (collectionName, id, fields) { + var self = this; + if (self._isDeactivated()) + return; + id = self._idFilter.idStringify(id); + self._session.changed(self._subscriptionHandle, collectionName, id, fields); + }, + + /** + * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set. + * @locus Server + * @memberOf Subscription + * @instance + * @param {String} collection The name of the collection that the document has been removed from. + * @param {String} id The ID of the document that has been removed. + */ + removed: function (collectionName, id) { + var self = this; + if (self._isDeactivated()) + return; + id = self._idFilter.idStringify(id); + // We don't bother to delete sets of things in a collection if the + // collection is empty. It could break _removeAllDocuments. + self._documents.get(collectionName).delete(id); + self._session.removed(self._subscriptionHandle, collectionName, id); + }, + + /** + * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. + * @locus Server + * @memberOf Subscription + * @instance + */ + ready: function () { + var self = this; + if (self._isDeactivated()) + return; + if (!self._subscriptionId) + return; // unnecessary but ignored for universal sub + if (!self._ready) { + self._session.sendReady([self._subscriptionId]); + self._ready = true; + } + } +}); + +/******************************************************************************/ +/* Server */ +/******************************************************************************/ + +Server = function (options) { + var self = this; + + // The default heartbeat interval is 30 seconds on the server and 35 + // seconds on the client. Since the client doesn't need to send a + // ping as long as it is receiving pings, this means that pings + // normally go from the server to the client. + // + // Note: Troposphere depends on the ability to mutate + // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life. + self.options = _.defaults(options || {}, { + heartbeatInterval: 15000, + heartbeatTimeout: 15000, + // For testing, allow responding to pings to be disabled. + respondToPings: true + }); + + // Map of callbacks to call when a new connection comes in to the + // server and completes DDP version negotiation. Use an object instead + // of an array so we can safely remove one from the list while + // iterating over it. + self.onConnectionHook = new Hook({ + debugPrintExceptions: "onConnection callback" + }); + + // Map of callbacks to call when a new message comes in. + self.onMessageHook = new Hook({ + debugPrintExceptions: "onMessage callback" + }); + + self.publish_handlers = {}; + self.universal_publish_handlers = []; + + self.method_handlers = {}; + + self.sessions = new Map(); // map from id to session + + self.stream_server = new StreamServer; + + self.stream_server.register(function (socket) { + // socket implements the SockJSConnection interface + socket._meteorSession = null; + + var sendError = function (reason, offendingMessage) { + var msg = {msg: 'error', reason: reason}; + if (offendingMessage) + msg.offendingMessage = offendingMessage; + socket.send(DDPCommon.stringifyDDP(msg)); + }; + + socket.on('data', function (raw_msg) { + if (Meteor._printReceivedDDP) { + Meteor._debug("Received DDP", raw_msg); + } + try { + try { + var msg = DDPCommon.parseDDP(raw_msg); + } catch (err) { + sendError('Parse error'); + return; + } + if (msg === null || !msg.msg) { + sendError('Bad request', msg); + return; + } + + if (msg.msg === 'connect') { + if (socket._meteorSession) { + sendError("Already connected", msg); + return; + } + Fiber(function () { + self._handleConnect(socket, msg); + }).run(); + return; + } + + if (!socket._meteorSession) { + sendError('Must connect first', msg); + return; + } + socket._meteorSession.processMessage(msg); + } catch (e) { + // XXX print stack nicely + Meteor._debug("Internal exception while processing message", msg, e); + } + }); + + socket.on('close', function () { + if (socket._meteorSession) { + Fiber(function () { + socket._meteorSession.close(); + }).run(); + } + }); + }); +}; + +_.extend(Server.prototype, { + + /** + * @summary Register a callback to be called when a new DDP connection is made to the server. + * @locus Server + * @param {function} callback The function to call when a new DDP connection is established. + * @memberOf Meteor + * @importFromPackage meteor + */ + onConnection: function (fn) { + var self = this; + return self.onConnectionHook.register(fn); + }, + + /** + * @summary Register a callback to be called when a new DDP message is received. + * @locus Server + * @param {function} callback The function to call when a new DDP message is received. + * @memberOf Meteor + * @importFromPackage meteor + */ + onMessage: function (fn) { + var self = this; + return self.onMessageHook.register(fn); + }, + + _handleConnect: function (socket, msg) { + var self = this; + + // The connect message must specify a version and an array of supported + // versions, and it must claim to support what it is proposing. + if (!(typeof (msg.version) === 'string' && + _.isArray(msg.support) && + _.all(msg.support, _.isString) && + _.contains(msg.support, msg.version))) { + socket.send(DDPCommon.stringifyDDP({msg: 'failed', + version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]})); + socket.close(); + return; + } + + // In the future, handle session resumption: something like: + // socket._meteorSession = self.sessions[msg.session] + var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS); + + if (msg.version !== version) { + // The best version to use (according to the client's stated preferences) + // is not the one the client is trying to use. Inform them about the best + // version to use. + socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version})); + socket.close(); + return; + } + + // Yay, version matches! Create a new session. + // Note: Troposphere depends on the ability to mutate + // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life. + socket._meteorSession = new Session(self, version, socket, self.options); + self.sessions.set(socket._meteorSession.id, socket._meteorSession); + self.onConnectionHook.each(function (callback) { + if (socket._meteorSession) + callback(socket._meteorSession.connectionHandle); + return true; + }); + }, + /** + * Register a publish handler function. + * + * @param name {String} identifier for query + * @param handler {Function} publish handler + * @param options {Object} + * + * Server will call handler function on each new subscription, + * either when receiving DDP sub message for a named subscription, or on + * DDP connect for a universal subscription. + * + * If name is null, this will be a subscription that is + * automatically established and permanently on for all connected + * client, instead of a subscription that can be turned on and off + * with subscribe(). + * + * options to contain: + * - (mostly internal) is_auto: true if generated automatically + * from an autopublish hook. this is for cosmetic purposes only + * (it lets us determine whether to print a warning suggesting + * that you turn off autopublish.) + */ + + /** + * @summary Publish a record set. + * @memberOf Meteor + * @importFromPackage meteor + * @locus Server + * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients. + * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments. + */ + publish: function (name, handler, options) { + var self = this; + + if (! _.isObject(name)) { + options = options || {}; + + if (name && name in self.publish_handlers) { + Meteor._debug("Ignoring duplicate publish named '" + name + "'"); + return; + } + + if (Package.autopublish && !options.is_auto) { + // They have autopublish on, yet they're trying to manually + // picking stuff to publish. They probably should turn off + // autopublish. (This check isn't perfect -- if you create a + // publish before you turn on autopublish, it won't catch + // it. But this will definitely handle the simple case where + // you've added the autopublish package to your app, and are + // calling publish from your app code.) + if (!self.warned_about_autopublish) { + self.warned_about_autopublish = true; + Meteor._debug( + "** You've set up some data subscriptions with Meteor.publish(), but\n" + + "** you still have autopublish turned on. Because autopublish is still\n" + + "** on, your Meteor.publish() calls won't have much effect. All data\n" + + "** will still be sent to all clients.\n" + + "**\n" + + "** Turn off autopublish by removing the autopublish package:\n" + + "**\n" + + "** $ meteor remove autopublish\n" + + "**\n" + + "** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\n" + + "** for each collection that you want clients to see.\n"); + } + } + + if (name) + self.publish_handlers[name] = handler; + else { + self.universal_publish_handlers.push(handler); + // Spin up the new publisher on any existing session too. Run each + // session's subscription in a new Fiber, so that there's no change for + // self.sessions to change while we're running this loop. + self.sessions.forEach(function (session) { + if (!session._dontStartNewUniversalSubs) { + Fiber(function() { + session._startSubscription(handler); + }).run(); + } + }); + } + } + else{ + _.each(name, function(value, key) { + self.publish(key, value, {}); + }); + } + }, + + _removeSession: function (session) { + var self = this; + self.sessions.delete(session.id); + }, + + /** + * @summary Defines functions that can be invoked over the network by clients. + * @locus Anywhere + * @param {Object} methods Dictionary whose keys are method names and values are functions. + * @memberOf Meteor + * @importFromPackage meteor + */ + methods: function (methods) { + var self = this; + _.each(methods, function (func, name) { + if (typeof func !== 'function') + throw new Error("Method '" + name + "' must be a function"); + if (self.method_handlers[name]) + throw new Error("A method named '" + name + "' is already defined"); + self.method_handlers[name] = func; + }); + }, + + call: function (name, ...args) { + if (args.length && typeof args[args.length - 1] === "function") { + // If it's a function, the last argument is the result callback, not + // a parameter to the remote method. + var callback = args.pop(); + } + + return this.apply(name, args, callback); + }, + + // A version of the call method that always returns a Promise. + callAsync: function (name, ...args) { + return this.applyAsync(name, args); + }, + + apply: function (name, args, options, callback) { + // We were passed 3 arguments. They may be either (name, args, options) + // or (name, args, callback) + if (! callback && typeof options === 'function') { + callback = options; + options = {}; + } else { + options = options || {}; + } + + const promise = this.applyAsync(name, args, options); + + // Return the result in whichever way the caller asked for it. Note that we + // do NOT block on the write fence in an analogous way to how the client + // blocks on the relevant data being visible, so you are NOT guaranteed that + // cursor observe callbacks have fired when your callback is invoked. (We + // can change this if there's a real use case.) + if (callback) { + promise.then( + result => callback(undefined, result), + exception => callback(exception) + ); + } else { + return promise.await(); + } + }, + + // @param options {Optional Object} + applyAsync: function (name, args, options) { + // Run the handler + var handler = this.method_handlers[name]; + if (! handler) { + return Promise.reject( + new Meteor.Error(404, `Method '${name}' not found`) + ); + } + + // If this is a method call from within another method or publish function, + // get the user state from the outer method or publish function, otherwise + // don't allow setUserId to be called + var userId = null; + var setUserId = function() { + throw new Error("Can't call setUserId on a server initiated method call"); + }; + var connection = null; + var currentMethodInvocation = DDP._CurrentMethodInvocation.get(); + var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get(); + var randomSeed = null; + if (currentMethodInvocation) { + userId = currentMethodInvocation.userId; + setUserId = function(userId) { + currentMethodInvocation.setUserId(userId); + }; + connection = currentMethodInvocation.connection; + randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name); + } else if (currentPublicationInvocation) { + userId = currentPublicationInvocation.userId; + setUserId = function(userId) { + currentPublicationInvocation._session._setUserId(userId); + }; + connection = currentPublicationInvocation.connection; + } + + var invocation = new DDPCommon.MethodInvocation({ + isSimulation: false, + userId, + setUserId, + connection, + randomSeed + }); + + return new Promise(resolve => resolve( + DDP._CurrentMethodInvocation.withValue( + invocation, + () => maybeAuditArgumentChecks( + handler, invocation, EJSON.clone(args), + "internal call to '" + name + "'" + ) + ) + )).then(EJSON.clone); + }, + + _urlForSession: function (sessionId) { + var self = this; + var session = self.sessions.get(sessionId); + if (session) + return session._socketUrl; + else + return null; + } +}); + +var calculateVersion = function (clientSupportedVersions, + serverSupportedVersions) { + var correctVersion = _.find(clientSupportedVersions, function (version) { + return _.contains(serverSupportedVersions, version); + }); + if (!correctVersion) { + correctVersion = serverSupportedVersions[0]; + } + return correctVersion; +}; + +DDPServer._calculateVersion = calculateVersion; + + +// "blind" exceptions other than those that were deliberately thrown to signal +// errors to the client +var wrapInternalException = function (exception, context) { + if (!exception) return exception; + + // To allow packages to throw errors intended for the client but not have to + // depend on the Meteor.Error class, `isClientSafe` can be set to true on any + // error before it is thrown. + if (exception.isClientSafe) { + if (!(exception instanceof Meteor.Error)) { + const originalMessage = exception.message; + exception = new Meteor.Error(exception.error, exception.reason, exception.details); + exception.message = originalMessage; + } + return exception; + } + + // Tests can set the '_expectedByTest' flag on an exception so it won't go to + // the server log. + if (!exception._expectedByTest) { + Meteor._debug("Exception " + context, exception.stack); + if (exception.sanitizedError) { + Meteor._debug("Sanitized and reported to the client as:", exception.sanitizedError); + Meteor._debug(); + } + } + + // Did the error contain more details that could have been useful if caught in + // server code (or if thrown from non-client-originated code), but also + // provided a "sanitized" version with more context than 500 Internal server + // error? Use that. + if (exception.sanitizedError) { + if (exception.sanitizedError.isClientSafe) + return exception.sanitizedError; + Meteor._debug("Exception " + context + " provides a sanitizedError that " + + "does not have isClientSafe property set; ignoring"); + } + + return new Meteor.Error(500, "Internal server error"); +}; + + +// Audit argument checks, if the audit-argument-checks package exists (it is a +// weak dependency of this package). +var maybeAuditArgumentChecks = function (f, context, args, description) { + args = args || []; + if (Package['audit-argument-checks']) { + return Match._failIfArgumentsAreNotAllChecked( + f, context, args, description); + } + return f.apply(context, args); +}; diff --git a/creator/packages/ddp-server/livedata_server_tests.js b/creator/packages/ddp-server/livedata_server_tests.js new file mode 100644 index 0000000000..cde56b6196 --- /dev/null +++ b/creator/packages/ddp-server/livedata_server_tests.js @@ -0,0 +1,411 @@ +var Fiber = Npm.require('fibers'); + + +Tinytest.addAsync( + "livedata server - connectionHandle.onClose()", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + // On the server side, wait for the connection to be closed. + serverConn.onClose(function () { + test.isTrue(true); + // Add a new onClose after the connection is already + // closed. See that it fires. + serverConn.onClose(function () { + onComplete(); + }); + }); + // Close the connection from the client. + clientConn.disconnect(); + }, + onComplete + ); + } +); + +Tinytest.addAsync( + "livedata server - connectionHandle.close()", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + // Wait for the connection to be closed from the server side. + simplePoll( + function () { + return ! clientConn.status().connected; + }, + onComplete, + function () { + test.fail("timeout waiting for the connection to be closed on the server side"); + onComplete(); + } + ); + + // Close the connection from the server. + serverConn.close(); + }, + onComplete + ); + } +); + + +testAsyncMulti( + "livedata server - onConnection doesn't get callback after stop.", + [function (test, expect) { + var afterStop = false; + var expectStop1 = expect(); + var stopHandle1 = Meteor.onConnection(function (conn) { + stopHandle2.stop(); + stopHandle1.stop(); + afterStop = true; + // yield to the event loop for a moment to see that no other calls + // to listener2 are called. + Meteor.setTimeout(expectStop1, 10); + }); + var stopHandle2 = Meteor.onConnection(function (conn) { + test.isFalse(afterStop); + }); + + // trigger a connection + var expectConnection = expect(); + makeTestConnection( + test, + function (clientConn, serverConn) { + // Close the connection from the client. + clientConn.disconnect(); + expectConnection(); + }, + expectConnection + ); + }] +); + +Meteor.methods({ + livedata_server_test_inner: function () { + return this.connection && this.connection.id; + }, + + livedata_server_test_outer: function () { + return Meteor.call('livedata_server_test_inner'); + }, + + livedata_server_test_setuserid: function (userId) { + this.setUserId(userId); + } +}); + + +Tinytest.addAsync( + "livedata server - onMessage hook", + function (test, onComplete) { + + var cb = Meteor.onMessage(function (msg, session) { + test.equal(msg.method, 'livedata_server_test_inner'); + cb.stop(); + onComplete(); + }); + + makeTestConnection( + test, + function (clientConn, serverConn) { + clientConn.call('livedata_server_test_inner'); + clientConn.disconnect(); + }, + onComplete + ); + } +); + + +Tinytest.addAsync( + "livedata server - connection in method invocation", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + var res = clientConn.call('livedata_server_test_inner'); + test.equal(res, serverConn.id); + clientConn.disconnect(); + onComplete(); + }, + onComplete + ); + } +); + + +Tinytest.addAsync( + "livedata server - connection in nested method invocation", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + var res = clientConn.call('livedata_server_test_outer'); + test.equal(res, serverConn.id); + clientConn.disconnect(); + onComplete(); + }, + onComplete + ); + } +); + + +// connectionId -> callback +var onSubscription = {}; + +Meteor.publish("livedata_server_test_sub", function (connectionId) { + var callback = onSubscription[connectionId]; + if (callback) + callback(this); + this.stop(); +}); + +Meteor.publish("livedata_server_test_sub_method", function (connectionId) { + var callback = onSubscription[connectionId]; + if (callback) { + var id = Meteor.call('livedata_server_test_inner'); + callback(id); + } + this.stop(); +}); + +Meteor.publish("livedata_server_test_sub_context", function (connectionId, userId) { + var callback = onSubscription[connectionId]; + var methodInvocation = DDP._CurrentMethodInvocation.get(); + var publicationInvocation = DDP._CurrentPublicationInvocation.get(); + + // Check the publish function's environment variables and context. + if (callback) { + callback.call(this, methodInvocation, publicationInvocation); + } + + // Check that onStop callback is have the same context as the publish function + // and that it runs with the same environment variables as this publish function. + this.onStop(function () { + var onStopMethodInvocation = DDP._CurrentMethodInvocation.get(); + var onStopPublicationInvocation = DDP._CurrentPublicationInvocation.get(); + callback.call(this, onStopMethodInvocation, onStopPublicationInvocation, true); + }); + + if (this.userId) { + this.stop(); + } else { + this.ready(); + Meteor.call('livedata_server_test_setuserid', userId); + } +}); + + +Tinytest.addAsync( + "livedata server - connection in publish function", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + onSubscription[serverConn.id] = function (subscription) { + delete onSubscription[serverConn.id]; + test.equal(subscription.connection.id, serverConn.id); + clientConn.disconnect(); + onComplete(); + }; + clientConn.subscribe("livedata_server_test_sub", serverConn.id); + } + ); + } +); + +Tinytest.addAsync( + "livedata server - connection in method called from publish function", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + onSubscription[serverConn.id] = function (id) { + delete onSubscription[serverConn.id]; + test.equal(id, serverConn.id); + clientConn.disconnect(); + onComplete(); + }; + clientConn.subscribe("livedata_server_test_sub_method", serverConn.id); + } + ); + } +); + +Tinytest.addAsync( + "livedata server - verify context in publish function", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + var userId = 'someUserId'; + onSubscription[serverConn.id] = function (methodInvocation, publicationInvocation, fromOnStop) { + // DDP._CurrentMethodInvocation should be undefined in a publish function + test.isUndefined(methodInvocation, 'Should have been undefined'); + // DDP._CurrentPublicationInvocation should be set in a publish function + test.isNotUndefined(publicationInvocation, 'Should have been defined'); + if (this.userId === userId && fromOnStop) { + delete onSubscription[serverConn.id]; + clientConn.disconnect(); + onComplete(); + } + } + clientConn.subscribe("livedata_server_test_sub_context", serverConn.id, userId); + } + ); + } +); + +let onSubscriptions = {}; + +Meteor.publish({ + publicationObject () { + let callback = onSubscriptions; + if (callback) + callback(); + this.stop(); + } +}); + +Meteor.publish({ + "publication_object": function () { + let callback = onSubscriptions; + if (callback) + callback(); + this.stop(); + } +}); + +Meteor.publish("publication_compatibility", function () { + let callback = onSubscriptions; + if (callback) + callback(); + this.stop(); +}); + +Tinytest.addAsync( + "livedata server - publish object", + function (test, onComplete) { + makeTestConnection( + test, + function (clientConn, serverConn) { + let testsLength = 0; + + onSubscriptions = function (subscription) { + delete onSubscriptions; + clientConn.disconnect(); + testsLength++; + if(testsLength == 3){ + onComplete(); + } + }; + clientConn.subscribe("publicationObject"); + clientConn.subscribe("publication_object"); + clientConn.subscribe("publication_compatibility"); + } + ); + } +); + +Meteor.methods({ + testResolvedPromise(arg) { + const invocation1 = DDP._CurrentMethodInvocation.get(); + return Promise.resolve(arg).then(result => { + const invocation2 = DDP._CurrentMethodInvocation.get(); + // This equality holds because Promise callbacks are bound to the + // dynamic environment where .then was called. + if (invocation1 !== invocation2) { + throw new Meteor.Error("invocation mismatch"); + } + return result + " after waiting"; + }); + }, + + testRejectedPromise(arg) { + return Promise.resolve(arg).then(result => { + throw new Meteor.Error(result + " raised Meteor.Error"); + }); + }, + + testRejectedPromiseWithGenericError(arg) { + return Promise.resolve(arg).then(result => { + const error = new Error('MESSAGE'); + error.error = 'ERROR'; + error.reason = 'REASON'; + error.details = { foo: 'bar' }; + error.isClientSafe = true; + throw error; + }); + } +}); + +Tinytest.addAsync( + "livedata server - waiting for Promise", + (test, onComplete) => makeTestConnection(test, (clientConn, serverConn) => { + test.equal( + clientConn.call("testResolvedPromise", "clientConn.call"), + "clientConn.call after waiting" + ); + + const clientCallPromise = new Promise( + (resolve, reject) => clientConn.call( + "testResolvedPromise", + "clientConn.call with callback", + (error, result) => error ? reject(error) : resolve(result) + ) + ); + + const serverCallAsyncPromise = Meteor.server.callAsync( + "testResolvedPromise", + "Meteor.server.callAsync" + ); + + const serverApplyAsyncPromise = Meteor.server.applyAsync( + "testResolvedPromise", + ["Meteor.server.applyAsync"] + ); + + const clientCallRejectedPromise = new Promise(resolve => { + clientConn.call( + "testRejectedPromise", + "with callback", + (error, result) => resolve(error.message) + ); + }); + + const clientCallRejectedPromiseWithGenericError = new Promise(resolve => { + clientConn.call( + "testRejectedPromiseWithGenericError", + (error, result) => resolve({ + message: error.message, + error: error.error, + reason: error.reason, + details: error.details, + }) + ); + }); + + Promise.all([ + clientCallPromise, + clientCallRejectedPromise, + clientCallRejectedPromiseWithGenericError, + serverCallAsyncPromise, + serverApplyAsyncPromise + ]).then(results => test.equal(results, [ + "clientConn.call with callback after waiting", + "[with callback raised Meteor.Error]", + { + message: 'REASON [ERROR]', + error: 'ERROR', + reason: 'REASON', + details: { foo: 'bar' }, + }, + "Meteor.server.callAsync after waiting", + "Meteor.server.applyAsync after waiting" + ]), error => test.fail(error)) + .then(onComplete); + }) +); diff --git a/creator/packages/ddp-server/package.js b/creator/packages/ddp-server/package.js new file mode 100644 index 0000000000..a662b14325 --- /dev/null +++ b/creator/packages/ddp-server/package.js @@ -0,0 +1,60 @@ +Package.describe({ + summary: "Meteor's latency-compensated distributed data server", + version: '2.3.0', + documentation: null +}); + +Npm.depends({ + "permessage-deflate": "0.1.6", + sockjs: "0.3.19" +}); + +Package.onUse(function (api) { + api.use(['check', 'random', 'ejson', 'underscore', + 'retry', 'mongo-id', 'diff-sequence', 'ecmascript'], + 'server'); + + // common functionality + api.use('ddp-common', 'server'); // heartbeat + api.use('ddp-rate-limiter', 'server', {weak: true}); + // Transport + api.use('ddp-client', 'server'); + api.imply('ddp-client'); + + api.use(['webapp', 'routepolicy'], 'server'); + + // Detect whether or not the user wants us to audit argument checks. + api.use(['audit-argument-checks'], 'server', {weak: true}); + + // Allow us to detect 'autopublish', so we can print a warning if the user + // runs Meteor.publish while it's loaded. + api.use('autopublish', 'server', {weak: true}); + + // If the facts package is loaded, publish some statistics. + api.use('facts-base', 'server', {weak: true}); + + api.use('callback-hook', 'server'); + api.export('DDPServer', 'server'); + + api.addFiles('stream_server.js', 'server'); + + api.addFiles('livedata_server.js', 'server'); + api.addFiles('writefence.js', 'server'); + api.addFiles('crossbar.js', 'server'); + + api.addFiles('server_convenience.js', 'server'); +}); + + + +Package.onTest(function (api) { + api.use('ecmascript', ['client', 'server']); + api.use('livedata', ['client', 'server']); + api.use('mongo', ['client', 'server']); + api.use('test-helpers', ['client', 'server']); + api.use(['underscore', 'tinytest', 'random', 'tracker', 'minimongo', 'reactive-var']); + + api.addFiles('livedata_server_tests.js', 'server'); + api.addFiles('session_view_tests.js', ['server']); + api.addFiles('crossbar_tests.js', ['server']); +}); diff --git a/creator/packages/ddp-server/server_convenience.js b/creator/packages/ddp-server/server_convenience.js new file mode 100755 index 0000000000..28fca40b2b --- /dev/null +++ b/creator/packages/ddp-server/server_convenience.js @@ -0,0 +1,22 @@ +if (process.env.DDP_DEFAULT_CONNECTION_URL) { + __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL = + process.env.DDP_DEFAULT_CONNECTION_URL; +} + +Meteor.server = new Server; + +Meteor.refresh = function (notification) { + DDPServer._InvalidationCrossbar.fire(notification); +}; + +// Proxy the public methods of Meteor.server so they can +// be called directly on Meteor. +_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'], + function (name) { + Meteor[name] = _.bind(Meteor.server[name], Meteor.server); + }); + +// Meteor.server used to be called Meteor.default_server. Provide +// backcompat as a courtesy even though it was never documented. +// XXX COMPAT WITH 0.6.4 +Meteor.default_server = Meteor.server; diff --git a/creator/packages/ddp-server/session_view_tests.js b/creator/packages/ddp-server/session_view_tests.js new file mode 100644 index 0000000000..0459a45107 --- /dev/null +++ b/creator/packages/ddp-server/session_view_tests.js @@ -0,0 +1,393 @@ +var newView = function(test) { + var results = []; + var view = new DDPServer._SessionCollectionView('test', { + added: function (collection, id, fields) { + results.push({fun: 'added', id: id, fields: fields}); + }, + changed: function (collection, id, changed) { + if (_.isEmpty(changed)) + return; + results.push({fun: 'changed', id: id, changed: changed}); + }, + removed: function (collection, id) { + results.push({fun: 'removed', id: id}); + } + }); + var v = { + view: view, + results: results + }; + _.each(["added", "changed", "removed"], function (it) { + v[it] = _.bind(view[it], view); + }); + v.expectResult = function (result) { + test.equal(results.shift(), result); + }; + v.expectNoResult = function () { + test.equal(results, []); + }; + v.drain = function() { + var ret = results; + results = []; + return ret; + }; + return v; +}; + +Tinytest.add('livedata - sessionview - exists reveal', function (test) { + var v = newView(test); + + v.added("A", "A1", {}); + v.expectResult({fun: 'added', id: "A1", fields: {}}); + v.expectNoResult(); + + v.added("B", "A1", {}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectNoResult(); + + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - added a second field in another sub', function (test) { + var v = newView(test); + + v.added("A", "A1", {a: "foo"}); + v.expectResult({fun: 'added', id: "A1", fields: {a: "foo"}}); + v.expectNoResult(); + + v.added("B", "A1", {a: "foo", b: "bar"}); + v.expectResult({fun: 'changed', 'id': "A1", changed: {b: "bar"}}); + + v.removed("A", "A1"); + v.expectNoResult(); + + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + + +Tinytest.add('livedata - sessionview - field reveal', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.added("B", "A1", {foo: "baz"}); + v.removed("A", "A1"); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: "baz"}}); + v.expectNoResult(); + // Somewhere in here we must have changed foo to baz. Legal either on the + // added or on the removed, but only once. + + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - field change', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.changed("A", "A1", {foo: "baz"}, []); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: "baz"}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - field clear', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.changed("A", "A1", {foo: undefined}); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: undefined}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - change makes a new field', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.changed("A", "A1", {baz:"quux"}); + v.expectResult({fun: 'changed', id: "A1", changed: {baz: "quux"}}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - add, remove, add', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + +}); + +Tinytest.add('livedata - sessionview - field clear reveal', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + + v.added("B", "A1", {foo: "baz"}); + v.changed("A", "A1", {foo: undefined}); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: "baz"}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - change to canonical value produces no change', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + + v.added("B", "A1", {foo: "baz"}); + var canon = "bar"; + var maybeResults = v.drain(); + if (!_.isEmpty(maybeResults)) { + // if something happened, it was a change message to baz. + // if nothing did, canon is still bar. + test.length(maybeResults, 1); + test.equal(maybeResults[0], {fun: 'changed', id: "A1", changed: {foo: "baz"}}); + canon = "baz"; + } + v.changed("B", "A1", {foo: canon}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - new field of canonical value produces no change', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + + v.added("B", "A1", {}); + + v.changed("B", "A1", {foo: "bar"}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - clear all clears only once', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.added("B", "A1", {foo: "bar"}); + v.added("C", "A1", {foo: "bar"}); + v.changed("A", "A1", {foo: undefined}); + v.changed("B", "A1", {foo: undefined}); + v.changed("C", "A1", {foo: undefined}); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: undefined}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - change all changes only once', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar"}}); + v.expectNoResult(); + + v.added("B", "A1", {foo: "bar"}); + v.added("C", "A1", {foo: "bar"}); + v.changed("B", "A1", {foo: "baz"}); + v.changed("A", "A1", {foo: "baz"}); + v.changed("C", "A1", {foo: "baz"}); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: "baz"}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - multiple operations at once in a change', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar", baz: "quux"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar", baz: "quux"}}); + v.expectNoResult(); + + + v.added("B", "A1", {foo: "baz"}); + v.changed("A", "A1", {thing: "stuff", foo: undefined, baz: undefined}); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: "baz", thing: "stuff", baz: undefined}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectResult({fun: 'changed', id: "A1", changed: {thing: undefined}}); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - more than one document', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar", baz: "quux"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar", baz: "quux"}}); + v.expectNoResult(); + + + v.added("A", "A2", {foo: "baz"}); + v.expectResult({fun: 'added', id: "A2", fields: {foo: "baz"}}); + v.changed("A", "A1", {thing: "stuff", foo: undefined, baz: undefined}); + v.expectResult({fun: 'changed', id: "A1", changed: {thing: "stuff", foo: undefined, baz: undefined}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); + v.removed("A", "A2"); + v.expectResult({fun: 'removed', id: "A2"}); + v.expectNoResult(); + +}); + +Tinytest.add('livedata - sessionview - multiple docs removed', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar", baz: "quux"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar", baz: "quux"}}); + v.expectNoResult(); + + + v.added("A", "A2", {foo: "baz"}); + v.expectResult({fun: 'added', id: "A2", fields: {foo: "baz"}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.removed("A", "A2"); + v.expectResult({fun: 'removed', id: "A2"}); + v.expectNoResult(); +}); + + +Tinytest.add('livedata - sessionview - complicated sequence', function (test) { + var v = newView(test); + + v.added("A", "A1", {foo: "bar", baz: "quux"}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: "bar", baz: "quux"}}); + v.expectNoResult(); + + v.added("A", "A2", {foo: "eats"}); + v.expectResult({fun: 'added', id: "A2", fields: {foo: "eats"}}); + + v.added("B", "A1", {foo: "baz"}); + v.changed("A", "A1", {thing: "stuff", foo: undefined, baz: undefined}); + v.expectResult({fun: 'changed', id: "A1", changed: {foo: "baz", thing: "stuff", baz: undefined}}); + v.expectNoResult(); + + v.removed("A", "A1"); + v.removed("A", "A2"); + v.expectResult({fun: 'changed', id: "A1", changed: {thing: undefined}}); + v.expectResult({fun: 'removed', id: "A2"}); + v.expectNoResult(); + v.removed("B", "A1"); + v.expectResult({fun: 'removed', id: "A1"}); + v.expectNoResult(); +}); + +Tinytest.add('livedata - sessionview - added becomes changed', function (test) { + var v = newView(test); + + v.added('A', "A1", {foo: 'bar'}); + v.expectResult({fun: 'added', id: "A1", fields: {foo: 'bar'}}); + + v.added('B', "A1", {hi: 'there'}); + v.expectResult({fun: 'changed', id: 'A1', changed: {hi: 'there'}}); + + v.removed('A', 'A1'); + v.expectResult({fun: 'changed', id: 'A1', changed: {foo: undefined}}); + + v.removed('B', 'A1'); + v.expectResult({fun: 'removed', id: 'A1'}); +}); + +Tinytest.add('livedata - sessionview - weird key names', function (test) { + var v = newView(test); + + v.added('A', "A1", {}); + v.expectResult({fun: 'added', id: "A1", fields: {}}); + + v.changed('A', "A1", {constructor: 'bla'}); + v.expectResult({fun: 'changed', id: 'A1', changed: {constructor: 'bla'}}); +}); + +Tinytest.add('livedata - sessionview - clear undefined value', function (test) { + var v = newView(test); + + v.added("A", "A1", {field: "value"}); + v.expectResult({fun: 'added', id: "A1", fields: {field: "value"}}); + v.expectNoResult(); + + v.changed("A", "A1", {field: undefined}); + v.expectResult({fun: 'changed', id: 'A1', changed: {field: undefined}}); + v.expectNoResult(); + + v.changed("A", "A1", {field: undefined}); + v.expectNoResult(); + +}); diff --git a/creator/packages/ddp-server/stream_server.js b/creator/packages/ddp-server/stream_server.js new file mode 100644 index 0000000000..1996d9088c --- /dev/null +++ b/creator/packages/ddp-server/stream_server.js @@ -0,0 +1,184 @@ +var url = Npm.require('url'); + +// By default, we use the permessage-deflate extension with default +// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid +// JSON. If it represents a falsey value, then we do not use permessage-deflate +// at all; otherwise, the JSON value is used as an argument to deflate's +// configure method; see +// https://github.com/faye/permessage-deflate-node/blob/master/README.md +// +// (We do this in an _.once instead of at startup, because we don't want to +// crash the tool during isopacket load if your JSON doesn't parse. This is only +// a problem because the tool has to load the DDP server code just in order to +// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .) +var websocketExtensions = _.once(function () { + var extensions = []; + + var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION + ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {}; + if (websocketCompressionConfig) { + extensions.push(Npm.require('permessage-deflate').configure( + websocketCompressionConfig + )); + } + + return extensions; +}); + +var pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || ""; + +StreamServer = function () { + var self = this; + self.registration_callbacks = []; + self.open_sockets = []; + + // Because we are installing directly onto WebApp.httpServer instead of using + // WebApp.app, we have to process the path prefix ourselves. + self.prefix = pathPrefix + '/sockjs'; + RoutePolicy.declare(self.prefix + '/', 'network'); + + // set up sockjs + var sockjs = Npm.require('sockjs'); + var serverOptions = { + prefix: self.prefix, + log: function() {}, + // this is the default, but we code it explicitly because we depend + // on it in stream_client:HEARTBEAT_TIMEOUT + heartbeat_delay: 45000, + // The default disconnect_delay is 5 seconds, but if the server ends up CPU + // bound for that much time, SockJS might not notice that the user has + // reconnected because the timer (of disconnect_delay ms) can fire before + // SockJS processes the new connection. Eventually we'll fix this by not + // combining CPU-heavy processing with SockJS termination (eg a proxy which + // converts to Unix sockets) but for now, raise the delay. + disconnect_delay: 60 * 1000, + // Set the USE_JSESSIONID environment variable to enable setting the + // JSESSIONID cookie. This is useful for setting up proxies with + // session affinity. + jsessionid: !!process.env.USE_JSESSIONID + }; + + // If you know your server environment (eg, proxies) will prevent websockets + // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie, + // browsers) will not waste time attempting to use them. + // (Your server will still have a /websocket endpoint.) + if (process.env.DISABLE_WEBSOCKETS) { + serverOptions.websocket = false; + } else { + serverOptions.faye_server_options = { + extensions: websocketExtensions() + }; + } + + self.server = sockjs.createServer(serverOptions); + + // Install the sockjs handlers, but we want to keep around our own particular + // request handler that adjusts idle timeouts while we have an outstanding + // request. This compensates for the fact that sockjs removes all listeners + // for "request" to add its own. + WebApp.httpServer.removeListener( + 'request', WebApp._timeoutAdjustmentRequestCallback); + self.server.installHandlers(WebApp.httpServer); + WebApp.httpServer.addListener( + 'request', WebApp._timeoutAdjustmentRequestCallback); + + // Support the /websocket endpoint + self._redirectWebsocketEndpoint(); + + self.server.on('connection', function (socket) { + // We want to make sure that if a client connects to us and does the initial + // Websocket handshake but never gets to the DDP handshake, that we + // eventually kill the socket. Once the DDP handshake happens, DDP + // heartbeating will work. And before the Websocket handshake, the timeouts + // we set at the server level in webapp_server.js will work. But + // faye-websocket calls setTimeout(0) on any socket it takes over, so there + // is an "in between" state where this doesn't happen. We work around this + // by explicitly setting the socket timeout to a relatively large time here, + // and setting it back to zero when we set up the heartbeat in + // livedata_server.js. + socket.setWebsocketTimeout = function (timeout) { + if ((socket.protocol === 'websocket' || + socket.protocol === 'websocket-raw') + && socket._session.recv) { + socket._session.recv.connection.setTimeout(timeout); + } + }; + socket.setWebsocketTimeout(45 * 1000); + + socket.send = function (data) { + socket.write(data); + }; + socket.on('close', function () { + self.open_sockets = _.without(self.open_sockets, socket); + }); + self.open_sockets.push(socket); + + // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which + // will force old clients to reload. Remove this once we're not + // concerned about people upgrading from a pre-0.7.0 release. Also, + // remove the clause in the client that ignores the welcome message + // (livedata_connection.js) + socket.send(JSON.stringify({server_id: "0"})); + + // call all our callbacks when we get a new socket. they will do the + // work of setting up handlers and such for specific messages. + _.each(self.registration_callbacks, function (callback) { + callback(socket); + }); + }); + +}; + +_.extend(StreamServer.prototype, { + // call my callback when a new socket connects. + // also call it for all current connections. + register: function (callback) { + var self = this; + self.registration_callbacks.push(callback); + _.each(self.all_sockets(), function (socket) { + callback(socket); + }); + }, + + // get a list of all sockets + all_sockets: function () { + var self = this; + return _.values(self.open_sockets); + }, + + // Redirect /websocket to /sockjs/websocket in order to not expose + // sockjs to clients that want to use raw websockets + _redirectWebsocketEndpoint: function() { + var self = this; + // Unfortunately we can't use a connect middleware here since + // sockjs installs itself prior to all existing listeners + // (meaning prior to any connect middlewares) so we need to take + // an approach similar to overshadowListeners in + // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee + _.each(['request', 'upgrade'], function(event) { + var httpServer = WebApp.httpServer; + var oldHttpServerListeners = httpServer.listeners(event).slice(0); + httpServer.removeAllListeners(event); + + // request and upgrade have different arguments passed but + // we only care about the first one which is always request + var newListener = function(request /*, moreArguments */) { + // Store arguments for use within the closure below + var args = arguments; + + // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while + // preserving query string. + var parsedUrl = url.parse(request.url); + if (parsedUrl.pathname === pathPrefix + '/websocket' || + parsedUrl.pathname === pathPrefix + '/websocket/') { + parsedUrl.pathname = self.prefix + '/websocket'; + request.url = url.format(parsedUrl); + } + _.each(oldHttpServerListeners, function(oldListener) { + oldListener.apply(httpServer, args); + }); + }; + httpServer.addListener(event, newListener); + }); + } +}); diff --git a/creator/packages/ddp-server/writefence.js b/creator/packages/ddp-server/writefence.js new file mode 100644 index 0000000000..e9310c9f7f --- /dev/null +++ b/creator/packages/ddp-server/writefence.js @@ -0,0 +1,131 @@ +var Future = Npm.require('fibers/future'); + +// A write fence collects a group of writes, and provides a callback +// when all of the writes are fully committed and propagated (all +// observers have been notified of the write and acknowledged it.) +// +DDPServer._WriteFence = function () { + var self = this; + + self.armed = false; + self.fired = false; + self.retired = false; + self.outstanding_writes = 0; + self.before_fire_callbacks = []; + self.completion_callbacks = []; +}; + +// The current write fence. When there is a current write fence, code +// that writes to databases should register their writes with it using +// beginWrite(). +// +DDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable; + +_.extend(DDPServer._WriteFence.prototype, { + // Start tracking a write, and return an object to represent it. The + // object has a single method, committed(). This method should be + // called when the write is fully committed and propagated. You can + // continue to add writes to the WriteFence up until it is triggered + // (calls its callbacks because all writes have committed.) + beginWrite: function () { + var self = this; + + if (self.retired) + return { committed: function () {} }; + + if (self.fired) + throw new Error("fence has already activated -- too late to add writes"); + + self.outstanding_writes++; + var committed = false; + return { + committed: function () { + if (committed) + throw new Error("committed called twice on the same write"); + committed = true; + self.outstanding_writes--; + self._maybeFire(); + } + }; + }, + + // Arm the fence. Once the fence is armed, and there are no more + // uncommitted writes, it will activate. + arm: function () { + var self = this; + if (self === DDPServer._CurrentWriteFence.get()) + throw Error("Can't arm the current fence"); + self.armed = true; + self._maybeFire(); + }, + + // Register a function to be called once before firing the fence. + // Callback function can add new writes to the fence, in which case + // it won't fire until those writes are done as well. + onBeforeFire: function (func) { + var self = this; + if (self.fired) + throw new Error("fence has already activated -- too late to " + + "add a callback"); + self.before_fire_callbacks.push(func); + }, + + // Register a function to be called when the fence fires. + onAllCommitted: function (func) { + var self = this; + if (self.fired) + throw new Error("fence has already activated -- too late to " + + "add a callback"); + self.completion_callbacks.push(func); + }, + + // Convenience function. Arms the fence, then blocks until it fires. + armAndWait: function () { + var self = this; + var future = new Future; + self.onAllCommitted(function () { + future['return'](); + }); + self.arm(); + future.wait(); + }, + + _maybeFire: function () { + var self = this; + if (self.fired) + throw new Error("write fence already activated?"); + if (self.armed && !self.outstanding_writes) { + function invokeCallback (func) { + try { + func(self); + } catch (err) { + Meteor._debug("exception in write fence callback", err); + } + } + + self.outstanding_writes++; + while (self.before_fire_callbacks.length > 0) { + var callbacks = self.before_fire_callbacks; + self.before_fire_callbacks = []; + _.each(callbacks, invokeCallback); + } + self.outstanding_writes--; + + if (!self.outstanding_writes) { + self.fired = true; + var callbacks = self.completion_callbacks; + self.completion_callbacks = []; + _.each(callbacks, invokeCallback); + } + } + }, + + // Deactivate this fence so that adding more writes has no effect. + // The fence must have already fired. + retire: function () { + var self = this; + if (! self.fired) + throw new Error("Can't retire a fence that hasn't fired."); + self.retired = true; + } +}); diff --git a/server/bundle/programs/server/packages/ddp-server.js b/server/bundle/programs/server/packages/ddp-server.js index 7ac14f117c..4cd5085e6d 100644 --- a/server/bundle/programs/server/packages/ddp-server.js +++ b/server/bundle/programs/server/packages/ddp-server.js @@ -1854,7 +1854,7 @@ var wrapInternalException = function (exception, context) { if (!exception._expectedByTest) { - Meteor._debug("Exception " + context, exception); + Meteor._debug("Exception " + context, exception.stack); if (exception.sanitizedError) { Meteor._debug("Sanitized and reported to the client as:", exception.sanitizedError); @@ -2245,4 +2245,4 @@ Package._define("ddp-server", { })(); //# sourceURL=meteor://💻app/packages/ddp-server.js -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n  var extensions = [];\n\n  var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n        ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n  if (websocketCompressionConfig) {\n    extensions.push(Npm.require('permessage-deflate').configure(\n      websocketCompressionConfig\n    ));\n  }\n\n  return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX ||  \"\";\n\nStreamServer = function () {\n  var self = this;\n  self.registration_callbacks = [];\n  self.open_sockets = [];\n\n  // Because we are installing directly onto WebApp.httpServer instead of using\n  // WebApp.app, we have to process the path prefix ourselves.\n  self.prefix = pathPrefix + '/sockjs';\n  RoutePolicy.declare(self.prefix + '/', 'network');\n\n  // set up sockjs\n  var sockjs = Npm.require('sockjs');\n  var serverOptions = {\n    prefix: self.prefix,\n    log: function() {},\n    // this is the default, but we code it explicitly because we depend\n    // on it in stream_client:HEARTBEAT_TIMEOUT\n    heartbeat_delay: 45000,\n    // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n    // bound for that much time, SockJS might not notice that the user has\n    // reconnected because the timer (of disconnect_delay ms) can fire before\n    // SockJS processes the new connection. Eventually we'll fix this by not\n    // combining CPU-heavy processing with SockJS termination (eg a proxy which\n    // converts to Unix sockets) but for now, raise the delay.\n    disconnect_delay: 60 * 1000,\n    // Set the USE_JSESSIONID environment variable to enable setting the\n    // JSESSIONID cookie. This is useful for setting up proxies with\n    // session affinity.\n    jsessionid: !!process.env.USE_JSESSIONID\n  };\n\n  // If you know your server environment (eg, proxies) will prevent websockets\n  // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n  // browsers) will not waste time attempting to use them.\n  // (Your server will still have a /websocket endpoint.)\n  if (process.env.DISABLE_WEBSOCKETS) {\n    serverOptions.websocket = false;\n  } else {\n    serverOptions.faye_server_options = {\n      extensions: websocketExtensions()\n    };\n  }\n\n  self.server = sockjs.createServer(serverOptions);\n\n  // Install the sockjs handlers, but we want to keep around our own particular\n  // request handler that adjusts idle timeouts while we have an outstanding\n  // request.  This compensates for the fact that sockjs removes all listeners\n  // for \"request\" to add its own.\n  WebApp.httpServer.removeListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n  self.server.installHandlers(WebApp.httpServer);\n  WebApp.httpServer.addListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n\n  // Support the /websocket endpoint\n  self._redirectWebsocketEndpoint();\n\n  self.server.on('connection', function (socket) {\n    // We want to make sure that if a client connects to us and does the initial\n    // Websocket handshake but never gets to the DDP handshake, that we\n    // eventually kill the socket.  Once the DDP handshake happens, DDP\n    // heartbeating will work. And before the Websocket handshake, the timeouts\n    // we set at the server level in webapp_server.js will work. But\n    // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n    // is an \"in between\" state where this doesn't happen.  We work around this\n    // by explicitly setting the socket timeout to a relatively large time here,\n    // and setting it back to zero when we set up the heartbeat in\n    // livedata_server.js.\n    socket.setWebsocketTimeout = function (timeout) {\n      if ((socket.protocol === 'websocket' ||\n           socket.protocol === 'websocket-raw')\n          && socket._session.recv) {\n        socket._session.recv.connection.setTimeout(timeout);\n      }\n    };\n    socket.setWebsocketTimeout(45 * 1000);\n\n    socket.send = function (data) {\n      socket.write(data);\n    };\n    socket.on('close', function () {\n      self.open_sockets = _.without(self.open_sockets, socket);\n    });\n    self.open_sockets.push(socket);\n\n    // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n    // will force old clients to reload. Remove this once we're not\n    // concerned about people upgrading from a pre-0.7.0 release. Also,\n    // remove the clause in the client that ignores the welcome message\n    // (livedata_connection.js)\n    socket.send(JSON.stringify({server_id: \"0\"}));\n\n    // call all our callbacks when we get a new socket. they will do the\n    // work of setting up handlers and such for specific messages.\n    _.each(self.registration_callbacks, function (callback) {\n      callback(socket);\n    });\n  });\n\n};\n\n_.extend(StreamServer.prototype, {\n  // call my callback when a new socket connects.\n  // also call it for all current connections.\n  register: function (callback) {\n    var self = this;\n    self.registration_callbacks.push(callback);\n    _.each(self.all_sockets(), function (socket) {\n      callback(socket);\n    });\n  },\n\n  // get a list of all sockets\n  all_sockets: function () {\n    var self = this;\n    return _.values(self.open_sockets);\n  },\n\n  // Redirect /websocket to /sockjs/websocket in order to not expose\n  // sockjs to clients that want to use raw websockets\n  _redirectWebsocketEndpoint: function() {\n    var self = this;\n    // Unfortunately we can't use a connect middleware here since\n    // sockjs installs itself prior to all existing listeners\n    // (meaning prior to any connect middlewares) so we need to take\n    // an approach similar to overshadowListeners in\n    // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n    _.each(['request', 'upgrade'], function(event) {\n      var httpServer = WebApp.httpServer;\n      var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n      httpServer.removeAllListeners(event);\n\n      // request and upgrade have different arguments passed but\n      // we only care about the first one which is always request\n      var newListener = function(request /*, moreArguments */) {\n        // Store arguments for use within the closure below\n        var args = arguments;\n\n        // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n        // preserving query string.\n        var parsedUrl = url.parse(request.url);\n        if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n            parsedUrl.pathname === pathPrefix + '/websocket/') {\n          parsedUrl.pathname = self.prefix + '/websocket';\n          request.url = url.format(parsedUrl);\n        }\n        _.each(oldHttpServerListeners, function(oldListener) {\n          oldListener.apply(httpServer, args);\n        });\n      };\n      httpServer.addListener(event, newListener);\n    });\n  }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n  var self = this;\n  self.existsIn = new Set(); // set of subscriptionHandle\n  self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n  getFields: function () {\n    var self = this;\n    var ret = {};\n    self.dataByKey.forEach(function (precedenceList, key) {\n      ret[key] = precedenceList[0].value;\n    });\n    return ret;\n  },\n\n  clearField: function (subscriptionHandle, key, changeCollector) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n    var precedenceList = self.dataByKey.get(key);\n\n    // It's okay to clear fields that didn't exist. No need to throw\n    // an error.\n    if (!precedenceList)\n      return;\n\n    var removedValue = undefined;\n    for (var i = 0; i < precedenceList.length; i++) {\n      var precedence = precedenceList[i];\n      if (precedence.subscriptionHandle === subscriptionHandle) {\n        // The view's value can only change if this subscription is the one that\n        // used to have precedence.\n        if (i === 0)\n          removedValue = precedence.value;\n        precedenceList.splice(i, 1);\n        break;\n      }\n    }\n    if (precedenceList.length === 0) {\n      self.dataByKey.delete(key);\n      changeCollector[key] = undefined;\n    } else if (removedValue !== undefined &&\n               !EJSON.equals(removedValue, precedenceList[0].value)) {\n      changeCollector[key] = precedenceList[0].value;\n    }\n  },\n\n  changeField: function (subscriptionHandle, key, value,\n                         changeCollector, isAdd) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n\n    // Don't share state with the data passed in by the user.\n    value = EJSON.clone(value);\n\n    if (!self.dataByKey.has(key)) {\n      self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n                                value: value}]);\n      changeCollector[key] = value;\n      return;\n    }\n    var precedenceList = self.dataByKey.get(key);\n    var elt;\n    if (!isAdd) {\n      elt = precedenceList.find(function (precedence) {\n          return precedence.subscriptionHandle === subscriptionHandle;\n      });\n    }\n\n    if (elt) {\n      if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n        // this subscription is changing the value of this field.\n        changeCollector[key] = value;\n      }\n      elt.value = value;\n    } else {\n      // this subscription is newly caring about this field\n      precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n    }\n\n  }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n  var self = this;\n  self.collectionName = collectionName;\n  self.documents = new Map();\n  self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n  isEmpty: function () {\n    var self = this;\n    return self.documents.size === 0;\n  },\n\n  diff: function (previous) {\n    var self = this;\n    DiffSequence.diffMaps(previous.documents, self.documents, {\n      both: _.bind(self.diffDocument, self),\n\n      rightOnly: function (id, nowDV) {\n        self.callbacks.added(self.collectionName, id, nowDV.getFields());\n      },\n\n      leftOnly: function (id, prevDV) {\n        self.callbacks.removed(self.collectionName, id);\n      }\n    });\n  },\n\n  diffDocument: function (id, prevDV, nowDV) {\n    var self = this;\n    var fields = {};\n    DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n      both: function (key, prev, now) {\n        if (!EJSON.equals(prev, now))\n          fields[key] = now;\n      },\n      rightOnly: function (key, now) {\n        fields[key] = now;\n      },\n      leftOnly: function(key, prev) {\n        fields[key] = undefined;\n      }\n    });\n    self.callbacks.changed(self.collectionName, id, fields);\n  },\n\n  added: function (subscriptionHandle, id, fields) {\n    var self = this;\n    var docView = self.documents.get(id);\n    var added = false;\n    if (!docView) {\n      added = true;\n      docView = new SessionDocumentView();\n      self.documents.set(id, docView);\n    }\n    docView.existsIn.add(subscriptionHandle);\n    var changeCollector = {};\n    _.each(fields, function (value, key) {\n      docView.changeField(\n        subscriptionHandle, key, value, changeCollector, true);\n    });\n    if (added)\n      self.callbacks.added(self.collectionName, id, changeCollector);\n    else\n      self.callbacks.changed(self.collectionName, id, changeCollector);\n  },\n\n  changed: function (subscriptionHandle, id, changed) {\n    var self = this;\n    var changedResult = {};\n    var docView = self.documents.get(id);\n    if (!docView)\n      throw new Error(\"Could not find element with id \" + id + \" to change\");\n    _.each(changed, function (value, key) {\n      if (value === undefined)\n        docView.clearField(subscriptionHandle, key, changedResult);\n      else\n        docView.changeField(subscriptionHandle, key, value, changedResult);\n    });\n    self.callbacks.changed(self.collectionName, id, changedResult);\n  },\n\n  removed: function (subscriptionHandle, id) {\n    var self = this;\n    var docView = self.documents.get(id);\n    if (!docView) {\n      var err = new Error(\"Removed nonexistent document \" + id);\n      throw err;\n    }\n    docView.existsIn.delete(subscriptionHandle);\n    if (docView.existsIn.size === 0) {\n      // it is gone from everyone\n      self.callbacks.removed(self.collectionName, id);\n      self.documents.delete(id);\n    } else {\n      var changed = {};\n      // remove this subscription from every precedence list\n      // and record the changes\n      docView.dataByKey.forEach(function (precedenceList, key) {\n        docView.clearField(subscriptionHandle, key, changed);\n      });\n\n      self.callbacks.changed(self.collectionName, id, changed);\n    }\n  }\n});\n\n/******************************************************************************/\n/* Session                                                                    */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n  var self = this;\n  self.id = Random.id();\n\n  self.server = server;\n  self.version = version;\n\n  self.initialized = false;\n  self.socket = socket;\n\n  // set to null when the session is destroyed. multiple places below\n  // use this to determine if the session is alive or not.\n  self.inQueue = new Meteor._DoubleEndedQueue();\n\n  self.blocked = false;\n  self.workerRunning = false;\n\n  // Sub objects for active subscriptions\n  self._namedSubs = new Map();\n  self._universalSubs = [];\n\n  self.userId = null;\n\n  self.collectionViews = new Map();\n\n  // Set this to false to not send messages when collectionViews are\n  // modified. This is done when rerunning subs in _setUserId and those messages\n  // are calculated via a diff instead.\n  self._isSending = true;\n\n  // If this is true, don't start a newly-created universal publisher on this\n  // session. The session will take care of starting it when appropriate.\n  self._dontStartNewUniversalSubs = false;\n\n  // when we are rerunning subscriptions, any ready messages\n  // we want to buffer up for when we are done rerunning subscriptions\n  self._pendingReady = [];\n\n  // List of callbacks to call when this connection is closed.\n  self._closeCallbacks = [];\n\n\n  // XXX HACK: If a sockjs connection, save off the URL. This is\n  // temporary and will go away in the near future.\n  self._socketUrl = socket.url;\n\n  // Allow tests to disable responding to pings.\n  self._respondToPings = options.respondToPings;\n\n  // This object is the public interface to the session. In the public\n  // API, it is called the `connection` object.  Internally we call it\n  // a `connectionHandle` to avoid ambiguity.\n  self.connectionHandle = {\n    id: self.id,\n    close: function () {\n      self.close();\n    },\n    onClose: function (fn) {\n      var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n      if (self.inQueue) {\n        self._closeCallbacks.push(cb);\n      } else {\n        // if we're already closed, call the callback.\n        Meteor.defer(cb);\n      }\n    },\n    clientAddress: self._clientAddress(),\n    httpHeaders: self.socket.headers\n  };\n\n  self.send({ msg: 'connected', session: self.id });\n\n  // On initial connect, spin up all the universal publishers.\n  Fiber(function () {\n    self.startUniversalSubs();\n  }).run();\n\n  if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n    // We no longer need the low level timeout because we have heartbeating.\n    socket.setWebsocketTimeout(0);\n\n    self.heartbeat = new DDPCommon.Heartbeat({\n      heartbeatInterval: options.heartbeatInterval,\n      heartbeatTimeout: options.heartbeatTimeout,\n      onTimeout: function () {\n        self.close();\n      },\n      sendPing: function () {\n        self.send({msg: 'ping'});\n      }\n    });\n    self.heartbeat.start();\n  }\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n  sendReady: function (subscriptionIds) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"ready\", subs: subscriptionIds});\n    else {\n      _.each(subscriptionIds, function (subscriptionId) {\n        self._pendingReady.push(subscriptionId);\n      });\n    }\n  },\n\n  sendAdded: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n  },\n\n  sendChanged: function (collectionName, id, fields) {\n    var self = this;\n    if (_.isEmpty(fields))\n      return;\n\n    if (self._isSending) {\n      self.send({\n        msg: \"changed\",\n        collection: collectionName,\n        id: id,\n        fields: fields\n      });\n    }\n  },\n\n  sendRemoved: function (collectionName, id) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"removed\", collection: collectionName, id: id});\n  },\n\n  getSendCallbacks: function () {\n    var self = this;\n    return {\n      added: _.bind(self.sendAdded, self),\n      changed: _.bind(self.sendChanged, self),\n      removed: _.bind(self.sendRemoved, self)\n    };\n  },\n\n  getCollectionView: function (collectionName) {\n    var self = this;\n    var ret = self.collectionViews.get(collectionName);\n    if (!ret) {\n      ret = new SessionCollectionView(collectionName,\n                                        self.getSendCallbacks());\n      self.collectionViews.set(collectionName, ret);\n    }\n    return ret;\n  },\n\n  added: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.added(subscriptionHandle, id, fields);\n  },\n\n  removed: function (subscriptionHandle, collectionName, id) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.removed(subscriptionHandle, id);\n    if (view.isEmpty()) {\n       self.collectionViews.delete(collectionName);\n    }\n  },\n\n  changed: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.changed(subscriptionHandle, id, fields);\n  },\n\n  startUniversalSubs: function () {\n    var self = this;\n    // Make a shallow copy of the set of universal handlers and start them. If\n    // additional universal publishers start while we're running them (due to\n    // yielding), they will run separately as part of Server.publish.\n    var handlers = _.clone(self.server.universal_publish_handlers);\n    _.each(handlers, function (handler) {\n      self._startSubscription(handler);\n    });\n  },\n\n  // Destroy this session and unregister it at the server.\n  close: function () {\n    var self = this;\n\n    // Destroy this session, even if it's not registered at the\n    // server. Stop all processing and tear everything down. If a socket\n    // was attached, close it.\n\n    // Already destroyed.\n    if (! self.inQueue)\n      return;\n\n    // Drop the merge box data immediately.\n    self.inQueue = null;\n    self.collectionViews = new Map();\n\n    if (self.heartbeat) {\n      self.heartbeat.stop();\n      self.heartbeat = null;\n    }\n\n    if (self.socket) {\n      self.socket.close();\n      self.socket._meteorSession = null;\n    }\n\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"sessions\", -1);\n\n    Meteor.defer(function () {\n      // stop callbacks can yield, so we defer this on close.\n      // sub._isDeactivated() detects that we set inQueue to null and\n      // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n      self._deactivateAllSubscriptions();\n\n      // Defer calling the close callbacks, so that the caller closing\n      // the session isn't waiting for all the callbacks to complete.\n      _.each(self._closeCallbacks, function (callback) {\n        callback();\n      });\n    });\n\n    // Unregister the session.\n    self.server._removeSession(self);\n  },\n\n  // Send a message (doing nothing if no socket is connected right now.)\n  // It should be a JSON object (it will be stringified.)\n  send: function (msg) {\n    var self = this;\n    if (self.socket) {\n      if (Meteor._printSentDDP)\n        Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n      self.socket.send(DDPCommon.stringifyDDP(msg));\n    }\n  },\n\n  // Send a connection error.\n  sendError: function (reason, offendingMessage) {\n    var self = this;\n    var msg = {msg: 'error', reason: reason};\n    if (offendingMessage)\n      msg.offendingMessage = offendingMessage;\n    self.send(msg);\n  },\n\n  // Process 'msg' as an incoming message. (But as a guard against\n  // race conditions during reconnection, ignore the message if\n  // 'socket' is not the currently connected socket.)\n  //\n  // We run the messages from the client one at a time, in the order\n  // given by the client. The message handler is passed an idempotent\n  // function 'unblock' which it may call to allow other messages to\n  // begin running in parallel in another fiber (for example, a method\n  // that wants to yield.) Otherwise, it is automatically unblocked\n  // when it returns.\n  //\n  // Actually, we don't have to 'totally order' the messages in this\n  // way, but it's the easiest thing that's correct. (unsub needs to\n  // be ordered against sub, methods need to be ordered against each\n  // other.)\n  processMessage: function (msg_in) {\n    var self = this;\n    if (!self.inQueue) // we have been destroyed.\n      return;\n\n    // Respond to ping and pong messages immediately without queuing.\n    // If the negotiated DDP version is \"pre1\" which didn't support\n    // pings, preserve the \"pre1\" behavior of responding with a \"bad\n    // request\" for the unknown messages.\n    //\n    // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n    // needs a Fiber. We could actually use regular setTimeout and avoid\n    // these new fibers, but it is easier to just make everything use\n    // Meteor.setTimeout and not think too hard.\n    //\n    // Any message counts as receiving a pong, as it demonstrates that\n    // the client is still alive.\n    if (self.heartbeat) {\n      Fiber(function () {\n        self.heartbeat.messageReceived();\n      }).run();\n    }\n\n    if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n      if (self._respondToPings)\n        self.send({msg: \"pong\", id: msg_in.id});\n      return;\n    }\n    if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n      // Since everything is a pong, nothing to do\n      return;\n    }\n\n    self.inQueue.push(msg_in);\n    if (self.workerRunning)\n      return;\n    self.workerRunning = true;\n\n    var processNext = function () {\n      var msg = self.inQueue && self.inQueue.shift();\n      if (!msg) {\n        self.workerRunning = false;\n        return;\n      }\n\n      Fiber(function () {\n        var blocked = true;\n\n        var unblock = function () {\n          if (!blocked)\n            return; // idempotent\n          blocked = false;\n          processNext();\n        };\n\n        self.server.onMessageHook.each(function (callback) {\n          callback(msg, self);\n          return true;\n        });\n\n        if (_.has(self.protocol_handlers, msg.msg))\n          self.protocol_handlers[msg.msg].call(self, msg, unblock);\n        else\n          self.sendError('Bad request', msg);\n        unblock(); // in case the handler didn't already do it\n      }).run();\n    };\n\n    processNext();\n  },\n\n  protocol_handlers: {\n    sub: function (msg) {\n      var self = this;\n\n      // reject malformed messages\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.name) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array))) {\n        self.sendError(\"Malformed subscription\", msg);\n        return;\n      }\n\n      if (!self.server.publish_handlers[msg.name]) {\n        self.send({\n          msg: 'nosub', id: msg.id,\n          error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n        return;\n      }\n\n      if (self._namedSubs.has(msg.id))\n        // subs are idempotent, or rather, they are ignored if a sub\n        // with that id already exists. this is important during\n        // reconnect.\n        return;\n\n      // XXX It'd be much better if we had generic hooks where any package can\n      // hook into subscription handling, but in the mean while we special case\n      // ddp-rate-limiter package. This is also done for weak requirements to\n      // add the ddp-rate-limiter package in case we don't have Accounts. A\n      // user trying to use the ddp-rate-limiter must explicitly require it.\n      if (Package['ddp-rate-limiter']) {\n        var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n        var rateLimiterInput = {\n          userId: self.userId,\n          clientAddress: self.connectionHandle.clientAddress,\n          type: \"subscription\",\n          name: msg.name,\n          connectionId: self.id\n        };\n\n        DDPRateLimiter._increment(rateLimiterInput);\n        var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n        if (!rateLimitResult.allowed) {\n          self.send({\n            msg: 'nosub', id: msg.id,\n            error: new Meteor.Error(\n              'too-many-requests',\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset})\n          });\n          return;\n        }\n      }\n\n      var handler = self.server.publish_handlers[msg.name];\n\n      self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n    },\n\n    unsub: function (msg) {\n      var self = this;\n\n      self._stopSubscription(msg.id);\n    },\n\n    method: function (msg, unblock) {\n      var self = this;\n\n      // reject malformed messages\n      // For now, we silently ignore unknown attributes,\n      // for forwards compatibility.\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.method) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array)) ||\n          (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n        self.sendError(\"Malformed method invocation\", msg);\n        return;\n      }\n\n      var randomSeed = msg.randomSeed || null;\n\n      // set up to mark the method as satisfied once all observers\n      // (and subscriptions) have reacted to any writes that were\n      // done.\n      var fence = new DDPServer._WriteFence;\n      fence.onAllCommitted(function () {\n        // Retire the fence so that future writes are allowed.\n        // This means that callbacks like timers are free to use\n        // the fence, and if they fire before it's armed (for\n        // example, because the method waits for them) their\n        // writes will be included in the fence.\n        fence.retire();\n        self.send({\n          msg: 'updated', methods: [msg.id]});\n      });\n\n      // find the handler\n      var handler = self.server.method_handlers[msg.method];\n      if (!handler) {\n        self.send({\n          msg: 'result', id: msg.id,\n          error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n        fence.arm();\n        return;\n      }\n\n      var setUserId = function(userId) {\n        self._setUserId(userId);\n      };\n\n      var invocation = new DDPCommon.MethodInvocation({\n        isSimulation: false,\n        userId: self.userId,\n        setUserId: setUserId,\n        unblock: unblock,\n        connection: self.connectionHandle,\n        randomSeed: randomSeed\n      });\n\n      const promise = new Promise((resolve, reject) => {\n        // XXX It'd be better if we could hook into method handlers better but\n        // for now, we need to check if the ddp-rate-limiter exists since we\n        // have a weak requirement for the ddp-rate-limiter package to be added\n        // to our application.\n        if (Package['ddp-rate-limiter']) {\n          var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n          var rateLimiterInput = {\n            userId: self.userId,\n            clientAddress: self.connectionHandle.clientAddress,\n            type: \"method\",\n            name: msg.method,\n            connectionId: self.id\n          };\n          DDPRateLimiter._increment(rateLimiterInput);\n          var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n          if (!rateLimitResult.allowed) {\n            reject(new Meteor.Error(\n              \"too-many-requests\",\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset}\n            ));\n            return;\n          }\n        }\n\n        resolve(DDPServer._CurrentWriteFence.withValue(\n          fence,\n          () => DDP._CurrentMethodInvocation.withValue(\n            invocation,\n            () => maybeAuditArgumentChecks(\n              handler, invocation, msg.params,\n              \"call to '\" + msg.method + \"'\"\n            )\n          )\n        ));\n      });\n\n      function finish() {\n        fence.arm();\n        unblock();\n      }\n\n      const payload = {\n        msg: \"result\",\n        id: msg.id\n      };\n\n      promise.then((result) => {\n        finish();\n        if (result !== undefined) {\n          payload.result = result;\n        }\n        self.send(payload);\n      }, (exception) => {\n        finish();\n        payload.error = wrapInternalException(\n          exception,\n          `while invoking method '${msg.method}'`\n        );\n        self.send(payload);\n      });\n    }\n  },\n\n  _eachSub: function (f) {\n    var self = this;\n    self._namedSubs.forEach(f);\n    self._universalSubs.forEach(f);\n  },\n\n  _diffCollectionViews: function (beforeCVs) {\n    var self = this;\n    DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n      both: function (collectionName, leftValue, rightValue) {\n        rightValue.diff(leftValue);\n      },\n      rightOnly: function (collectionName, rightValue) {\n        rightValue.documents.forEach(function (docView, id) {\n          self.sendAdded(collectionName, id, docView.getFields());\n        });\n      },\n      leftOnly: function (collectionName, leftValue) {\n        leftValue.documents.forEach(function (doc, id) {\n          self.sendRemoved(collectionName, id);\n        });\n      }\n    });\n  },\n\n  // Sets the current user id in all appropriate contexts and reruns\n  // all subscriptions\n  _setUserId: function(userId) {\n    var self = this;\n\n    if (userId !== null && typeof userId !== \"string\")\n      throw new Error(\"setUserId must be called on string or null, not \" +\n                      typeof userId);\n\n    // Prevent newly-created universal subscriptions from being added to our\n    // session; they will be found below when we call startUniversalSubs.\n    //\n    // (We don't have to worry about named subscriptions, because we only add\n    // them when we process a 'sub' message. We are currently processing a\n    // 'method' message, and the method did not unblock, because it is illegal\n    // to call setUserId after unblock. Thus we cannot be concurrently adding a\n    // new named subscription.)\n    self._dontStartNewUniversalSubs = true;\n\n    // Prevent current subs from updating our collectionViews and call their\n    // stop callbacks. This may yield.\n    self._eachSub(function (sub) {\n      sub._deactivate();\n    });\n\n    // All subs should now be deactivated. Stop sending messages to the client,\n    // save the state of the published collections, reset to an empty view, and\n    // update the userId.\n    self._isSending = false;\n    var beforeCVs = self.collectionViews;\n    self.collectionViews = new Map();\n    self.userId = userId;\n\n    // _setUserId is normally called from a Meteor method with\n    // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n    // expected to be set inside a publish function, so we temporary unset it.\n    // Inside a publish function DDP._CurrentPublicationInvocation is set.\n    DDP._CurrentMethodInvocation.withValue(undefined, function () {\n      // Save the old named subs, and reset to having no subscriptions.\n      var oldNamedSubs = self._namedSubs;\n      self._namedSubs = new Map();\n      self._universalSubs = [];\n\n      oldNamedSubs.forEach(function (sub, subscriptionId) {\n        var newSub = sub._recreate();\n        self._namedSubs.set(subscriptionId, newSub);\n        // nb: if the handler throws or calls this.error(), it will in fact\n        // immediately send its 'nosub'. This is OK, though.\n        newSub._runHandler();\n      });\n\n      // Allow newly-created universal subs to be started on our connection in\n      // parallel with the ones we're spinning up here, and spin up universal\n      // subs.\n      self._dontStartNewUniversalSubs = false;\n      self.startUniversalSubs();\n    });\n\n    // Start sending messages again, beginning with the diff from the previous\n    // state of the world to the current state. No yields are allowed during\n    // this diff, so that other changes cannot interleave.\n    Meteor._noYieldsAllowed(function () {\n      self._isSending = true;\n      self._diffCollectionViews(beforeCVs);\n      if (!_.isEmpty(self._pendingReady)) {\n        self.sendReady(self._pendingReady);\n        self._pendingReady = [];\n      }\n    });\n  },\n\n  _startSubscription: function (handler, subId, params, name) {\n    var self = this;\n\n    var sub = new Subscription(\n      self, handler, subId, params, name);\n    if (subId)\n      self._namedSubs.set(subId, sub);\n    else\n      self._universalSubs.push(sub);\n\n    sub._runHandler();\n  },\n\n  // tear down specified subscription\n  _stopSubscription: function (subId, error) {\n    var self = this;\n\n    var subName = null;\n    if (subId) {\n      var maybeSub = self._namedSubs.get(subId);\n      if (maybeSub) {\n        subName = maybeSub._name;\n        maybeSub._removeAllDocuments();\n        maybeSub._deactivate();\n        self._namedSubs.delete(subId);\n      }\n    }\n\n    var response = {msg: 'nosub', id: subId};\n\n    if (error) {\n      response.error = wrapInternalException(\n        error,\n        subName ? (\"from sub \" + subName + \" id \" + subId)\n          : (\"from sub id \" + subId));\n    }\n\n    self.send(response);\n  },\n\n  // tear down all subscriptions. Note that this does NOT send removed or nosub\n  // messages, since we assume the client is gone.\n  _deactivateAllSubscriptions: function () {\n    var self = this;\n\n    self._namedSubs.forEach(function (sub, id) {\n      sub._deactivate();\n    });\n    self._namedSubs = new Map();\n\n    self._universalSubs.forEach(function (sub) {\n      sub._deactivate();\n    });\n    self._universalSubs = [];\n  },\n\n  // Determine the remote client's IP address, based on the\n  // HTTP_FORWARDED_COUNT environment variable representing how many\n  // proxies the server is behind.\n  _clientAddress: function () {\n    var self = this;\n\n    // For the reported client address for a connection to be correct,\n    // the developer must set the HTTP_FORWARDED_COUNT environment\n    // variable to an integer representing the number of hops they\n    // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n    // server is behind one proxy.\n    //\n    // This could be computed once at startup instead of every time.\n    var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n    if (httpForwardedCount === 0)\n      return self.socket.remoteAddress;\n\n    var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n    if (! _.isString(forwardedFor))\n      return null;\n    forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n    // Typically the first value in the `x-forwarded-for` header is\n    // the original IP address of the client connecting to the first\n    // proxy.  However, the end user can easily spoof the header, in\n    // which case the first value(s) will be the fake IP address from\n    // the user pretending to be a proxy reporting the original IP\n    // address value.  By counting HTTP_FORWARDED_COUNT back from the\n    // end of the list, we ensure that we get the IP address being\n    // reported by *our* first proxy.\n\n    if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n      return null;\n\n    return forwardedFor[forwardedFor.length - httpForwardedCount];\n  }\n});\n\n/******************************************************************************/\n/* Subscription                                                               */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n    session, handler, subscriptionId, params, name) {\n  var self = this;\n  self._session = session; // type is Session\n\n  /**\n   * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n   * @locus Server\n   * @name  connection\n   * @memberOf Subscription\n   * @instance\n   */\n  self.connection = session.connectionHandle; // public API object\n\n  self._handler = handler;\n\n  // my subscription ID (generated by client, undefined for universal subs).\n  self._subscriptionId = subscriptionId;\n  // undefined for universal subs\n  self._name = name;\n\n  self._params = params || [];\n\n  // Only named subscriptions have IDs, but we need some sort of string\n  // internally to keep track of all subscriptions inside\n  // SessionDocumentViews. We use this subscriptionHandle for that.\n  if (self._subscriptionId) {\n    self._subscriptionHandle = 'N' + self._subscriptionId;\n  } else {\n    self._subscriptionHandle = 'U' + Random.id();\n  }\n\n  // has _deactivate been called?\n  self._deactivated = false;\n\n  // stop callbacks to g/c this sub.  called w/ zero arguments.\n  self._stopCallbacks = [];\n\n  // the set of (collection, documentid) that this subscription has\n  // an opinion about\n  self._documents = new Map();\n\n  // remember if we are ready.\n  self._ready = false;\n\n  // Part of the public API: the user of this sub.\n\n  /**\n   * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n   * @locus Server\n   * @memberOf Subscription\n   * @name  userId\n   * @instance\n   */\n  self.userId = session.userId;\n\n  // For now, the id filter is going to default to\n  // the to/from DDP methods on MongoID, to\n  // specifically deal with mongo/minimongo ObjectIds.\n\n  // Later, you will be able to make this be \"raw\"\n  // if you want to publish a collection that you know\n  // just has strings for keys and no funny business, to\n  // a ddp consumer that isn't minimongo\n\n  self._idFilter = {\n    idStringify: MongoID.idStringify,\n    idParse: MongoID.idParse\n  };\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n  _runHandler: function () {\n    // XXX should we unblock() here? Either before running the publish\n    // function, or before running _publishCursor.\n    //\n    // Right now, each publish function blocks all future publishes and\n    // methods waiting on data from Mongo (or whatever else the function\n    // blocks on). This probably slows page load in common cases.\n\n    var self = this;\n    try {\n      var res = DDP._CurrentPublicationInvocation.withValue(\n        self,\n        () => maybeAuditArgumentChecks(\n          self._handler, self, EJSON.clone(self._params),\n          // It's OK that this would look weird for universal subscriptions,\n          // because they have no arguments so there can never be an\n          // audit-argument-checks failure.\n          \"publisher '\" + self._name + \"'\"\n        )\n      );\n    } catch (e) {\n      self.error(e);\n      return;\n    }\n\n    // Did the handler call this.error or this.stop?\n    if (self._isDeactivated())\n      return;\n\n    self._publishHandlerResult(res);\n  },\n\n  _publishHandlerResult: function (res) {\n    // SPECIAL CASE: Instead of writing their own callbacks that invoke\n    // this.added/changed/ready/etc, the user can just return a collection\n    // cursor or array of cursors from the publish function; we call their\n    // _publishCursor method which starts observing the cursor and publishes the\n    // results. Note that _publishCursor does NOT call ready().\n    //\n    // XXX This uses an undocumented interface which only the Mongo cursor\n    // interface publishes. Should we make this interface public and encourage\n    // users to implement it themselves? Arguably, it's unnecessary; users can\n    // already write their own functions like\n    //   var publishMyReactiveThingy = function (name, handler) {\n    //     Meteor.publish(name, function () {\n    //       var reactiveThingy = handler();\n    //       reactiveThingy.publishMe();\n    //     });\n    //   };\n\n    var self = this;\n    var isCursor = function (c) {\n      return c && c._publishCursor;\n    };\n    if (isCursor(res)) {\n      try {\n        res._publishCursor(self);\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      // _publishCursor only returns after the initial added callbacks have run.\n      // mark subscription as ready.\n      self.ready();\n    } else if (_.isArray(res)) {\n      // check all the elements are cursors\n      if (! _.all(res, isCursor)) {\n        self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n        return;\n      }\n      // find duplicate collection names\n      // XXX we should support overlapping cursors, but that would require the\n      // merge box to allow overlap within a subscription\n      var collectionNames = {};\n      for (var i = 0; i < res.length; ++i) {\n        var collectionName = res[i]._getCollectionName();\n        if (_.has(collectionNames, collectionName)) {\n          self.error(new Error(\n            \"Publish function returned multiple cursors for collection \" +\n              collectionName));\n          return;\n        }\n        collectionNames[collectionName] = true;\n      };\n\n      try {\n        _.each(res, function (cur) {\n          cur._publishCursor(self);\n        });\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      self.ready();\n    } else if (res) {\n      // truthy values other than cursors or arrays are probably a\n      // user mistake (possible returning a Mongo document via, say,\n      // `coll.findOne()`).\n      self.error(new Error(\"Publish function can only return a Cursor or \"\n                           + \"an array of Cursors\"));\n    }\n  },\n\n  // This calls all stop callbacks and prevents the handler from updating any\n  // SessionCollectionViews further. It's used when the user unsubscribes or\n  // disconnects, as well as during setUserId re-runs. It does *NOT* send\n  // removed messages for the published objects; if that is necessary, call\n  // _removeAllDocuments first.\n  _deactivate: function() {\n    var self = this;\n    if (self._deactivated)\n      return;\n    self._deactivated = true;\n    self._callStopCallbacks();\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"subscriptions\", -1);\n  },\n\n  _callStopCallbacks: function () {\n    var self = this;\n    // tell listeners, so they can clean up\n    var callbacks = self._stopCallbacks;\n    self._stopCallbacks = [];\n    _.each(callbacks, function (callback) {\n      callback();\n    });\n  },\n\n  // Send remove messages for every document.\n  _removeAllDocuments: function () {\n    var self = this;\n    Meteor._noYieldsAllowed(function () {\n      self._documents.forEach(function (collectionDocs, collectionName) {\n        collectionDocs.forEach(function (strId) {\n          self.removed(collectionName, self._idFilter.idParse(strId));\n        });\n      });\n    });\n  },\n\n  // Returns a new Subscription for the same session with the same\n  // initial creation parameters. This isn't a clone: it doesn't have\n  // the same _documents cache, stopped state or callbacks; may have a\n  // different _subscriptionHandle, and gets its userId from the\n  // session, not from this object.\n  _recreate: function () {\n    var self = this;\n    return new Subscription(\n      self._session, self._handler, self._subscriptionId, self._params,\n      self._name);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n   * @locus Server\n   * @param {Error} error The error to pass to the client.\n   * @instance\n   * @memberOf Subscription\n   */\n  error: function (error) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId, error);\n  },\n\n  // Note that while our DDP client will notice that you've called stop() on the\n  // server (and clean up its _subscriptions table) we don't actually provide a\n  // mechanism for an app to notice this (the subscribe onError callback only\n  // triggers if there is an error).\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.\n   * @locus Server\n   * @instance\n   * @memberOf Subscription\n   */\n  stop: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {Function} func The callback function\n   */\n  onStop: function (callback) {\n    var self = this;\n    callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n    if (self._isDeactivated())\n      callback();\n    else\n      self._stopCallbacks.push(callback);\n  },\n\n  // This returns true if the sub has been deactivated, *OR* if the session was\n  // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n  // happened yet.\n  _isDeactivated: function () {\n    var self = this;\n    return self._deactivated || self._session.inQueue === null;\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the new document.\n   * @param {String} id The new document's ID.\n   * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.\n   */\n  added: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    let ids = self._documents.get(collectionName);\n    if (ids == null) {\n      ids = new Set();\n      self._documents.set(collectionName, ids);\n    }\n    ids.add(id);\n    self._session.added(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the changed document.\n   * @param {String} id The changed document's ID.\n   * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.\n   */\n  changed: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that the document has been removed from.\n   * @param {String} id The ID of the document that has been removed.\n   */\n  removed: function (collectionName, id) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    // We don't bother to delete sets of things in a collection if the\n    // collection is empty.  It could break _removeAllDocuments.\n    self._documents.get(collectionName).delete(id);\n    self._session.removed(self._subscriptionHandle, collectionName, id);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   */\n  ready: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    if (!self._subscriptionId)\n      return;  // unnecessary but ignored for universal sub\n    if (!self._ready) {\n      self._session.sendReady([self._subscriptionId]);\n      self._ready = true;\n    }\n  }\n});\n\n/******************************************************************************/\n/* Server                                                                     */\n/******************************************************************************/\n\nServer = function (options) {\n  var self = this;\n\n  // The default heartbeat interval is 30 seconds on the server and 35\n  // seconds on the client.  Since the client doesn't need to send a\n  // ping as long as it is receiving pings, this means that pings\n  // normally go from the server to the client.\n  //\n  // Note: Troposphere depends on the ability to mutate\n  // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n  self.options = _.defaults(options || {}, {\n    heartbeatInterval: 15000,\n    heartbeatTimeout: 15000,\n    // For testing, allow responding to pings to be disabled.\n    respondToPings: true\n  });\n\n  // Map of callbacks to call when a new connection comes in to the\n  // server and completes DDP version negotiation. Use an object instead\n  // of an array so we can safely remove one from the list while\n  // iterating over it.\n  self.onConnectionHook = new Hook({\n    debugPrintExceptions: \"onConnection callback\"\n  });\n\n  // Map of callbacks to call when a new message comes in.\n  self.onMessageHook = new Hook({\n    debugPrintExceptions: \"onMessage callback\"\n  });\n\n  self.publish_handlers = {};\n  self.universal_publish_handlers = [];\n\n  self.method_handlers = {};\n\n  self.sessions = new Map(); // map from id to session\n\n  self.stream_server = new StreamServer;\n\n  self.stream_server.register(function (socket) {\n    // socket implements the SockJSConnection interface\n    socket._meteorSession = null;\n\n    var sendError = function (reason, offendingMessage) {\n      var msg = {msg: 'error', reason: reason};\n      if (offendingMessage)\n        msg.offendingMessage = offendingMessage;\n      socket.send(DDPCommon.stringifyDDP(msg));\n    };\n\n    socket.on('data', function (raw_msg) {\n      if (Meteor._printReceivedDDP) {\n        Meteor._debug(\"Received DDP\", raw_msg);\n      }\n      try {\n        try {\n          var msg = DDPCommon.parseDDP(raw_msg);\n        } catch (err) {\n          sendError('Parse error');\n          return;\n        }\n        if (msg === null || !msg.msg) {\n          sendError('Bad request', msg);\n          return;\n        }\n\n        if (msg.msg === 'connect') {\n          if (socket._meteorSession) {\n            sendError(\"Already connected\", msg);\n            return;\n          }\n          Fiber(function () {\n            self._handleConnect(socket, msg);\n          }).run();\n          return;\n        }\n\n        if (!socket._meteorSession) {\n          sendError('Must connect first', msg);\n          return;\n        }\n        socket._meteorSession.processMessage(msg);\n      } catch (e) {\n        // XXX print stack nicely\n        Meteor._debug(\"Internal exception while processing message\", msg, e);\n      }\n    });\n\n    socket.on('close', function () {\n      if (socket._meteorSession) {\n        Fiber(function () {\n          socket._meteorSession.close();\n        }).run();\n      }\n    });\n  });\n};\n\n_.extend(Server.prototype, {\n\n  /**\n   * @summary Register a callback to be called when a new DDP connection is made to the server.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP connection is established.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onConnection: function (fn) {\n    var self = this;\n    return self.onConnectionHook.register(fn);\n  },\n\n  /**\n   * @summary Register a callback to be called when a new DDP message is received.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP message is received.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onMessage: function (fn) {\n    var self = this;\n    return self.onMessageHook.register(fn);\n  },\n\n  _handleConnect: function (socket, msg) {\n    var self = this;\n\n    // The connect message must specify a version and an array of supported\n    // versions, and it must claim to support what it is proposing.\n    if (!(typeof (msg.version) === 'string' &&\n          _.isArray(msg.support) &&\n          _.all(msg.support, _.isString) &&\n          _.contains(msg.support, msg.version))) {\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n                                version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n      socket.close();\n      return;\n    }\n\n    // In the future, handle session resumption: something like:\n    //  socket._meteorSession = self.sessions[msg.session]\n    var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n    if (msg.version !== version) {\n      // The best version to use (according to the client's stated preferences)\n      // is not the one the client is trying to use. Inform them about the best\n      // version to use.\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n      socket.close();\n      return;\n    }\n\n    // Yay, version matches! Create a new session.\n    // Note: Troposphere depends on the ability to mutate\n    // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n    socket._meteorSession = new Session(self, version, socket, self.options);\n    self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n    self.onConnectionHook.each(function (callback) {\n      if (socket._meteorSession)\n        callback(socket._meteorSession.connectionHandle);\n      return true;\n    });\n  },\n  /**\n   * Register a publish handler function.\n   *\n   * @param name {String} identifier for query\n   * @param handler {Function} publish handler\n   * @param options {Object}\n   *\n   * Server will call handler function on each new subscription,\n   * either when receiving DDP sub message for a named subscription, or on\n   * DDP connect for a universal subscription.\n   *\n   * If name is null, this will be a subscription that is\n   * automatically established and permanently on for all connected\n   * client, instead of a subscription that can be turned on and off\n   * with subscribe().\n   *\n   * options to contain:\n   *  - (mostly internal) is_auto: true if generated automatically\n   *    from an autopublish hook. this is for cosmetic purposes only\n   *    (it lets us determine whether to print a warning suggesting\n   *    that you turn off autopublish.)\n   */\n\n  /**\n   * @summary Publish a record set.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   * @locus Server\n   * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n   * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.\n   */\n  publish: function (name, handler, options) {\n    var self = this;\n\n    if (! _.isObject(name)) {\n      options = options || {};\n\n      if (name && name in self.publish_handlers) {\n        Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n        return;\n      }\n\n      if (Package.autopublish && !options.is_auto) {\n        // They have autopublish on, yet they're trying to manually\n        // picking stuff to publish. They probably should turn off\n        // autopublish. (This check isn't perfect -- if you create a\n        // publish before you turn on autopublish, it won't catch\n        // it. But this will definitely handle the simple case where\n        // you've added the autopublish package to your app, and are\n        // calling publish from your app code.)\n        if (!self.warned_about_autopublish) {\n          self.warned_about_autopublish = true;\n          Meteor._debug(\n    \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n    \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n    \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n    \"** will still be sent to all clients.\\n\" +\n    \"**\\n\" +\n    \"** Turn off autopublish by removing the autopublish package:\\n\" +\n    \"**\\n\" +\n    \"**   $ meteor remove autopublish\\n\" +\n    \"**\\n\" +\n    \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n    \"** for each collection that you want clients to see.\\n\");\n        }\n      }\n\n      if (name)\n        self.publish_handlers[name] = handler;\n      else {\n        self.universal_publish_handlers.push(handler);\n        // Spin up the new publisher on any existing session too. Run each\n        // session's subscription in a new Fiber, so that there's no change for\n        // self.sessions to change while we're running this loop.\n        self.sessions.forEach(function (session) {\n          if (!session._dontStartNewUniversalSubs) {\n            Fiber(function() {\n              session._startSubscription(handler);\n            }).run();\n          }\n        });\n      }\n    }\n    else{\n      _.each(name, function(value, key) {\n        self.publish(key, value, {});\n      });\n    }\n  },\n\n  _removeSession: function (session) {\n    var self = this;\n    self.sessions.delete(session.id);\n  },\n\n  /**\n   * @summary Defines functions that can be invoked over the network by clients.\n   * @locus Anywhere\n   * @param {Object} methods Dictionary whose keys are method names and values are functions.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  methods: function (methods) {\n    var self = this;\n    _.each(methods, function (func, name) {\n      if (typeof func !== 'function')\n        throw new Error(\"Method '\" + name + \"' must be a function\");\n      if (self.method_handlers[name])\n        throw new Error(\"A method named '\" + name + \"' is already defined\");\n      self.method_handlers[name] = func;\n    });\n  },\n\n  call: function (name, ...args) {\n    if (args.length && typeof args[args.length - 1] === \"function\") {\n      // If it's a function, the last argument is the result callback, not\n      // a parameter to the remote method.\n      var callback = args.pop();\n    }\n\n    return this.apply(name, args, callback);\n  },\n\n  // A version of the call method that always returns a Promise.\n  callAsync: function (name, ...args) {\n    return this.applyAsync(name, args);\n  },\n\n  apply: function (name, args, options, callback) {\n    // We were passed 3 arguments. They may be either (name, args, options)\n    // or (name, args, callback)\n    if (! callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    } else {\n      options = options || {};\n    }\n\n    const promise = this.applyAsync(name, args, options);\n\n    // Return the result in whichever way the caller asked for it. Note that we\n    // do NOT block on the write fence in an analogous way to how the client\n    // blocks on the relevant data being visible, so you are NOT guaranteed that\n    // cursor observe callbacks have fired when your callback is invoked. (We\n    // can change this if there's a real use case.)\n    if (callback) {\n      promise.then(\n        result => callback(undefined, result),\n        exception => callback(exception)\n      );\n    } else {\n      return promise.await();\n    }\n  },\n\n  // @param options {Optional Object}\n  applyAsync: function (name, args, options) {\n    // Run the handler\n    var handler = this.method_handlers[name];\n    if (! handler) {\n      return Promise.reject(\n        new Meteor.Error(404, `Method '${name}' not found`)\n      );\n    }\n\n    // If this is a method call from within another method or publish function,\n    // get the user state from the outer method or publish function, otherwise\n    // don't allow setUserId to be called\n    var userId = null;\n    var setUserId = function() {\n      throw new Error(\"Can't call setUserId on a server initiated method call\");\n    };\n    var connection = null;\n    var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n    var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n    var randomSeed = null;\n    if (currentMethodInvocation) {\n      userId = currentMethodInvocation.userId;\n      setUserId = function(userId) {\n        currentMethodInvocation.setUserId(userId);\n      };\n      connection = currentMethodInvocation.connection;\n      randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n    } else if (currentPublicationInvocation) {\n      userId = currentPublicationInvocation.userId;\n      setUserId = function(userId) {\n        currentPublicationInvocation._session._setUserId(userId);\n      };\n      connection = currentPublicationInvocation.connection;\n    }\n\n    var invocation = new DDPCommon.MethodInvocation({\n      isSimulation: false,\n      userId,\n      setUserId,\n      connection,\n      randomSeed\n    });\n\n    return new Promise(resolve => resolve(\n      DDP._CurrentMethodInvocation.withValue(\n        invocation,\n        () => maybeAuditArgumentChecks(\n          handler, invocation, EJSON.clone(args),\n          \"internal call to '\" + name + \"'\"\n        )\n      )\n    )).then(EJSON.clone);\n  },\n\n  _urlForSession: function (sessionId) {\n    var self = this;\n    var session = self.sessions.get(sessionId);\n    if (session)\n      return session._socketUrl;\n    else\n      return null;\n  }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n                                 serverSupportedVersions) {\n  var correctVersion = _.find(clientSupportedVersions, function (version) {\n    return _.contains(serverSupportedVersions, version);\n  });\n  if (!correctVersion) {\n    correctVersion = serverSupportedVersions[0];\n  }\n  return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n  if (!exception) return exception;\n\n  // To allow packages to throw errors intended for the client but not have to\n  // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n  // error before it is thrown.\n  if (exception.isClientSafe) {\n    if (!(exception instanceof Meteor.Error)) {\n      const originalMessage = exception.message;\n      exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n      exception.message = originalMessage;\n    }\n    return exception;\n  }\n\n  // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n  // the server log.\n  if (!exception._expectedByTest) {\n    Meteor._debug(\"Exception \" + context, exception);\n    if (exception.sanitizedError) {\n      Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n      Meteor._debug();\n    }\n  }\n\n  // Did the error contain more details that could have been useful if caught in\n  // server code (or if thrown from non-client-originated code), but also\n  // provided a \"sanitized\" version with more context than 500 Internal server\n  // error? Use that.\n  if (exception.sanitizedError) {\n    if (exception.sanitizedError.isClientSafe)\n      return exception.sanitizedError;\n    Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n                  \"does not have isClientSafe property set; ignoring\");\n  }\n\n  return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n  args = args || [];\n  if (Package['audit-argument-checks']) {\n    return Match._failIfArgumentsAreNotAllChecked(\n      f, context, args, description);\n  }\n  return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n  var self = this;\n\n  self.armed = false;\n  self.fired = false;\n  self.retired = false;\n  self.outstanding_writes = 0;\n  self.before_fire_callbacks = [];\n  self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n  // Start tracking a write, and return an object to represent it. The\n  // object has a single method, committed(). This method should be\n  // called when the write is fully committed and propagated. You can\n  // continue to add writes to the WriteFence up until it is triggered\n  // (calls its callbacks because all writes have committed.)\n  beginWrite: function () {\n    var self = this;\n\n    if (self.retired)\n      return { committed: function () {} };\n\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to add writes\");\n\n    self.outstanding_writes++;\n    var committed = false;\n    return {\n      committed: function () {\n        if (committed)\n          throw new Error(\"committed called twice on the same write\");\n        committed = true;\n        self.outstanding_writes--;\n        self._maybeFire();\n      }\n    };\n  },\n\n  // Arm the fence. Once the fence is armed, and there are no more\n  // uncommitted writes, it will activate.\n  arm: function () {\n    var self = this;\n    if (self === DDPServer._CurrentWriteFence.get())\n      throw Error(\"Can't arm the current fence\");\n    self.armed = true;\n    self._maybeFire();\n  },\n\n  // Register a function to be called once before firing the fence.\n  // Callback function can add new writes to the fence, in which case\n  // it won't fire until those writes are done as well.\n  onBeforeFire: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.before_fire_callbacks.push(func);\n  },\n\n  // Register a function to be called when the fence fires.\n  onAllCommitted: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.completion_callbacks.push(func);\n  },\n\n  // Convenience function. Arms the fence, then blocks until it fires.\n  armAndWait: function () {\n    var self = this;\n    var future = new Future;\n    self.onAllCommitted(function () {\n      future['return']();\n    });\n    self.arm();\n    future.wait();\n  },\n\n  _maybeFire: function () {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"write fence already activated?\");\n    if (self.armed && !self.outstanding_writes) {\n      function invokeCallback (func) {\n        try {\n          func(self);\n        } catch (err) {\n          Meteor._debug(\"exception in write fence callback\", err);\n        }\n      }\n\n      self.outstanding_writes++;\n      while (self.before_fire_callbacks.length > 0) {\n        var callbacks = self.before_fire_callbacks;\n        self.before_fire_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n      self.outstanding_writes--;\n\n      if (!self.outstanding_writes) {\n        self.fired = true;\n        var callbacks = self.completion_callbacks;\n        self.completion_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n    }\n  },\n\n  // Deactivate this fence so that adding more writes has no effect.\n  // The fence must have already fired.\n  retire: function () {\n    var self = this;\n    if (! self.fired)\n      throw new Error(\"Can't retire a fence that hasn't fired.\");\n    self.retired = true;\n  }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n  var self = this;\n  options = options || {};\n\n  self.nextId = 1;\n  // map from collection name (string) -> listener id -> object. each object has\n  // keys 'trigger', 'callback'.  As a hack, the empty string means \"no\n  // collection\".\n  self.listenersByCollection = {};\n  self.listenersByCollectionCount = {};\n  self.factPackage = options.factPackage || \"livedata\";\n  self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n  // msg is a trigger or a notification\n  _collectionForMessage: function (msg) {\n    var self = this;\n    if (! _.has(msg, 'collection')) {\n      return '';\n    } else if (typeof(msg.collection) === 'string') {\n      if (msg.collection === '')\n        throw Error(\"Message has empty collection!\");\n      return msg.collection;\n    } else {\n      throw Error(\"Message has non-string collection!\");\n    }\n  },\n\n  // Listen for notification that match 'trigger'. A notification\n  // matches if it has the key-value pairs in trigger as a\n  // subset. When a notification matches, call 'callback', passing\n  // the actual notification.\n  //\n  // Returns a listen handle, which is an object with a method\n  // stop(). Call stop() to stop listening.\n  //\n  // XXX It should be legal to call fire() from inside a listen()\n  // callback?\n  listen: function (trigger, callback) {\n    var self = this;\n    var id = self.nextId++;\n\n    var collection = self._collectionForMessage(trigger);\n    var record = {trigger: EJSON.clone(trigger), callback: callback};\n    if (! _.has(self.listenersByCollection, collection)) {\n      self.listenersByCollection[collection] = {};\n      self.listenersByCollectionCount[collection] = 0;\n    }\n    self.listenersByCollection[collection][id] = record;\n    self.listenersByCollectionCount[collection]++;\n\n    if (self.factName && Package['facts-base']) {\n      Package['facts-base'].Facts.incrementServerFact(\n        self.factPackage, self.factName, 1);\n    }\n\n    return {\n      stop: function () {\n        if (self.factName && Package['facts-base']) {\n          Package['facts-base'].Facts.incrementServerFact(\n            self.factPackage, self.factName, -1);\n        }\n        delete self.listenersByCollection[collection][id];\n        self.listenersByCollectionCount[collection]--;\n        if (self.listenersByCollectionCount[collection] === 0) {\n          delete self.listenersByCollection[collection];\n          delete self.listenersByCollectionCount[collection];\n        }\n      }\n    };\n  },\n\n  // Fire the provided 'notification' (an object whose attribute\n  // values are all JSON-compatibile) -- inform all matching listeners\n  // (registered with listen()).\n  //\n  // If fire() is called inside a write fence, then each of the\n  // listener callbacks will be called inside the write fence as well.\n  //\n  // The listeners may be invoked in parallel, rather than serially.\n  fire: function (notification) {\n    var self = this;\n\n    var collection = self._collectionForMessage(notification);\n\n    if (! _.has(self.listenersByCollection, collection)) {\n      return;\n    }\n\n    var listenersForCollection = self.listenersByCollection[collection];\n    var callbackIds = [];\n    _.each(listenersForCollection, function (l, id) {\n      if (self._matches(notification, l.trigger)) {\n        callbackIds.push(id);\n      }\n    });\n\n    // Listener callbacks can yield, so we need to first find all the ones that\n    // match in a single iteration over self.listenersByCollection (which can't\n    // be mutated during this iteration), and then invoke the matching\n    // callbacks, checking before each call to ensure they haven't stopped.\n    // Note that we don't have to check that\n    // self.listenersByCollection[collection] still === listenersForCollection,\n    // because the only way that stops being true is if listenersForCollection\n    // first gets reduced down to the empty object (and then never gets\n    // increased again).\n    _.each(callbackIds, function (id) {\n      if (_.has(listenersForCollection, id)) {\n        listenersForCollection[id].callback(notification);\n      }\n    });\n  },\n\n  // A notification matches a trigger if all keys that exist in both are equal.\n  //\n  // Examples:\n  //  N:{collection: \"C\"} matches T:{collection: \"C\"}\n  //    (a non-targeted write to a collection matches a\n  //     non-targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n  //    (a targeted write to a collection matches a non-targeted query)\n  //  N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a non-targeted write to a collection matches a\n  //     targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a targeted write to a collection matches a targeted query targeted\n  //     at the same document)\n  //  N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n  //    (a targeted write to a collection does not match a targeted query\n  //     targeted at a different document)\n  _matches: function (notification, trigger) {\n    // Most notifications that use the crossbar have a string `collection` and\n    // maybe an `id` that is a string or ObjectID. We're already dividing up\n    // triggers by collection, but let's fast-track \"nope, different ID\" (and\n    // avoid the overly generic EJSON.equals). This makes a noticeable\n    // performance difference; see https://github.com/meteor/meteor/pull/3697\n    if (typeof(notification.id) === 'string' &&\n        typeof(trigger.id) === 'string' &&\n        notification.id !== trigger.id) {\n      return false;\n    }\n    if (notification.id instanceof MongoID.ObjectID &&\n        trigger.id instanceof MongoID.ObjectID &&\n        ! notification.id.equals(trigger.id)) {\n      return false;\n    }\n\n    return _.all(trigger, function (triggerValue, key) {\n      return !_.has(notification, key) ||\n        EJSON.equals(triggerValue, notification[key]);\n    });\n  }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n  factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n  __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n    process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n  DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n       function (name) {\n         Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n       });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n  var extensions = [];\n\n  var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n        ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n  if (websocketCompressionConfig) {\n    extensions.push(Npm.require('permessage-deflate').configure(\n      websocketCompressionConfig\n    ));\n  }\n\n  return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX ||  \"\";\n\nStreamServer = function () {\n  var self = this;\n  self.registration_callbacks = [];\n  self.open_sockets = [];\n\n  // Because we are installing directly onto WebApp.httpServer instead of using\n  // WebApp.app, we have to process the path prefix ourselves.\n  self.prefix = pathPrefix + '/sockjs';\n  RoutePolicy.declare(self.prefix + '/', 'network');\n\n  // set up sockjs\n  var sockjs = Npm.require('sockjs');\n  var serverOptions = {\n    prefix: self.prefix,\n    log: function() {},\n    // this is the default, but we code it explicitly because we depend\n    // on it in stream_client:HEARTBEAT_TIMEOUT\n    heartbeat_delay: 45000,\n    // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n    // bound for that much time, SockJS might not notice that the user has\n    // reconnected because the timer (of disconnect_delay ms) can fire before\n    // SockJS processes the new connection. Eventually we'll fix this by not\n    // combining CPU-heavy processing with SockJS termination (eg a proxy which\n    // converts to Unix sockets) but for now, raise the delay.\n    disconnect_delay: 60 * 1000,\n    // Set the USE_JSESSIONID environment variable to enable setting the\n    // JSESSIONID cookie. This is useful for setting up proxies with\n    // session affinity.\n    jsessionid: !!process.env.USE_JSESSIONID\n  };\n\n  // If you know your server environment (eg, proxies) will prevent websockets\n  // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n  // browsers) will not waste time attempting to use them.\n  // (Your server will still have a /websocket endpoint.)\n  if (process.env.DISABLE_WEBSOCKETS) {\n    serverOptions.websocket = false;\n  } else {\n    serverOptions.faye_server_options = {\n      extensions: websocketExtensions()\n    };\n  }\n\n  self.server = sockjs.createServer(serverOptions);\n\n  // Install the sockjs handlers, but we want to keep around our own particular\n  // request handler that adjusts idle timeouts while we have an outstanding\n  // request.  This compensates for the fact that sockjs removes all listeners\n  // for \"request\" to add its own.\n  WebApp.httpServer.removeListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n  self.server.installHandlers(WebApp.httpServer);\n  WebApp.httpServer.addListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n\n  // Support the /websocket endpoint\n  self._redirectWebsocketEndpoint();\n\n  self.server.on('connection', function (socket) {\n    // We want to make sure that if a client connects to us and does the initial\n    // Websocket handshake but never gets to the DDP handshake, that we\n    // eventually kill the socket.  Once the DDP handshake happens, DDP\n    // heartbeating will work. And before the Websocket handshake, the timeouts\n    // we set at the server level in webapp_server.js will work. But\n    // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n    // is an \"in between\" state where this doesn't happen.  We work around this\n    // by explicitly setting the socket timeout to a relatively large time here,\n    // and setting it back to zero when we set up the heartbeat in\n    // livedata_server.js.\n    socket.setWebsocketTimeout = function (timeout) {\n      if ((socket.protocol === 'websocket' ||\n           socket.protocol === 'websocket-raw')\n          && socket._session.recv) {\n        socket._session.recv.connection.setTimeout(timeout);\n      }\n    };\n    socket.setWebsocketTimeout(45 * 1000);\n\n    socket.send = function (data) {\n      socket.write(data);\n    };\n    socket.on('close', function () {\n      self.open_sockets = _.without(self.open_sockets, socket);\n    });\n    self.open_sockets.push(socket);\n\n    // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n    // will force old clients to reload. Remove this once we're not\n    // concerned about people upgrading from a pre-0.7.0 release. Also,\n    // remove the clause in the client that ignores the welcome message\n    // (livedata_connection.js)\n    socket.send(JSON.stringify({server_id: \"0\"}));\n\n    // call all our callbacks when we get a new socket. they will do the\n    // work of setting up handlers and such for specific messages.\n    _.each(self.registration_callbacks, function (callback) {\n      callback(socket);\n    });\n  });\n\n};\n\n_.extend(StreamServer.prototype, {\n  // call my callback when a new socket connects.\n  // also call it for all current connections.\n  register: function (callback) {\n    var self = this;\n    self.registration_callbacks.push(callback);\n    _.each(self.all_sockets(), function (socket) {\n      callback(socket);\n    });\n  },\n\n  // get a list of all sockets\n  all_sockets: function () {\n    var self = this;\n    return _.values(self.open_sockets);\n  },\n\n  // Redirect /websocket to /sockjs/websocket in order to not expose\n  // sockjs to clients that want to use raw websockets\n  _redirectWebsocketEndpoint: function() {\n    var self = this;\n    // Unfortunately we can't use a connect middleware here since\n    // sockjs installs itself prior to all existing listeners\n    // (meaning prior to any connect middlewares) so we need to take\n    // an approach similar to overshadowListeners in\n    // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n    _.each(['request', 'upgrade'], function(event) {\n      var httpServer = WebApp.httpServer;\n      var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n      httpServer.removeAllListeners(event);\n\n      // request and upgrade have different arguments passed but\n      // we only care about the first one which is always request\n      var newListener = function(request /*, moreArguments */) {\n        // Store arguments for use within the closure below\n        var args = arguments;\n\n        // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n        // preserving query string.\n        var parsedUrl = url.parse(request.url);\n        if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n            parsedUrl.pathname === pathPrefix + '/websocket/') {\n          parsedUrl.pathname = self.prefix + '/websocket';\n          request.url = url.format(parsedUrl);\n        }\n        _.each(oldHttpServerListeners, function(oldListener) {\n          oldListener.apply(httpServer, args);\n        });\n      };\n      httpServer.addListener(event, newListener);\n    });\n  }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n  var self = this;\n  self.existsIn = new Set(); // set of subscriptionHandle\n  self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n  getFields: function () {\n    var self = this;\n    var ret = {};\n    self.dataByKey.forEach(function (precedenceList, key) {\n      ret[key] = precedenceList[0].value;\n    });\n    return ret;\n  },\n\n  clearField: function (subscriptionHandle, key, changeCollector) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n    var precedenceList = self.dataByKey.get(key);\n\n    // It's okay to clear fields that didn't exist. No need to throw\n    // an error.\n    if (!precedenceList)\n      return;\n\n    var removedValue = undefined;\n    for (var i = 0; i < precedenceList.length; i++) {\n      var precedence = precedenceList[i];\n      if (precedence.subscriptionHandle === subscriptionHandle) {\n        // The view's value can only change if this subscription is the one that\n        // used to have precedence.\n        if (i === 0)\n          removedValue = precedence.value;\n        precedenceList.splice(i, 1);\n        break;\n      }\n    }\n    if (precedenceList.length === 0) {\n      self.dataByKey.delete(key);\n      changeCollector[key] = undefined;\n    } else if (removedValue !== undefined &&\n               !EJSON.equals(removedValue, precedenceList[0].value)) {\n      changeCollector[key] = precedenceList[0].value;\n    }\n  },\n\n  changeField: function (subscriptionHandle, key, value,\n                         changeCollector, isAdd) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n\n    // Don't share state with the data passed in by the user.\n    value = EJSON.clone(value);\n\n    if (!self.dataByKey.has(key)) {\n      self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n                                value: value}]);\n      changeCollector[key] = value;\n      return;\n    }\n    var precedenceList = self.dataByKey.get(key);\n    var elt;\n    if (!isAdd) {\n      elt = precedenceList.find(function (precedence) {\n          return precedence.subscriptionHandle === subscriptionHandle;\n      });\n    }\n\n    if (elt) {\n      if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n        // this subscription is changing the value of this field.\n        changeCollector[key] = value;\n      }\n      elt.value = value;\n    } else {\n      // this subscription is newly caring about this field\n      precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n    }\n\n  }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n  var self = this;\n  self.collectionName = collectionName;\n  self.documents = new Map();\n  self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n  isEmpty: function () {\n    var self = this;\n    return self.documents.size === 0;\n  },\n\n  diff: function (previous) {\n    var self = this;\n    DiffSequence.diffMaps(previous.documents, self.documents, {\n      both: _.bind(self.diffDocument, self),\n\n      rightOnly: function (id, nowDV) {\n        self.callbacks.added(self.collectionName, id, nowDV.getFields());\n      },\n\n      leftOnly: function (id, prevDV) {\n        self.callbacks.removed(self.collectionName, id);\n      }\n    });\n  },\n\n  diffDocument: function (id, prevDV, nowDV) {\n    var self = this;\n    var fields = {};\n    DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n      both: function (key, prev, now) {\n        if (!EJSON.equals(prev, now))\n          fields[key] = now;\n      },\n      rightOnly: function (key, now) {\n        fields[key] = now;\n      },\n      leftOnly: function(key, prev) {\n        fields[key] = undefined;\n      }\n    });\n    self.callbacks.changed(self.collectionName, id, fields);\n  },\n\n  added: function (subscriptionHandle, id, fields) {\n    var self = this;\n    var docView = self.documents.get(id);\n    var added = false;\n    if (!docView) {\n      added = true;\n      docView = new SessionDocumentView();\n      self.documents.set(id, docView);\n    }\n    docView.existsIn.add(subscriptionHandle);\n    var changeCollector = {};\n    _.each(fields, function (value, key) {\n      docView.changeField(\n        subscriptionHandle, key, value, changeCollector, true);\n    });\n    if (added)\n      self.callbacks.added(self.collectionName, id, changeCollector);\n    else\n      self.callbacks.changed(self.collectionName, id, changeCollector);\n  },\n\n  changed: function (subscriptionHandle, id, changed) {\n    var self = this;\n    var changedResult = {};\n    var docView = self.documents.get(id);\n    if (!docView)\n      throw new Error(\"Could not find element with id \" + id + \" to change\");\n    _.each(changed, function (value, key) {\n      if (value === undefined)\n        docView.clearField(subscriptionHandle, key, changedResult);\n      else\n        docView.changeField(subscriptionHandle, key, value, changedResult);\n    });\n    self.callbacks.changed(self.collectionName, id, changedResult);\n  },\n\n  removed: function (subscriptionHandle, id) {\n    var self = this;\n    var docView = self.documents.get(id);\n    if (!docView) {\n      var err = new Error(\"Removed nonexistent document \" + id);\n      throw err;\n    }\n    docView.existsIn.delete(subscriptionHandle);\n    if (docView.existsIn.size === 0) {\n      // it is gone from everyone\n      self.callbacks.removed(self.collectionName, id);\n      self.documents.delete(id);\n    } else {\n      var changed = {};\n      // remove this subscription from every precedence list\n      // and record the changes\n      docView.dataByKey.forEach(function (precedenceList, key) {\n        docView.clearField(subscriptionHandle, key, changed);\n      });\n\n      self.callbacks.changed(self.collectionName, id, changed);\n    }\n  }\n});\n\n/******************************************************************************/\n/* Session                                                                    */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n  var self = this;\n  self.id = Random.id();\n\n  self.server = server;\n  self.version = version;\n\n  self.initialized = false;\n  self.socket = socket;\n\n  // set to null when the session is destroyed. multiple places below\n  // use this to determine if the session is alive or not.\n  self.inQueue = new Meteor._DoubleEndedQueue();\n\n  self.blocked = false;\n  self.workerRunning = false;\n\n  // Sub objects for active subscriptions\n  self._namedSubs = new Map();\n  self._universalSubs = [];\n\n  self.userId = null;\n\n  self.collectionViews = new Map();\n\n  // Set this to false to not send messages when collectionViews are\n  // modified. This is done when rerunning subs in _setUserId and those messages\n  // are calculated via a diff instead.\n  self._isSending = true;\n\n  // If this is true, don't start a newly-created universal publisher on this\n  // session. The session will take care of starting it when appropriate.\n  self._dontStartNewUniversalSubs = false;\n\n  // when we are rerunning subscriptions, any ready messages\n  // we want to buffer up for when we are done rerunning subscriptions\n  self._pendingReady = [];\n\n  // List of callbacks to call when this connection is closed.\n  self._closeCallbacks = [];\n\n\n  // XXX HACK: If a sockjs connection, save off the URL. This is\n  // temporary and will go away in the near future.\n  self._socketUrl = socket.url;\n\n  // Allow tests to disable responding to pings.\n  self._respondToPings = options.respondToPings;\n\n  // This object is the public interface to the session. In the public\n  // API, it is called the `connection` object.  Internally we call it\n  // a `connectionHandle` to avoid ambiguity.\n  self.connectionHandle = {\n    id: self.id,\n    close: function () {\n      self.close();\n    },\n    onClose: function (fn) {\n      var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n      if (self.inQueue) {\n        self._closeCallbacks.push(cb);\n      } else {\n        // if we're already closed, call the callback.\n        Meteor.defer(cb);\n      }\n    },\n    clientAddress: self._clientAddress(),\n    httpHeaders: self.socket.headers\n  };\n\n  self.send({ msg: 'connected', session: self.id });\n\n  // On initial connect, spin up all the universal publishers.\n  Fiber(function () {\n    self.startUniversalSubs();\n  }).run();\n\n  if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n    // We no longer need the low level timeout because we have heartbeating.\n    socket.setWebsocketTimeout(0);\n\n    self.heartbeat = new DDPCommon.Heartbeat({\n      heartbeatInterval: options.heartbeatInterval,\n      heartbeatTimeout: options.heartbeatTimeout,\n      onTimeout: function () {\n        self.close();\n      },\n      sendPing: function () {\n        self.send({msg: 'ping'});\n      }\n    });\n    self.heartbeat.start();\n  }\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n  sendReady: function (subscriptionIds) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"ready\", subs: subscriptionIds});\n    else {\n      _.each(subscriptionIds, function (subscriptionId) {\n        self._pendingReady.push(subscriptionId);\n      });\n    }\n  },\n\n  sendAdded: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n  },\n\n  sendChanged: function (collectionName, id, fields) {\n    var self = this;\n    if (_.isEmpty(fields))\n      return;\n\n    if (self._isSending) {\n      self.send({\n        msg: \"changed\",\n        collection: collectionName,\n        id: id,\n        fields: fields\n      });\n    }\n  },\n\n  sendRemoved: function (collectionName, id) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"removed\", collection: collectionName, id: id});\n  },\n\n  getSendCallbacks: function () {\n    var self = this;\n    return {\n      added: _.bind(self.sendAdded, self),\n      changed: _.bind(self.sendChanged, self),\n      removed: _.bind(self.sendRemoved, self)\n    };\n  },\n\n  getCollectionView: function (collectionName) {\n    var self = this;\n    var ret = self.collectionViews.get(collectionName);\n    if (!ret) {\n      ret = new SessionCollectionView(collectionName,\n                                        self.getSendCallbacks());\n      self.collectionViews.set(collectionName, ret);\n    }\n    return ret;\n  },\n\n  added: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.added(subscriptionHandle, id, fields);\n  },\n\n  removed: function (subscriptionHandle, collectionName, id) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.removed(subscriptionHandle, id);\n    if (view.isEmpty()) {\n       self.collectionViews.delete(collectionName);\n    }\n  },\n\n  changed: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.changed(subscriptionHandle, id, fields);\n  },\n\n  startUniversalSubs: function () {\n    var self = this;\n    // Make a shallow copy of the set of universal handlers and start them. If\n    // additional universal publishers start while we're running them (due to\n    // yielding), they will run separately as part of Server.publish.\n    var handlers = _.clone(self.server.universal_publish_handlers);\n    _.each(handlers, function (handler) {\n      self._startSubscription(handler);\n    });\n  },\n\n  // Destroy this session and unregister it at the server.\n  close: function () {\n    var self = this;\n\n    // Destroy this session, even if it's not registered at the\n    // server. Stop all processing and tear everything down. If a socket\n    // was attached, close it.\n\n    // Already destroyed.\n    if (! self.inQueue)\n      return;\n\n    // Drop the merge box data immediately.\n    self.inQueue = null;\n    self.collectionViews = new Map();\n\n    if (self.heartbeat) {\n      self.heartbeat.stop();\n      self.heartbeat = null;\n    }\n\n    if (self.socket) {\n      self.socket.close();\n      self.socket._meteorSession = null;\n    }\n\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"sessions\", -1);\n\n    Meteor.defer(function () {\n      // stop callbacks can yield, so we defer this on close.\n      // sub._isDeactivated() detects that we set inQueue to null and\n      // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n      self._deactivateAllSubscriptions();\n\n      // Defer calling the close callbacks, so that the caller closing\n      // the session isn't waiting for all the callbacks to complete.\n      _.each(self._closeCallbacks, function (callback) {\n        callback();\n      });\n    });\n\n    // Unregister the session.\n    self.server._removeSession(self);\n  },\n\n  // Send a message (doing nothing if no socket is connected right now.)\n  // It should be a JSON object (it will be stringified.)\n  send: function (msg) {\n    var self = this;\n    if (self.socket) {\n      if (Meteor._printSentDDP)\n        Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n      self.socket.send(DDPCommon.stringifyDDP(msg));\n    }\n  },\n\n  // Send a connection error.\n  sendError: function (reason, offendingMessage) {\n    var self = this;\n    var msg = {msg: 'error', reason: reason};\n    if (offendingMessage)\n      msg.offendingMessage = offendingMessage;\n    self.send(msg);\n  },\n\n  // Process 'msg' as an incoming message. (But as a guard against\n  // race conditions during reconnection, ignore the message if\n  // 'socket' is not the currently connected socket.)\n  //\n  // We run the messages from the client one at a time, in the order\n  // given by the client. The message handler is passed an idempotent\n  // function 'unblock' which it may call to allow other messages to\n  // begin running in parallel in another fiber (for example, a method\n  // that wants to yield.) Otherwise, it is automatically unblocked\n  // when it returns.\n  //\n  // Actually, we don't have to 'totally order' the messages in this\n  // way, but it's the easiest thing that's correct. (unsub needs to\n  // be ordered against sub, methods need to be ordered against each\n  // other.)\n  processMessage: function (msg_in) {\n    var self = this;\n    if (!self.inQueue) // we have been destroyed.\n      return;\n\n    // Respond to ping and pong messages immediately without queuing.\n    // If the negotiated DDP version is \"pre1\" which didn't support\n    // pings, preserve the \"pre1\" behavior of responding with a \"bad\n    // request\" for the unknown messages.\n    //\n    // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n    // needs a Fiber. We could actually use regular setTimeout and avoid\n    // these new fibers, but it is easier to just make everything use\n    // Meteor.setTimeout and not think too hard.\n    //\n    // Any message counts as receiving a pong, as it demonstrates that\n    // the client is still alive.\n    if (self.heartbeat) {\n      Fiber(function () {\n        self.heartbeat.messageReceived();\n      }).run();\n    }\n\n    if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n      if (self._respondToPings)\n        self.send({msg: \"pong\", id: msg_in.id});\n      return;\n    }\n    if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n      // Since everything is a pong, nothing to do\n      return;\n    }\n\n    self.inQueue.push(msg_in);\n    if (self.workerRunning)\n      return;\n    self.workerRunning = true;\n\n    var processNext = function () {\n      var msg = self.inQueue && self.inQueue.shift();\n      if (!msg) {\n        self.workerRunning = false;\n        return;\n      }\n\n      Fiber(function () {\n        var blocked = true;\n\n        var unblock = function () {\n          if (!blocked)\n            return; // idempotent\n          blocked = false;\n          processNext();\n        };\n\n        self.server.onMessageHook.each(function (callback) {\n          callback(msg, self);\n          return true;\n        });\n\n        if (_.has(self.protocol_handlers, msg.msg))\n          self.protocol_handlers[msg.msg].call(self, msg, unblock);\n        else\n          self.sendError('Bad request', msg);\n        unblock(); // in case the handler didn't already do it\n      }).run();\n    };\n\n    processNext();\n  },\n\n  protocol_handlers: {\n    sub: function (msg) {\n      var self = this;\n\n      // reject malformed messages\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.name) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array))) {\n        self.sendError(\"Malformed subscription\", msg);\n        return;\n      }\n\n      if (!self.server.publish_handlers[msg.name]) {\n        self.send({\n          msg: 'nosub', id: msg.id,\n          error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n        return;\n      }\n\n      if (self._namedSubs.has(msg.id))\n        // subs are idempotent, or rather, they are ignored if a sub\n        // with that id already exists. this is important during\n        // reconnect.\n        return;\n\n      // XXX It'd be much better if we had generic hooks where any package can\n      // hook into subscription handling, but in the mean while we special case\n      // ddp-rate-limiter package. This is also done for weak requirements to\n      // add the ddp-rate-limiter package in case we don't have Accounts. A\n      // user trying to use the ddp-rate-limiter must explicitly require it.\n      if (Package['ddp-rate-limiter']) {\n        var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n        var rateLimiterInput = {\n          userId: self.userId,\n          clientAddress: self.connectionHandle.clientAddress,\n          type: \"subscription\",\n          name: msg.name,\n          connectionId: self.id\n        };\n\n        DDPRateLimiter._increment(rateLimiterInput);\n        var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n        if (!rateLimitResult.allowed) {\n          self.send({\n            msg: 'nosub', id: msg.id,\n            error: new Meteor.Error(\n              'too-many-requests',\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset})\n          });\n          return;\n        }\n      }\n\n      var handler = self.server.publish_handlers[msg.name];\n\n      self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n    },\n\n    unsub: function (msg) {\n      var self = this;\n\n      self._stopSubscription(msg.id);\n    },\n\n    method: function (msg, unblock) {\n      var self = this;\n\n      // reject malformed messages\n      // For now, we silently ignore unknown attributes,\n      // for forwards compatibility.\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.method) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array)) ||\n          (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n        self.sendError(\"Malformed method invocation\", msg);\n        return;\n      }\n\n      var randomSeed = msg.randomSeed || null;\n\n      // set up to mark the method as satisfied once all observers\n      // (and subscriptions) have reacted to any writes that were\n      // done.\n      var fence = new DDPServer._WriteFence;\n      fence.onAllCommitted(function () {\n        // Retire the fence so that future writes are allowed.\n        // This means that callbacks like timers are free to use\n        // the fence, and if they fire before it's armed (for\n        // example, because the method waits for them) their\n        // writes will be included in the fence.\n        fence.retire();\n        self.send({\n          msg: 'updated', methods: [msg.id]});\n      });\n\n      // find the handler\n      var handler = self.server.method_handlers[msg.method];\n      if (!handler) {\n        self.send({\n          msg: 'result', id: msg.id,\n          error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n        fence.arm();\n        return;\n      }\n\n      var setUserId = function(userId) {\n        self._setUserId(userId);\n      };\n\n      var invocation = new DDPCommon.MethodInvocation({\n        isSimulation: false,\n        userId: self.userId,\n        setUserId: setUserId,\n        unblock: unblock,\n        connection: self.connectionHandle,\n        randomSeed: randomSeed\n      });\n\n      const promise = new Promise((resolve, reject) => {\n        // XXX It'd be better if we could hook into method handlers better but\n        // for now, we need to check if the ddp-rate-limiter exists since we\n        // have a weak requirement for the ddp-rate-limiter package to be added\n        // to our application.\n        if (Package['ddp-rate-limiter']) {\n          var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n          var rateLimiterInput = {\n            userId: self.userId,\n            clientAddress: self.connectionHandle.clientAddress,\n            type: \"method\",\n            name: msg.method,\n            connectionId: self.id\n          };\n          DDPRateLimiter._increment(rateLimiterInput);\n          var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n          if (!rateLimitResult.allowed) {\n            reject(new Meteor.Error(\n              \"too-many-requests\",\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset}\n            ));\n            return;\n          }\n        }\n\n        resolve(DDPServer._CurrentWriteFence.withValue(\n          fence,\n          () => DDP._CurrentMethodInvocation.withValue(\n            invocation,\n            () => maybeAuditArgumentChecks(\n              handler, invocation, msg.params,\n              \"call to '\" + msg.method + \"'\"\n            )\n          )\n        ));\n      });\n\n      function finish() {\n        fence.arm();\n        unblock();\n      }\n\n      const payload = {\n        msg: \"result\",\n        id: msg.id\n      };\n\n      promise.then((result) => {\n        finish();\n        if (result !== undefined) {\n          payload.result = result;\n        }\n        self.send(payload);\n      }, (exception) => {\n        finish();\n        payload.error = wrapInternalException(\n          exception,\n          `while invoking method '${msg.method}'`\n        );\n        self.send(payload);\n      });\n    }\n  },\n\n  _eachSub: function (f) {\n    var self = this;\n    self._namedSubs.forEach(f);\n    self._universalSubs.forEach(f);\n  },\n\n  _diffCollectionViews: function (beforeCVs) {\n    var self = this;\n    DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n      both: function (collectionName, leftValue, rightValue) {\n        rightValue.diff(leftValue);\n      },\n      rightOnly: function (collectionName, rightValue) {\n        rightValue.documents.forEach(function (docView, id) {\n          self.sendAdded(collectionName, id, docView.getFields());\n        });\n      },\n      leftOnly: function (collectionName, leftValue) {\n        leftValue.documents.forEach(function (doc, id) {\n          self.sendRemoved(collectionName, id);\n        });\n      }\n    });\n  },\n\n  // Sets the current user id in all appropriate contexts and reruns\n  // all subscriptions\n  _setUserId: function(userId) {\n    var self = this;\n\n    if (userId !== null && typeof userId !== \"string\")\n      throw new Error(\"setUserId must be called on string or null, not \" +\n                      typeof userId);\n\n    // Prevent newly-created universal subscriptions from being added to our\n    // session; they will be found below when we call startUniversalSubs.\n    //\n    // (We don't have to worry about named subscriptions, because we only add\n    // them when we process a 'sub' message. We are currently processing a\n    // 'method' message, and the method did not unblock, because it is illegal\n    // to call setUserId after unblock. Thus we cannot be concurrently adding a\n    // new named subscription.)\n    self._dontStartNewUniversalSubs = true;\n\n    // Prevent current subs from updating our collectionViews and call their\n    // stop callbacks. This may yield.\n    self._eachSub(function (sub) {\n      sub._deactivate();\n    });\n\n    // All subs should now be deactivated. Stop sending messages to the client,\n    // save the state of the published collections, reset to an empty view, and\n    // update the userId.\n    self._isSending = false;\n    var beforeCVs = self.collectionViews;\n    self.collectionViews = new Map();\n    self.userId = userId;\n\n    // _setUserId is normally called from a Meteor method with\n    // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n    // expected to be set inside a publish function, so we temporary unset it.\n    // Inside a publish function DDP._CurrentPublicationInvocation is set.\n    DDP._CurrentMethodInvocation.withValue(undefined, function () {\n      // Save the old named subs, and reset to having no subscriptions.\n      var oldNamedSubs = self._namedSubs;\n      self._namedSubs = new Map();\n      self._universalSubs = [];\n\n      oldNamedSubs.forEach(function (sub, subscriptionId) {\n        var newSub = sub._recreate();\n        self._namedSubs.set(subscriptionId, newSub);\n        // nb: if the handler throws or calls this.error(), it will in fact\n        // immediately send its 'nosub'. This is OK, though.\n        newSub._runHandler();\n      });\n\n      // Allow newly-created universal subs to be started on our connection in\n      // parallel with the ones we're spinning up here, and spin up universal\n      // subs.\n      self._dontStartNewUniversalSubs = false;\n      self.startUniversalSubs();\n    });\n\n    // Start sending messages again, beginning with the diff from the previous\n    // state of the world to the current state. No yields are allowed during\n    // this diff, so that other changes cannot interleave.\n    Meteor._noYieldsAllowed(function () {\n      self._isSending = true;\n      self._diffCollectionViews(beforeCVs);\n      if (!_.isEmpty(self._pendingReady)) {\n        self.sendReady(self._pendingReady);\n        self._pendingReady = [];\n      }\n    });\n  },\n\n  _startSubscription: function (handler, subId, params, name) {\n    var self = this;\n\n    var sub = new Subscription(\n      self, handler, subId, params, name);\n    if (subId)\n      self._namedSubs.set(subId, sub);\n    else\n      self._universalSubs.push(sub);\n\n    sub._runHandler();\n  },\n\n  // tear down specified subscription\n  _stopSubscription: function (subId, error) {\n    var self = this;\n\n    var subName = null;\n    if (subId) {\n      var maybeSub = self._namedSubs.get(subId);\n      if (maybeSub) {\n        subName = maybeSub._name;\n        maybeSub._removeAllDocuments();\n        maybeSub._deactivate();\n        self._namedSubs.delete(subId);\n      }\n    }\n\n    var response = {msg: 'nosub', id: subId};\n\n    if (error) {\n      response.error = wrapInternalException(\n        error,\n        subName ? (\"from sub \" + subName + \" id \" + subId)\n          : (\"from sub id \" + subId));\n    }\n\n    self.send(response);\n  },\n\n  // tear down all subscriptions. Note that this does NOT send removed or nosub\n  // messages, since we assume the client is gone.\n  _deactivateAllSubscriptions: function () {\n    var self = this;\n\n    self._namedSubs.forEach(function (sub, id) {\n      sub._deactivate();\n    });\n    self._namedSubs = new Map();\n\n    self._universalSubs.forEach(function (sub) {\n      sub._deactivate();\n    });\n    self._universalSubs = [];\n  },\n\n  // Determine the remote client's IP address, based on the\n  // HTTP_FORWARDED_COUNT environment variable representing how many\n  // proxies the server is behind.\n  _clientAddress: function () {\n    var self = this;\n\n    // For the reported client address for a connection to be correct,\n    // the developer must set the HTTP_FORWARDED_COUNT environment\n    // variable to an integer representing the number of hops they\n    // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n    // server is behind one proxy.\n    //\n    // This could be computed once at startup instead of every time.\n    var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n    if (httpForwardedCount === 0)\n      return self.socket.remoteAddress;\n\n    var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n    if (! _.isString(forwardedFor))\n      return null;\n    forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n    // Typically the first value in the `x-forwarded-for` header is\n    // the original IP address of the client connecting to the first\n    // proxy.  However, the end user can easily spoof the header, in\n    // which case the first value(s) will be the fake IP address from\n    // the user pretending to be a proxy reporting the original IP\n    // address value.  By counting HTTP_FORWARDED_COUNT back from the\n    // end of the list, we ensure that we get the IP address being\n    // reported by *our* first proxy.\n\n    if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n      return null;\n\n    return forwardedFor[forwardedFor.length - httpForwardedCount];\n  }\n});\n\n/******************************************************************************/\n/* Subscription                                                               */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n    session, handler, subscriptionId, params, name) {\n  var self = this;\n  self._session = session; // type is Session\n\n  /**\n   * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n   * @locus Server\n   * @name  connection\n   * @memberOf Subscription\n   * @instance\n   */\n  self.connection = session.connectionHandle; // public API object\n\n  self._handler = handler;\n\n  // my subscription ID (generated by client, undefined for universal subs).\n  self._subscriptionId = subscriptionId;\n  // undefined for universal subs\n  self._name = name;\n\n  self._params = params || [];\n\n  // Only named subscriptions have IDs, but we need some sort of string\n  // internally to keep track of all subscriptions inside\n  // SessionDocumentViews. We use this subscriptionHandle for that.\n  if (self._subscriptionId) {\n    self._subscriptionHandle = 'N' + self._subscriptionId;\n  } else {\n    self._subscriptionHandle = 'U' + Random.id();\n  }\n\n  // has _deactivate been called?\n  self._deactivated = false;\n\n  // stop callbacks to g/c this sub.  called w/ zero arguments.\n  self._stopCallbacks = [];\n\n  // the set of (collection, documentid) that this subscription has\n  // an opinion about\n  self._documents = new Map();\n\n  // remember if we are ready.\n  self._ready = false;\n\n  // Part of the public API: the user of this sub.\n\n  /**\n   * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n   * @locus Server\n   * @memberOf Subscription\n   * @name  userId\n   * @instance\n   */\n  self.userId = session.userId;\n\n  // For now, the id filter is going to default to\n  // the to/from DDP methods on MongoID, to\n  // specifically deal with mongo/minimongo ObjectIds.\n\n  // Later, you will be able to make this be \"raw\"\n  // if you want to publish a collection that you know\n  // just has strings for keys and no funny business, to\n  // a ddp consumer that isn't minimongo\n\n  self._idFilter = {\n    idStringify: MongoID.idStringify,\n    idParse: MongoID.idParse\n  };\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n  _runHandler: function () {\n    // XXX should we unblock() here? Either before running the publish\n    // function, or before running _publishCursor.\n    //\n    // Right now, each publish function blocks all future publishes and\n    // methods waiting on data from Mongo (or whatever else the function\n    // blocks on). This probably slows page load in common cases.\n\n    var self = this;\n    try {\n      var res = DDP._CurrentPublicationInvocation.withValue(\n        self,\n        () => maybeAuditArgumentChecks(\n          self._handler, self, EJSON.clone(self._params),\n          // It's OK that this would look weird for universal subscriptions,\n          // because they have no arguments so there can never be an\n          // audit-argument-checks failure.\n          \"publisher '\" + self._name + \"'\"\n        )\n      );\n    } catch (e) {\n      self.error(e);\n      return;\n    }\n\n    // Did the handler call this.error or this.stop?\n    if (self._isDeactivated())\n      return;\n\n    self._publishHandlerResult(res);\n  },\n\n  _publishHandlerResult: function (res) {\n    // SPECIAL CASE: Instead of writing their own callbacks that invoke\n    // this.added/changed/ready/etc, the user can just return a collection\n    // cursor or array of cursors from the publish function; we call their\n    // _publishCursor method which starts observing the cursor and publishes the\n    // results. Note that _publishCursor does NOT call ready().\n    //\n    // XXX This uses an undocumented interface which only the Mongo cursor\n    // interface publishes. Should we make this interface public and encourage\n    // users to implement it themselves? Arguably, it's unnecessary; users can\n    // already write their own functions like\n    //   var publishMyReactiveThingy = function (name, handler) {\n    //     Meteor.publish(name, function () {\n    //       var reactiveThingy = handler();\n    //       reactiveThingy.publishMe();\n    //     });\n    //   };\n\n    var self = this;\n    var isCursor = function (c) {\n      return c && c._publishCursor;\n    };\n    if (isCursor(res)) {\n      try {\n        res._publishCursor(self);\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      // _publishCursor only returns after the initial added callbacks have run.\n      // mark subscription as ready.\n      self.ready();\n    } else if (_.isArray(res)) {\n      // check all the elements are cursors\n      if (! _.all(res, isCursor)) {\n        self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n        return;\n      }\n      // find duplicate collection names\n      // XXX we should support overlapping cursors, but that would require the\n      // merge box to allow overlap within a subscription\n      var collectionNames = {};\n      for (var i = 0; i < res.length; ++i) {\n        var collectionName = res[i]._getCollectionName();\n        if (_.has(collectionNames, collectionName)) {\n          self.error(new Error(\n            \"Publish function returned multiple cursors for collection \" +\n              collectionName));\n          return;\n        }\n        collectionNames[collectionName] = true;\n      };\n\n      try {\n        _.each(res, function (cur) {\n          cur._publishCursor(self);\n        });\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      self.ready();\n    } else if (res) {\n      // truthy values other than cursors or arrays are probably a\n      // user mistake (possible returning a Mongo document via, say,\n      // `coll.findOne()`).\n      self.error(new Error(\"Publish function can only return a Cursor or \"\n                           + \"an array of Cursors\"));\n    }\n  },\n\n  // This calls all stop callbacks and prevents the handler from updating any\n  // SessionCollectionViews further. It's used when the user unsubscribes or\n  // disconnects, as well as during setUserId re-runs. It does *NOT* send\n  // removed messages for the published objects; if that is necessary, call\n  // _removeAllDocuments first.\n  _deactivate: function() {\n    var self = this;\n    if (self._deactivated)\n      return;\n    self._deactivated = true;\n    self._callStopCallbacks();\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"subscriptions\", -1);\n  },\n\n  _callStopCallbacks: function () {\n    var self = this;\n    // tell listeners, so they can clean up\n    var callbacks = self._stopCallbacks;\n    self._stopCallbacks = [];\n    _.each(callbacks, function (callback) {\n      callback();\n    });\n  },\n\n  // Send remove messages for every document.\n  _removeAllDocuments: function () {\n    var self = this;\n    Meteor._noYieldsAllowed(function () {\n      self._documents.forEach(function (collectionDocs, collectionName) {\n        collectionDocs.forEach(function (strId) {\n          self.removed(collectionName, self._idFilter.idParse(strId));\n        });\n      });\n    });\n  },\n\n  // Returns a new Subscription for the same session with the same\n  // initial creation parameters. This isn't a clone: it doesn't have\n  // the same _documents cache, stopped state or callbacks; may have a\n  // different _subscriptionHandle, and gets its userId from the\n  // session, not from this object.\n  _recreate: function () {\n    var self = this;\n    return new Subscription(\n      self._session, self._handler, self._subscriptionId, self._params,\n      self._name);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n   * @locus Server\n   * @param {Error} error The error to pass to the client.\n   * @instance\n   * @memberOf Subscription\n   */\n  error: function (error) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId, error);\n  },\n\n  // Note that while our DDP client will notice that you've called stop() on the\n  // server (and clean up its _subscriptions table) we don't actually provide a\n  // mechanism for an app to notice this (the subscribe onError callback only\n  // triggers if there is an error).\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.\n   * @locus Server\n   * @instance\n   * @memberOf Subscription\n   */\n  stop: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {Function} func The callback function\n   */\n  onStop: function (callback) {\n    var self = this;\n    callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n    if (self._isDeactivated())\n      callback();\n    else\n      self._stopCallbacks.push(callback);\n  },\n\n  // This returns true if the sub has been deactivated, *OR* if the session was\n  // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n  // happened yet.\n  _isDeactivated: function () {\n    var self = this;\n    return self._deactivated || self._session.inQueue === null;\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the new document.\n   * @param {String} id The new document's ID.\n   * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.\n   */\n  added: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    let ids = self._documents.get(collectionName);\n    if (ids == null) {\n      ids = new Set();\n      self._documents.set(collectionName, ids);\n    }\n    ids.add(id);\n    self._session.added(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the changed document.\n   * @param {String} id The changed document's ID.\n   * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.\n   */\n  changed: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that the document has been removed from.\n   * @param {String} id The ID of the document that has been removed.\n   */\n  removed: function (collectionName, id) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    // We don't bother to delete sets of things in a collection if the\n    // collection is empty.  It could break _removeAllDocuments.\n    self._documents.get(collectionName).delete(id);\n    self._session.removed(self._subscriptionHandle, collectionName, id);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   */\n  ready: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    if (!self._subscriptionId)\n      return;  // unnecessary but ignored for universal sub\n    if (!self._ready) {\n      self._session.sendReady([self._subscriptionId]);\n      self._ready = true;\n    }\n  }\n});\n\n/******************************************************************************/\n/* Server                                                                     */\n/******************************************************************************/\n\nServer = function (options) {\n  var self = this;\n\n  // The default heartbeat interval is 30 seconds on the server and 35\n  // seconds on the client.  Since the client doesn't need to send a\n  // ping as long as it is receiving pings, this means that pings\n  // normally go from the server to the client.\n  //\n  // Note: Troposphere depends on the ability to mutate\n  // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n  self.options = _.defaults(options || {}, {\n    heartbeatInterval: 15000,\n    heartbeatTimeout: 15000,\n    // For testing, allow responding to pings to be disabled.\n    respondToPings: true\n  });\n\n  // Map of callbacks to call when a new connection comes in to the\n  // server and completes DDP version negotiation. Use an object instead\n  // of an array so we can safely remove one from the list while\n  // iterating over it.\n  self.onConnectionHook = new Hook({\n    debugPrintExceptions: \"onConnection callback\"\n  });\n\n  // Map of callbacks to call when a new message comes in.\n  self.onMessageHook = new Hook({\n    debugPrintExceptions: \"onMessage callback\"\n  });\n\n  self.publish_handlers = {};\n  self.universal_publish_handlers = [];\n\n  self.method_handlers = {};\n\n  self.sessions = new Map(); // map from id to session\n\n  self.stream_server = new StreamServer;\n\n  self.stream_server.register(function (socket) {\n    // socket implements the SockJSConnection interface\n    socket._meteorSession = null;\n\n    var sendError = function (reason, offendingMessage) {\n      var msg = {msg: 'error', reason: reason};\n      if (offendingMessage)\n        msg.offendingMessage = offendingMessage;\n      socket.send(DDPCommon.stringifyDDP(msg));\n    };\n\n    socket.on('data', function (raw_msg) {\n      if (Meteor._printReceivedDDP) {\n        Meteor._debug(\"Received DDP\", raw_msg);\n      }\n      try {\n        try {\n          var msg = DDPCommon.parseDDP(raw_msg);\n        } catch (err) {\n          sendError('Parse error');\n          return;\n        }\n        if (msg === null || !msg.msg) {\n          sendError('Bad request', msg);\n          return;\n        }\n\n        if (msg.msg === 'connect') {\n          if (socket._meteorSession) {\n            sendError(\"Already connected\", msg);\n            return;\n          }\n          Fiber(function () {\n            self._handleConnect(socket, msg);\n          }).run();\n          return;\n        }\n\n        if (!socket._meteorSession) {\n          sendError('Must connect first', msg);\n          return;\n        }\n        socket._meteorSession.processMessage(msg);\n      } catch (e) {\n        // XXX print stack nicely\n        Meteor._debug(\"Internal exception while processing message\", msg, e);\n      }\n    });\n\n    socket.on('close', function () {\n      if (socket._meteorSession) {\n        Fiber(function () {\n          socket._meteorSession.close();\n        }).run();\n      }\n    });\n  });\n};\n\n_.extend(Server.prototype, {\n\n  /**\n   * @summary Register a callback to be called when a new DDP connection is made to the server.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP connection is established.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onConnection: function (fn) {\n    var self = this;\n    return self.onConnectionHook.register(fn);\n  },\n\n  /**\n   * @summary Register a callback to be called when a new DDP message is received.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP message is received.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onMessage: function (fn) {\n    var self = this;\n    return self.onMessageHook.register(fn);\n  },\n\n  _handleConnect: function (socket, msg) {\n    var self = this;\n\n    // The connect message must specify a version and an array of supported\n    // versions, and it must claim to support what it is proposing.\n    if (!(typeof (msg.version) === 'string' &&\n          _.isArray(msg.support) &&\n          _.all(msg.support, _.isString) &&\n          _.contains(msg.support, msg.version))) {\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n                                version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n      socket.close();\n      return;\n    }\n\n    // In the future, handle session resumption: something like:\n    //  socket._meteorSession = self.sessions[msg.session]\n    var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n    if (msg.version !== version) {\n      // The best version to use (according to the client's stated preferences)\n      // is not the one the client is trying to use. Inform them about the best\n      // version to use.\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n      socket.close();\n      return;\n    }\n\n    // Yay, version matches! Create a new session.\n    // Note: Troposphere depends on the ability to mutate\n    // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n    socket._meteorSession = new Session(self, version, socket, self.options);\n    self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n    self.onConnectionHook.each(function (callback) {\n      if (socket._meteorSession)\n        callback(socket._meteorSession.connectionHandle);\n      return true;\n    });\n  },\n  /**\n   * Register a publish handler function.\n   *\n   * @param name {String} identifier for query\n   * @param handler {Function} publish handler\n   * @param options {Object}\n   *\n   * Server will call handler function on each new subscription,\n   * either when receiving DDP sub message for a named subscription, or on\n   * DDP connect for a universal subscription.\n   *\n   * If name is null, this will be a subscription that is\n   * automatically established and permanently on for all connected\n   * client, instead of a subscription that can be turned on and off\n   * with subscribe().\n   *\n   * options to contain:\n   *  - (mostly internal) is_auto: true if generated automatically\n   *    from an autopublish hook. this is for cosmetic purposes only\n   *    (it lets us determine whether to print a warning suggesting\n   *    that you turn off autopublish.)\n   */\n\n  /**\n   * @summary Publish a record set.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   * @locus Server\n   * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n   * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.\n   */\n  publish: function (name, handler, options) {\n    var self = this;\n\n    if (! _.isObject(name)) {\n      options = options || {};\n\n      if (name && name in self.publish_handlers) {\n        Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n        return;\n      }\n\n      if (Package.autopublish && !options.is_auto) {\n        // They have autopublish on, yet they're trying to manually\n        // picking stuff to publish. They probably should turn off\n        // autopublish. (This check isn't perfect -- if you create a\n        // publish before you turn on autopublish, it won't catch\n        // it. But this will definitely handle the simple case where\n        // you've added the autopublish package to your app, and are\n        // calling publish from your app code.)\n        if (!self.warned_about_autopublish) {\n          self.warned_about_autopublish = true;\n          Meteor._debug(\n    \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n    \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n    \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n    \"** will still be sent to all clients.\\n\" +\n    \"**\\n\" +\n    \"** Turn off autopublish by removing the autopublish package:\\n\" +\n    \"**\\n\" +\n    \"**   $ meteor remove autopublish\\n\" +\n    \"**\\n\" +\n    \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n    \"** for each collection that you want clients to see.\\n\");\n        }\n      }\n\n      if (name)\n        self.publish_handlers[name] = handler;\n      else {\n        self.universal_publish_handlers.push(handler);\n        // Spin up the new publisher on any existing session too. Run each\n        // session's subscription in a new Fiber, so that there's no change for\n        // self.sessions to change while we're running this loop.\n        self.sessions.forEach(function (session) {\n          if (!session._dontStartNewUniversalSubs) {\n            Fiber(function() {\n              session._startSubscription(handler);\n            }).run();\n          }\n        });\n      }\n    }\n    else{\n      _.each(name, function(value, key) {\n        self.publish(key, value, {});\n      });\n    }\n  },\n\n  _removeSession: function (session) {\n    var self = this;\n    self.sessions.delete(session.id);\n  },\n\n  /**\n   * @summary Defines functions that can be invoked over the network by clients.\n   * @locus Anywhere\n   * @param {Object} methods Dictionary whose keys are method names and values are functions.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  methods: function (methods) {\n    var self = this;\n    _.each(methods, function (func, name) {\n      if (typeof func !== 'function')\n        throw new Error(\"Method '\" + name + \"' must be a function\");\n      if (self.method_handlers[name])\n        throw new Error(\"A method named '\" + name + \"' is already defined\");\n      self.method_handlers[name] = func;\n    });\n  },\n\n  call: function (name, ...args) {\n    if (args.length && typeof args[args.length - 1] === \"function\") {\n      // If it's a function, the last argument is the result callback, not\n      // a parameter to the remote method.\n      var callback = args.pop();\n    }\n\n    return this.apply(name, args, callback);\n  },\n\n  // A version of the call method that always returns a Promise.\n  callAsync: function (name, ...args) {\n    return this.applyAsync(name, args);\n  },\n\n  apply: function (name, args, options, callback) {\n    // We were passed 3 arguments. They may be either (name, args, options)\n    // or (name, args, callback)\n    if (! callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    } else {\n      options = options || {};\n    }\n\n    const promise = this.applyAsync(name, args, options);\n\n    // Return the result in whichever way the caller asked for it. Note that we\n    // do NOT block on the write fence in an analogous way to how the client\n    // blocks on the relevant data being visible, so you are NOT guaranteed that\n    // cursor observe callbacks have fired when your callback is invoked. (We\n    // can change this if there's a real use case.)\n    if (callback) {\n      promise.then(\n        result => callback(undefined, result),\n        exception => callback(exception)\n      );\n    } else {\n      return promise.await();\n    }\n  },\n\n  // @param options {Optional Object}\n  applyAsync: function (name, args, options) {\n    // Run the handler\n    var handler = this.method_handlers[name];\n    if (! handler) {\n      return Promise.reject(\n        new Meteor.Error(404, `Method '${name}' not found`)\n      );\n    }\n\n    // If this is a method call from within another method or publish function,\n    // get the user state from the outer method or publish function, otherwise\n    // don't allow setUserId to be called\n    var userId = null;\n    var setUserId = function() {\n      throw new Error(\"Can't call setUserId on a server initiated method call\");\n    };\n    var connection = null;\n    var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n    var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n    var randomSeed = null;\n    if (currentMethodInvocation) {\n      userId = currentMethodInvocation.userId;\n      setUserId = function(userId) {\n        currentMethodInvocation.setUserId(userId);\n      };\n      connection = currentMethodInvocation.connection;\n      randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n    } else if (currentPublicationInvocation) {\n      userId = currentPublicationInvocation.userId;\n      setUserId = function(userId) {\n        currentPublicationInvocation._session._setUserId(userId);\n      };\n      connection = currentPublicationInvocation.connection;\n    }\n\n    var invocation = new DDPCommon.MethodInvocation({\n      isSimulation: false,\n      userId,\n      setUserId,\n      connection,\n      randomSeed\n    });\n\n    return new Promise(resolve => resolve(\n      DDP._CurrentMethodInvocation.withValue(\n        invocation,\n        () => maybeAuditArgumentChecks(\n          handler, invocation, EJSON.clone(args),\n          \"internal call to '\" + name + \"'\"\n        )\n      )\n    )).then(EJSON.clone);\n  },\n\n  _urlForSession: function (sessionId) {\n    var self = this;\n    var session = self.sessions.get(sessionId);\n    if (session)\n      return session._socketUrl;\n    else\n      return null;\n  }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n                                 serverSupportedVersions) {\n  var correctVersion = _.find(clientSupportedVersions, function (version) {\n    return _.contains(serverSupportedVersions, version);\n  });\n  if (!correctVersion) {\n    correctVersion = serverSupportedVersions[0];\n  }\n  return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n  if (!exception) return exception;\n\n  // To allow packages to throw errors intended for the client but not have to\n  // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n  // error before it is thrown.\n  if (exception.isClientSafe) {\n    if (!(exception instanceof Meteor.Error)) {\n      const originalMessage = exception.message;\n      exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n      exception.message = originalMessage;\n    }\n    return exception;\n  }\n\n  // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n  // the server log.\n  if (!exception._expectedByTest) {\n    Meteor._debug(\"Exception \" + context, exception.stack);\n    if (exception.sanitizedError) {\n      Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n      Meteor._debug();\n    }\n  }\n\n  // Did the error contain more details that could have been useful if caught in\n  // server code (or if thrown from non-client-originated code), but also\n  // provided a \"sanitized\" version with more context than 500 Internal server\n  // error? Use that.\n  if (exception.sanitizedError) {\n    if (exception.sanitizedError.isClientSafe)\n      return exception.sanitizedError;\n    Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n                  \"does not have isClientSafe property set; ignoring\");\n  }\n\n  return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n  args = args || [];\n  if (Package['audit-argument-checks']) {\n    return Match._failIfArgumentsAreNotAllChecked(\n      f, context, args, description);\n  }\n  return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n  var self = this;\n\n  self.armed = false;\n  self.fired = false;\n  self.retired = false;\n  self.outstanding_writes = 0;\n  self.before_fire_callbacks = [];\n  self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n  // Start tracking a write, and return an object to represent it. The\n  // object has a single method, committed(). This method should be\n  // called when the write is fully committed and propagated. You can\n  // continue to add writes to the WriteFence up until it is triggered\n  // (calls its callbacks because all writes have committed.)\n  beginWrite: function () {\n    var self = this;\n\n    if (self.retired)\n      return { committed: function () {} };\n\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to add writes\");\n\n    self.outstanding_writes++;\n    var committed = false;\n    return {\n      committed: function () {\n        if (committed)\n          throw new Error(\"committed called twice on the same write\");\n        committed = true;\n        self.outstanding_writes--;\n        self._maybeFire();\n      }\n    };\n  },\n\n  // Arm the fence. Once the fence is armed, and there are no more\n  // uncommitted writes, it will activate.\n  arm: function () {\n    var self = this;\n    if (self === DDPServer._CurrentWriteFence.get())\n      throw Error(\"Can't arm the current fence\");\n    self.armed = true;\n    self._maybeFire();\n  },\n\n  // Register a function to be called once before firing the fence.\n  // Callback function can add new writes to the fence, in which case\n  // it won't fire until those writes are done as well.\n  onBeforeFire: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.before_fire_callbacks.push(func);\n  },\n\n  // Register a function to be called when the fence fires.\n  onAllCommitted: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.completion_callbacks.push(func);\n  },\n\n  // Convenience function. Arms the fence, then blocks until it fires.\n  armAndWait: function () {\n    var self = this;\n    var future = new Future;\n    self.onAllCommitted(function () {\n      future['return']();\n    });\n    self.arm();\n    future.wait();\n  },\n\n  _maybeFire: function () {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"write fence already activated?\");\n    if (self.armed && !self.outstanding_writes) {\n      function invokeCallback (func) {\n        try {\n          func(self);\n        } catch (err) {\n          Meteor._debug(\"exception in write fence callback\", err);\n        }\n      }\n\n      self.outstanding_writes++;\n      while (self.before_fire_callbacks.length > 0) {\n        var callbacks = self.before_fire_callbacks;\n        self.before_fire_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n      self.outstanding_writes--;\n\n      if (!self.outstanding_writes) {\n        self.fired = true;\n        var callbacks = self.completion_callbacks;\n        self.completion_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n    }\n  },\n\n  // Deactivate this fence so that adding more writes has no effect.\n  // The fence must have already fired.\n  retire: function () {\n    var self = this;\n    if (! self.fired)\n      throw new Error(\"Can't retire a fence that hasn't fired.\");\n    self.retired = true;\n  }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n  var self = this;\n  options = options || {};\n\n  self.nextId = 1;\n  // map from collection name (string) -> listener id -> object. each object has\n  // keys 'trigger', 'callback'.  As a hack, the empty string means \"no\n  // collection\".\n  self.listenersByCollection = {};\n  self.listenersByCollectionCount = {};\n  self.factPackage = options.factPackage || \"livedata\";\n  self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n  // msg is a trigger or a notification\n  _collectionForMessage: function (msg) {\n    var self = this;\n    if (! _.has(msg, 'collection')) {\n      return '';\n    } else if (typeof(msg.collection) === 'string') {\n      if (msg.collection === '')\n        throw Error(\"Message has empty collection!\");\n      return msg.collection;\n    } else {\n      throw Error(\"Message has non-string collection!\");\n    }\n  },\n\n  // Listen for notification that match 'trigger'. A notification\n  // matches if it has the key-value pairs in trigger as a\n  // subset. When a notification matches, call 'callback', passing\n  // the actual notification.\n  //\n  // Returns a listen handle, which is an object with a method\n  // stop(). Call stop() to stop listening.\n  //\n  // XXX It should be legal to call fire() from inside a listen()\n  // callback?\n  listen: function (trigger, callback) {\n    var self = this;\n    var id = self.nextId++;\n\n    var collection = self._collectionForMessage(trigger);\n    var record = {trigger: EJSON.clone(trigger), callback: callback};\n    if (! _.has(self.listenersByCollection, collection)) {\n      self.listenersByCollection[collection] = {};\n      self.listenersByCollectionCount[collection] = 0;\n    }\n    self.listenersByCollection[collection][id] = record;\n    self.listenersByCollectionCount[collection]++;\n\n    if (self.factName && Package['facts-base']) {\n      Package['facts-base'].Facts.incrementServerFact(\n        self.factPackage, self.factName, 1);\n    }\n\n    return {\n      stop: function () {\n        if (self.factName && Package['facts-base']) {\n          Package['facts-base'].Facts.incrementServerFact(\n            self.factPackage, self.factName, -1);\n        }\n        delete self.listenersByCollection[collection][id];\n        self.listenersByCollectionCount[collection]--;\n        if (self.listenersByCollectionCount[collection] === 0) {\n          delete self.listenersByCollection[collection];\n          delete self.listenersByCollectionCount[collection];\n        }\n      }\n    };\n  },\n\n  // Fire the provided 'notification' (an object whose attribute\n  // values are all JSON-compatibile) -- inform all matching listeners\n  // (registered with listen()).\n  //\n  // If fire() is called inside a write fence, then each of the\n  // listener callbacks will be called inside the write fence as well.\n  //\n  // The listeners may be invoked in parallel, rather than serially.\n  fire: function (notification) {\n    var self = this;\n\n    var collection = self._collectionForMessage(notification);\n\n    if (! _.has(self.listenersByCollection, collection)) {\n      return;\n    }\n\n    var listenersForCollection = self.listenersByCollection[collection];\n    var callbackIds = [];\n    _.each(listenersForCollection, function (l, id) {\n      if (self._matches(notification, l.trigger)) {\n        callbackIds.push(id);\n      }\n    });\n\n    // Listener callbacks can yield, so we need to first find all the ones that\n    // match in a single iteration over self.listenersByCollection (which can't\n    // be mutated during this iteration), and then invoke the matching\n    // callbacks, checking before each call to ensure they haven't stopped.\n    // Note that we don't have to check that\n    // self.listenersByCollection[collection] still === listenersForCollection,\n    // because the only way that stops being true is if listenersForCollection\n    // first gets reduced down to the empty object (and then never gets\n    // increased again).\n    _.each(callbackIds, function (id) {\n      if (_.has(listenersForCollection, id)) {\n        listenersForCollection[id].callback(notification);\n      }\n    });\n  },\n\n  // A notification matches a trigger if all keys that exist in both are equal.\n  //\n  // Examples:\n  //  N:{collection: \"C\"} matches T:{collection: \"C\"}\n  //    (a non-targeted write to a collection matches a\n  //     non-targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n  //    (a targeted write to a collection matches a non-targeted query)\n  //  N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a non-targeted write to a collection matches a\n  //     targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a targeted write to a collection matches a targeted query targeted\n  //     at the same document)\n  //  N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n  //    (a targeted write to a collection does not match a targeted query\n  //     targeted at a different document)\n  _matches: function (notification, trigger) {\n    // Most notifications that use the crossbar have a string `collection` and\n    // maybe an `id` that is a string or ObjectID. We're already dividing up\n    // triggers by collection, but let's fast-track \"nope, different ID\" (and\n    // avoid the overly generic EJSON.equals). This makes a noticeable\n    // performance difference; see https://github.com/meteor/meteor/pull/3697\n    if (typeof(notification.id) === 'string' &&\n        typeof(trigger.id) === 'string' &&\n        notification.id !== trigger.id) {\n      return false;\n    }\n    if (notification.id instanceof MongoID.ObjectID &&\n        trigger.id instanceof MongoID.ObjectID &&\n        ! notification.id.equals(trigger.id)) {\n      return false;\n    }\n\n    return _.all(trigger, function (triggerValue, key) {\n      return !_.has(notification, key) ||\n        EJSON.equals(triggerValue, notification[key]);\n    });\n  }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n  factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n  __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n    process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n  DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n       function (name) {\n         Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n       });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} diff --git a/server/bundle/programs/server/packages/ddp-server.js.map b/server/bundle/programs/server/packages/ddp-server.js.map index 15ae6c399a..96d6a02426 100644 --- a/server/bundle/programs/server/packages/ddp-server.js.map +++ b/server/bundle/programs/server/packages/ddp-server.js.map @@ -1 +1 @@ -{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAIA,GAAG,GAAGC,GAAG,CAACC,OAAJ,CAAY,KAAZ,CAAV,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,IAAIC,mBAAmB,GAAGC,CAAC,CAACC,IAAF,CAAO,YAAY;AAC3C,MAAIC,UAAU,GAAG,EAAjB;AAEA,MAAIC,0BAA0B,GAAGC,OAAO,CAACC,GAAR,CAAYC,4BAAZ,GACzBC,IAAI,CAACC,KAAL,CAAWJ,OAAO,CAACC,GAAR,CAAYC,4BAAvB,CADyB,GAC8B,EAD/D;;AAEA,MAAIH,0BAAJ,EAAgC;AAC9BD,cAAU,CAACO,IAAX,CAAgBZ,GAAG,CAACC,OAAJ,CAAY,oBAAZ,EAAkCY,SAAlC,CACdP,0BADc,CAAhB;AAGD;;AAED,SAAOD,UAAP;AACD,CAZyB,CAA1B;;AAcA,IAAIS,UAAU,GAAGC,yBAAyB,CAACC,oBAA1B,IAAmD,EAApE;;AAEAC,YAAY,GAAG,YAAY;AACzB,MAAIC,IAAI,GAAG,IAAX;AACAA,MAAI,CAACC,sBAAL,GAA8B,EAA9B;AACAD,MAAI,CAACE,YAAL,GAAoB,EAApB,CAHyB,CAKzB;AACA;;AACAF,MAAI,CAACG,MAAL,GAAcP,UAAU,GAAG,SAA3B;AACAQ,aAAW,CAACC,OAAZ,CAAoBL,IAAI,CAACG,MAAL,GAAc,GAAlC,EAAuC,SAAvC,EARyB,CAUzB;;AACA,MAAIG,MAAM,GAAGxB,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAb;;AACA,MAAIwB,aAAa,GAAG;AAClBJ,UAAM,EAAEH,IAAI,CAACG,MADK;AAElBK,OAAG,EAAE,YAAW,CAAE,CAFA;AAGlB;AACA;AACAC,mBAAe,EAAE,KALC;AAMlB;AACA;AACA;AACA;AACA;AACA;AACAC,oBAAgB,EAAE,KAAK,IAZL;AAalB;AACA;AACA;AACAC,cAAU,EAAE,CAAC,CAACtB,OAAO,CAACC,GAAR,CAAYsB;AAhBR,GAApB,CAZyB,CA+BzB;AACA;AACA;AACA;;AACA,MAAIvB,OAAO,CAACC,GAAR,CAAYuB,kBAAhB,EAAoC;AAClCN,iBAAa,CAACO,SAAd,GAA0B,KAA1B;AACD,GAFD,MAEO;AACLP,iBAAa,CAACQ,mBAAd,GAAoC;AAClC5B,gBAAU,EAAEH,mBAAmB;AADG,KAApC;AAGD;;AAEDgB,MAAI,CAACgB,MAAL,GAAcV,MAAM,CAACW,YAAP,CAAoBV,aAApB,CAAd,CA3CyB,CA6CzB;AACA;AACA;AACA;;AACAW,QAAM,CAACC,UAAP,CAAkBC,cAAlB,CACE,SADF,EACaF,MAAM,CAACG,iCADpB;AAEArB,MAAI,CAACgB,MAAL,CAAYM,eAAZ,CAA4BJ,MAAM,CAACC,UAAnC;AACAD,QAAM,CAACC,UAAP,CAAkBI,WAAlB,CACE,SADF,EACaL,MAAM,CAACG,iCADpB,EApDyB,CAuDzB;;AACArB,MAAI,CAACwB,0BAAL;;AAEAxB,MAAI,CAACgB,MAAL,CAAYS,EAAZ,CAAe,YAAf,EAA6B,UAAUC,MAAV,EAAkB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,UAAM,CAACC,mBAAP,GAA6B,UAAUC,OAAV,EAAmB;AAC9C,UAAI,CAACF,MAAM,CAACG,QAAP,KAAoB,WAApB,IACAH,MAAM,CAACG,QAAP,KAAoB,eADrB,KAEGH,MAAM,CAACI,QAAP,CAAgBC,IAFvB,EAE6B;AAC3BL,cAAM,CAACI,QAAP,CAAgBC,IAAhB,CAAqBC,UAArB,CAAgCC,UAAhC,CAA2CL,OAA3C;AACD;AACF,KAND;;AAOAF,UAAM,CAACC,mBAAP,CAA2B,KAAK,IAAhC;;AAEAD,UAAM,CAACQ,IAAP,GAAc,UAAUC,IAAV,EAAgB;AAC5BT,YAAM,CAACU,KAAP,CAAaD,IAAb;AACD,KAFD;;AAGAT,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7BzB,UAAI,CAACE,YAAL,GAAoBjB,CAAC,CAACoD,OAAF,CAAUrC,IAAI,CAACE,YAAf,EAA6BwB,MAA7B,CAApB;AACD,KAFD;AAGA1B,QAAI,CAACE,YAAL,CAAkBR,IAAlB,CAAuBgC,MAAvB,EA1B6C,CA4B7C;AACA;AACA;AACA;AACA;;AACAA,UAAM,CAACQ,IAAP,CAAY1C,IAAI,CAAC8C,SAAL,CAAe;AAACC,eAAS,EAAE;AAAZ,KAAf,CAAZ,EAjC6C,CAmC7C;AACA;;AACAtD,KAAC,CAACuD,IAAF,CAAOxC,IAAI,CAACC,sBAAZ,EAAoC,UAAUwC,QAAV,EAAoB;AACtDA,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAxCD;AA0CD,CApGD;;AAsGAzC,CAAC,CAACyD,MAAF,CAAS3C,YAAY,CAAC4C,SAAtB,EAAiC;AAC/B;AACA;AACAC,UAAQ,EAAE,UAAUH,QAAV,EAAoB;AAC5B,QAAIzC,IAAI,GAAG,IAAX;AACAA,QAAI,CAACC,sBAAL,CAA4BP,IAA5B,CAAiC+C,QAAjC;;AACAxD,KAAC,CAACuD,IAAF,CAAOxC,IAAI,CAAC6C,WAAL,EAAP,EAA2B,UAAUnB,MAAV,EAAkB;AAC3Ce,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAT8B;AAW/B;AACAmB,aAAW,EAAE,YAAY;AACvB,QAAI7C,IAAI,GAAG,IAAX;AACA,WAAOf,CAAC,CAAC6D,MAAF,CAAS9C,IAAI,CAACE,YAAd,CAAP;AACD,GAf8B;AAiB/B;AACA;AACAsB,4BAA0B,EAAE,YAAW;AACrC,QAAIxB,IAAI,GAAG,IAAX,CADqC,CAErC;AACA;AACA;AACA;AACA;;AACAf,KAAC,CAACuD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,CAAP,EAA+B,UAASO,KAAT,EAAgB;AAC7C,UAAI5B,UAAU,GAAGD,MAAM,CAACC,UAAxB;AACA,UAAI6B,sBAAsB,GAAG7B,UAAU,CAAC8B,SAAX,CAAqBF,KAArB,EAA4BG,KAA5B,CAAkC,CAAlC,CAA7B;AACA/B,gBAAU,CAACgC,kBAAX,CAA8BJ,KAA9B,EAH6C,CAK7C;AACA;;AACA,UAAIK,WAAW,GAAG,UAASC;AAAQ;AAAjB,QAAuC;AACvD;AACA,YAAIC,IAAI,GAAGC,SAAX,CAFuD,CAIvD;AACA;;AACA,YAAIC,SAAS,GAAG3E,GAAG,CAACY,KAAJ,CAAU4D,OAAO,CAACxE,GAAlB,CAAhB;;AACA,YAAI2E,SAAS,CAACC,QAAV,KAAuB7D,UAAU,GAAG,YAApC,IACA4D,SAAS,CAACC,QAAV,KAAuB7D,UAAU,GAAG,aADxC,EACuD;AACrD4D,mBAAS,CAACC,QAAV,GAAqBzD,IAAI,CAACG,MAAL,GAAc,YAAnC;AACAkD,iBAAO,CAACxE,GAAR,GAAcA,GAAG,CAAC6E,MAAJ,CAAWF,SAAX,CAAd;AACD;;AACDvE,SAAC,CAACuD,IAAF,CAAOQ,sBAAP,EAA+B,UAASW,WAAT,EAAsB;AACnDA,qBAAW,CAACC,KAAZ,CAAkBzC,UAAlB,EAA8BmC,IAA9B;AACD,SAFD;AAGD,OAfD;;AAgBAnC,gBAAU,CAACI,WAAX,CAAuBwB,KAAvB,EAA8BK,WAA9B;AACD,KAxBD;AAyBD;AAnD8B,CAAjC,E;;;;;;;;;;;ACnIAS,SAAS,GAAG,EAAZ;;AAEA,IAAIC,KAAK,GAAGhF,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAZ,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;AACA,IAAIgF,mBAAmB,GAAG,YAAY;AACpC,MAAI/D,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgE,QAAL,GAAgB,IAAIC,GAAJ,EAAhB,CAFoC,CAET;;AAC3BjE,MAAI,CAACkE,SAAL,GAAiB,IAAIC,GAAJ,EAAjB,CAHoC,CAGR;AAC7B,CAJD;;AAMAN,SAAS,CAACO,oBAAV,GAAiCL,mBAAjC;;AAGA9E,CAAC,CAACyD,MAAF,CAASqB,mBAAmB,CAACpB,SAA7B,EAAwC;AAEtC0B,WAAS,EAAE,YAAY;AACrB,QAAIrE,IAAI,GAAG,IAAX;AACA,QAAIsE,GAAG,GAAG,EAAV;AACAtE,QAAI,CAACkE,SAAL,CAAeK,OAAf,CAAuB,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACpDH,SAAG,CAACG,GAAD,CAAH,GAAWD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7B;AACD,KAFD;AAGA,WAAOJ,GAAP;AACD,GATqC;AAWtCK,YAAU,EAAE,UAAUC,kBAAV,EAA8BH,GAA9B,EAAmCI,eAAnC,EAAoD;AAC9D,QAAI7E,IAAI,GAAG,IAAX,CAD8D,CAE9D;;AACA,QAAIyE,GAAG,KAAK,KAAZ,EACE;AACF,QAAID,cAAc,GAAGxE,IAAI,CAACkE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB,CAL8D,CAO9D;AACA;;AACA,QAAI,CAACD,cAAL,EACE;AAEF,QAAIO,YAAY,GAAGC,SAAnB;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGT,cAAc,CAACU,MAAnC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9C,UAAIE,UAAU,GAAGX,cAAc,CAACS,CAAD,CAA/B;;AACA,UAAIE,UAAU,CAACP,kBAAX,KAAkCA,kBAAtC,EAA0D;AACxD;AACA;AACA,YAAIK,CAAC,KAAK,CAAV,EACEF,YAAY,GAAGI,UAAU,CAACT,KAA1B;AACFF,sBAAc,CAACY,MAAf,CAAsBH,CAAtB,EAAyB,CAAzB;AACA;AACD;AACF;;AACD,QAAIT,cAAc,CAACU,MAAf,KAA0B,CAA9B,EAAiC;AAC/BlF,UAAI,CAACkE,SAAL,CAAemB,MAAf,CAAsBZ,GAAtB;AACAI,qBAAe,CAACJ,GAAD,CAAf,GAAuBO,SAAvB;AACD,KAHD,MAGO,IAAID,YAAY,KAAKC,SAAjB,IACA,CAACM,KAAK,CAACC,MAAN,CAAaR,YAAb,EAA2BP,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7C,CADL,EAC0D;AAC/DG,qBAAe,CAACJ,GAAD,CAAf,GAAuBD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAAzC;AACD;AACF,GA1CqC;AA4CtCc,aAAW,EAAE,UAAUZ,kBAAV,EAA8BH,GAA9B,EAAmCC,KAAnC,EACUG,eADV,EAC2BY,KAD3B,EACkC;AAC7C,QAAIzF,IAAI,GAAG,IAAX,CAD6C,CAE7C;;AACA,QAAIyE,GAAG,KAAK,KAAZ,EACE,OAJ2C,CAM7C;;AACAC,SAAK,GAAGY,KAAK,CAACI,KAAN,CAAYhB,KAAZ,CAAR;;AAEA,QAAI,CAAC1E,IAAI,CAACkE,SAAL,CAAeyB,GAAf,CAAmBlB,GAAnB,CAAL,EAA8B;AAC5BzE,UAAI,CAACkE,SAAL,CAAe0B,GAAf,CAAmBnB,GAAnB,EAAwB,CAAC;AAACG,0BAAkB,EAAEA,kBAArB;AACCF,aAAK,EAAEA;AADR,OAAD,CAAxB;AAEAG,qBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACA;AACD;;AACD,QAAIF,cAAc,GAAGxE,IAAI,CAACkE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB;AACA,QAAIoB,GAAJ;;AACA,QAAI,CAACJ,KAAL,EAAY;AACVI,SAAG,GAAGrB,cAAc,CAACsB,IAAf,CAAoB,UAAUX,UAAV,EAAsB;AAC5C,eAAOA,UAAU,CAACP,kBAAX,KAAkCA,kBAAzC;AACH,OAFK,CAAN;AAGD;;AAED,QAAIiB,GAAJ,EAAS;AACP,UAAIA,GAAG,KAAKrB,cAAc,CAAC,CAAD,CAAtB,IAA6B,CAACc,KAAK,CAACC,MAAN,CAAab,KAAb,EAAoBmB,GAAG,CAACnB,KAAxB,CAAlC,EAAkE;AAChE;AACAG,uBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACD;;AACDmB,SAAG,CAACnB,KAAJ,GAAYA,KAAZ;AACD,KAND,MAMO;AACL;AACAF,oBAAc,CAAC9E,IAAf,CAAoB;AAACkF,0BAAkB,EAAEA,kBAArB;AAAyCF,aAAK,EAAEA;AAAhD,OAApB;AACD;AAEF;AA/EqC,CAAxC;AAkFA;;;;;;;;AAMA,IAAIqB,qBAAqB,GAAG,UAAUC,cAAV,EAA0BC,gBAA1B,EAA4C;AACtE,MAAIjG,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgG,cAAL,GAAsBA,cAAtB;AACAhG,MAAI,CAACkG,SAAL,GAAiB,IAAI/B,GAAJ,EAAjB;AACAnE,MAAI,CAACmG,SAAL,GAAiBF,gBAAjB;AACD,CALD;;AAOApC,SAAS,CAACuC,sBAAV,GAAmCL,qBAAnC;;AAGA9G,CAAC,CAACyD,MAAF,CAASqD,qBAAqB,CAACpD,SAA/B,EAA0C;AAExC0D,SAAO,EAAE,YAAY;AACnB,QAAIrG,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAACkG,SAAL,CAAeI,IAAf,KAAwB,CAA/B;AACD,GALuC;AAOxCC,MAAI,EAAE,UAAUC,QAAV,EAAoB;AACxB,QAAIxG,IAAI,GAAG,IAAX;AACAyG,gBAAY,CAACC,QAAb,CAAsBF,QAAQ,CAACN,SAA/B,EAA0ClG,IAAI,CAACkG,SAA/C,EAA0D;AACxDS,UAAI,EAAE1H,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAAC6G,YAAZ,EAA0B7G,IAA1B,CADkD;AAGxD8G,eAAS,EAAE,UAAUC,EAAV,EAAcC,KAAd,EAAqB;AAC9BhH,YAAI,CAACmG,SAAL,CAAec,KAAf,CAAqBjH,IAAI,CAACgG,cAA1B,EAA0Ce,EAA1C,EAA8CC,KAAK,CAAC3C,SAAN,EAA9C;AACD,OALuD;AAOxD6C,cAAQ,EAAE,UAAUH,EAAV,EAAcI,MAAd,EAAsB;AAC9BnH,YAAI,CAACmG,SAAL,CAAeiB,OAAf,CAAuBpH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C;AACD;AATuD,KAA1D;AAWD,GApBuC;AAsBxCF,cAAY,EAAE,UAAUE,EAAV,EAAcI,MAAd,EAAsBH,KAAtB,EAA6B;AACzC,QAAIhH,IAAI,GAAG,IAAX;AACA,QAAIqH,MAAM,GAAG,EAAb;AACAZ,gBAAY,CAACa,WAAb,CAAyBH,MAAM,CAAC9C,SAAP,EAAzB,EAA6C2C,KAAK,CAAC3C,SAAN,EAA7C,EAAgE;AAC9DsC,UAAI,EAAE,UAAUlC,GAAV,EAAe8C,IAAf,EAAqBC,GAArB,EAA0B;AAC9B,YAAI,CAAClC,KAAK,CAACC,MAAN,CAAagC,IAAb,EAAmBC,GAAnB,CAAL,EACEH,MAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACH,OAJ6D;AAK9DV,eAAS,EAAE,UAAUrC,GAAV,EAAe+C,GAAf,EAAoB;AAC7BH,cAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACD,OAP6D;AAQ9DN,cAAQ,EAAE,UAASzC,GAAT,EAAc8C,IAAd,EAAoB;AAC5BF,cAAM,CAAC5C,GAAD,CAAN,GAAcO,SAAd;AACD;AAV6D,KAAhE;AAYAhF,QAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDM,MAAhD;AACD,GAtCuC;AAwCxCJ,OAAK,EAAE,UAAUrC,kBAAV,EAA8BmC,EAA9B,EAAkCM,MAAlC,EAA0C;AAC/C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAI0H,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAIE,KAAK,GAAG,KAAZ;;AACA,QAAI,CAACS,OAAL,EAAc;AACZT,WAAK,GAAG,IAAR;AACAS,aAAO,GAAG,IAAI3D,mBAAJ,EAAV;AACA/D,UAAI,CAACkG,SAAL,CAAeN,GAAf,CAAmBmB,EAAnB,EAAuBW,OAAvB;AACD;;AACDA,WAAO,CAAC1D,QAAR,CAAiB2D,GAAjB,CAAqB/C,kBAArB;AACA,QAAIC,eAAe,GAAG,EAAtB;;AACA5F,KAAC,CAACuD,IAAF,CAAO6E,MAAP,EAAe,UAAU3C,KAAV,EAAiBD,GAAjB,EAAsB;AACnCiD,aAAO,CAAClC,WAAR,CACEZ,kBADF,EACsBH,GADtB,EAC2BC,KAD3B,EACkCG,eADlC,EACmD,IADnD;AAED,KAHD;;AAIA,QAAIoC,KAAJ,EACEjH,IAAI,CAACmG,SAAL,CAAec,KAAf,CAAqBjH,IAAI,CAACgG,cAA1B,EAA0Ce,EAA1C,EAA8ClC,eAA9C,EADF,KAGE7E,IAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDlC,eAAhD;AACH,GA3DuC;AA6DxC4C,SAAO,EAAE,UAAU7C,kBAAV,EAA8BmC,EAA9B,EAAkCU,OAAlC,EAA2C;AAClD,QAAIzH,IAAI,GAAG,IAAX;AACA,QAAI4H,aAAa,GAAG,EAApB;AACA,QAAIF,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAI,CAACW,OAAL,EACE,MAAM,IAAIG,KAAJ,CAAU,oCAAoCd,EAApC,GAAyC,YAAnD,CAAN;;AACF9H,KAAC,CAACuD,IAAF,CAAOiF,OAAP,EAAgB,UAAU/C,KAAV,EAAiBD,GAAjB,EAAsB;AACpC,UAAIC,KAAK,KAAKM,SAAd,EACE0C,OAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CmD,aAA5C,EADF,KAGEF,OAAO,CAAClC,WAAR,CAAoBZ,kBAApB,EAAwCH,GAAxC,EAA6CC,KAA7C,EAAoDkD,aAApD;AACH,KALD;;AAMA5H,QAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDa,aAAhD;AACD,GA1EuC;AA4ExCR,SAAO,EAAE,UAAUxC,kBAAV,EAA8BmC,EAA9B,EAAkC;AACzC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAI0H,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;;AACA,QAAI,CAACW,OAAL,EAAc;AACZ,UAAII,GAAG,GAAG,IAAID,KAAJ,CAAU,kCAAkCd,EAA5C,CAAV;AACA,YAAMe,GAAN;AACD;;AACDJ,WAAO,CAAC1D,QAAR,CAAiBqB,MAAjB,CAAwBT,kBAAxB;;AACA,QAAI8C,OAAO,CAAC1D,QAAR,CAAiBsC,IAAjB,KAA0B,CAA9B,EAAiC;AAC/B;AACAtG,UAAI,CAACmG,SAAL,CAAeiB,OAAf,CAAuBpH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C;AACA/G,UAAI,CAACkG,SAAL,CAAeb,MAAf,CAAsB0B,EAAtB;AACD,KAJD,MAIO;AACL,UAAIU,OAAO,GAAG,EAAd,CADK,CAEL;AACA;;AACAC,aAAO,CAACxD,SAAR,CAAkBK,OAAlB,CAA0B,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACvDiD,eAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CgD,OAA5C;AACD,OAFD;AAIAzH,UAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDU,OAAhD;AACD;AACF;AAlGuC,CAA1C;AAqGA;;AACA;;AACA;;;AAEA,IAAIM,OAAO,GAAG,UAAU/G,MAAV,EAAkBgH,OAAlB,EAA2BtG,MAA3B,EAAmCuG,OAAnC,EAA4C;AACxD,MAAIjI,IAAI,GAAG,IAAX;AACAA,MAAI,CAAC+G,EAAL,GAAUmB,MAAM,CAACnB,EAAP,EAAV;AAEA/G,MAAI,CAACgB,MAAL,GAAcA,MAAd;AACAhB,MAAI,CAACgI,OAAL,GAAeA,OAAf;AAEAhI,MAAI,CAACmI,WAAL,GAAmB,KAAnB;AACAnI,MAAI,CAAC0B,MAAL,GAAcA,MAAd,CARwD,CAUxD;AACA;;AACA1B,MAAI,CAACoI,OAAL,GAAe,IAAIC,MAAM,CAACC,iBAAX,EAAf;AAEAtI,MAAI,CAACuI,OAAL,GAAe,KAAf;AACAvI,MAAI,CAACwI,aAAL,GAAqB,KAArB,CAfwD,CAiBxD;;AACAxI,MAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACAnE,MAAI,CAAC0I,cAAL,GAAsB,EAAtB;AAEA1I,MAAI,CAAC2I,MAAL,GAAc,IAAd;AAEA3I,MAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB,CAvBwD,CAyBxD;AACA;AACA;;AACAnE,MAAI,CAAC6I,UAAL,GAAkB,IAAlB,CA5BwD,CA8BxD;AACA;;AACA7I,MAAI,CAAC8I,0BAAL,GAAkC,KAAlC,CAhCwD,CAkCxD;AACA;;AACA9I,MAAI,CAAC+I,aAAL,GAAqB,EAArB,CApCwD,CAsCxD;;AACA/I,MAAI,CAACgJ,eAAL,GAAuB,EAAvB,CAvCwD,CA0CxD;AACA;;AACAhJ,MAAI,CAACiJ,UAAL,GAAkBvH,MAAM,CAAC7C,GAAzB,CA5CwD,CA8CxD;;AACAmB,MAAI,CAACkJ,eAAL,GAAuBjB,OAAO,CAACkB,cAA/B,CA/CwD,CAiDxD;AACA;AACA;;AACAnJ,MAAI,CAACoJ,gBAAL,GAAwB;AACtBrC,MAAE,EAAE/G,IAAI,CAAC+G,EADa;AAEtBsC,SAAK,EAAE,YAAY;AACjBrJ,UAAI,CAACqJ,KAAL;AACD,KAJqB;AAKtBC,WAAO,EAAE,UAAUC,EAAV,EAAc;AACrB,UAAIC,EAAE,GAAGnB,MAAM,CAACoB,eAAP,CAAuBF,EAAvB,EAA2B,6BAA3B,CAAT;;AACA,UAAIvJ,IAAI,CAACoI,OAAT,EAAkB;AAChBpI,YAAI,CAACgJ,eAAL,CAAqBtJ,IAArB,CAA0B8J,EAA1B;AACD,OAFD,MAEO;AACL;AACAnB,cAAM,CAACqB,KAAP,CAAaF,EAAb;AACD;AACF,KAbqB;AActBG,iBAAa,EAAE3J,IAAI,CAAC4J,cAAL,EAdO;AAetBC,eAAW,EAAE7J,IAAI,CAAC0B,MAAL,CAAYoI;AAfH,GAAxB;AAkBA9J,MAAI,CAACkC,IAAL,CAAU;AAAE6H,OAAG,EAAE,WAAP;AAAoBC,WAAO,EAAEhK,IAAI,CAAC+G;AAAlC,GAAV,EAtEwD,CAwExD;;AACAjD,OAAK,CAAC,YAAY;AAChB9D,QAAI,CAACiK,kBAAL;AACD,GAFI,CAAL,CAEGC,GAFH;;AAIA,MAAIlC,OAAO,KAAK,MAAZ,IAAsBC,OAAO,CAACkC,iBAAR,KAA8B,CAAxD,EAA2D;AACzD;AACAzI,UAAM,CAACC,mBAAP,CAA2B,CAA3B;AAEA3B,QAAI,CAACoK,SAAL,GAAiB,IAAIC,SAAS,CAACC,SAAd,CAAwB;AACvCH,uBAAiB,EAAElC,OAAO,CAACkC,iBADY;AAEvCI,sBAAgB,EAAEtC,OAAO,CAACsC,gBAFa;AAGvCC,eAAS,EAAE,YAAY;AACrBxK,YAAI,CAACqJ,KAAL;AACD,OALsC;AAMvCoB,cAAQ,EAAE,YAAY;AACpBzK,YAAI,CAACkC,IAAL,CAAU;AAAC6H,aAAG,EAAE;AAAN,SAAV;AACD;AARsC,KAAxB,CAAjB;AAUA/J,QAAI,CAACoK,SAAL,CAAeM,KAAf;AACD;;AAEDC,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CADD,CAAzB;AAED,CAhGD;;AAkGA5L,CAAC,CAACyD,MAAF,CAASqF,OAAO,CAACpF,SAAjB,EAA4B;AAE1BmI,WAAS,EAAE,UAAUC,eAAV,EAA2B;AACpC,QAAI/K,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeiB,UAAI,EAAED;AAArB,KAAV,EADF,KAEK;AACH9L,OAAC,CAACuD,IAAF,CAAOuI,eAAP,EAAwB,UAAUE,cAAV,EAA0B;AAChDjL,YAAI,CAAC+I,aAAL,CAAmBrJ,IAAnB,CAAwBuL,cAAxB;AACD,OAFD;AAGD;AACF,GAXyB;AAa1BC,WAAS,EAAE,UAAUlF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC/C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeoB,gBAAU,EAAEnF,cAA3B;AAA2Ce,QAAE,EAAEA,EAA/C;AAAmDM,YAAM,EAAEA;AAA3D,KAAV;AACH,GAjByB;AAmB1B+D,aAAW,EAAE,UAAUpF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AACjD,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIf,CAAC,CAACoH,OAAF,CAAUgB,MAAV,CAAJ,EACE;;AAEF,QAAIrH,IAAI,CAAC6I,UAAT,EAAqB;AACnB7I,UAAI,CAACkC,IAAL,CAAU;AACR6H,WAAG,EAAE,SADG;AAERoB,kBAAU,EAAEnF,cAFJ;AAGRe,UAAE,EAAEA,EAHI;AAIRM,cAAM,EAAEA;AAJA,OAAV;AAMD;AACF,GAhCyB;AAkC1BgE,aAAW,EAAE,UAAUrF,cAAV,EAA0Be,EAA1B,EAA8B;AACzC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,SAAN;AAAiBoB,gBAAU,EAAEnF,cAA7B;AAA6Ce,QAAE,EAAEA;AAAjD,KAAV;AACH,GAtCyB;AAwC1BuE,kBAAgB,EAAE,YAAY;AAC5B,QAAItL,IAAI,GAAG,IAAX;AACA,WAAO;AACLiH,WAAK,EAAEhI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACkL,SAAZ,EAAuBlL,IAAvB,CADF;AAELyH,aAAO,EAAExI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACoL,WAAZ,EAAyBpL,IAAzB,CAFJ;AAGLoH,aAAO,EAAEnI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACqL,WAAZ,EAAyBrL,IAAzB;AAHJ,KAAP;AAKD,GA/CyB;AAiD1BuL,mBAAiB,EAAE,UAAUvF,cAAV,EAA0B;AAC3C,QAAIhG,IAAI,GAAG,IAAX;AACA,QAAIsE,GAAG,GAAGtE,IAAI,CAAC4I,eAAL,CAAqB9D,GAArB,CAAyBkB,cAAzB,CAAV;;AACA,QAAI,CAAC1B,GAAL,EAAU;AACRA,SAAG,GAAG,IAAIyB,qBAAJ,CAA0BC,cAA1B,EAC4BhG,IAAI,CAACsL,gBAAL,EAD5B,CAAN;AAEAtL,UAAI,CAAC4I,eAAL,CAAqBhD,GAArB,CAAyBI,cAAzB,EAAyC1B,GAAzC;AACD;;AACD,WAAOA,GAAP;AACD,GA1DyB;AA4D1B2C,OAAK,EAAE,UAAUrC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AAC/D,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACvE,KAAL,CAAWrC,kBAAX,EAA+BmC,EAA/B,EAAmCM,MAAnC;AACD,GAhEyB;AAkE1BD,SAAO,EAAE,UAAUxC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkD;AACzD,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACpE,OAAL,CAAaxC,kBAAb,EAAiCmC,EAAjC;;AACA,QAAIyE,IAAI,CAACnF,OAAL,EAAJ,EAAoB;AACjBrG,UAAI,CAAC4I,eAAL,CAAqBvD,MAArB,CAA4BW,cAA5B;AACF;AACF,GAzEyB;AA2E1ByB,SAAO,EAAE,UAAU7C,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AACjE,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAAC/D,OAAL,CAAa7C,kBAAb,EAAiCmC,EAAjC,EAAqCM,MAArC;AACD,GA/EyB;AAiF1B4C,oBAAkB,EAAE,YAAY;AAC9B,QAAIjK,IAAI,GAAG,IAAX,CAD8B,CAE9B;AACA;AACA;;AACA,QAAIyL,QAAQ,GAAGxM,CAAC,CAACyG,KAAF,CAAQ1F,IAAI,CAACgB,MAAL,CAAY0K,0BAApB,CAAf;;AACAzM,KAAC,CAACuD,IAAF,CAAOiJ,QAAP,EAAiB,UAAUE,OAAV,EAAmB;AAClC3L,UAAI,CAAC4L,kBAAL,CAAwBD,OAAxB;AACD,KAFD;AAGD,GA1FyB;AA4F1B;AACAtC,OAAK,EAAE,YAAY;AACjB,QAAIrJ,IAAI,GAAG,IAAX,CADiB,CAGjB;AACA;AACA;AAEA;;AACA,QAAI,CAAEA,IAAI,CAACoI,OAAX,EACE,OATe,CAWjB;;AACApI,QAAI,CAACoI,OAAL,GAAe,IAAf;AACApI,QAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;;AAEA,QAAInE,IAAI,CAACoK,SAAT,EAAoB;AAClBpK,UAAI,CAACoK,SAAL,CAAeyB,IAAf;AACA7L,UAAI,CAACoK,SAAL,GAAiB,IAAjB;AACD;;AAED,QAAIpK,IAAI,CAAC0B,MAAT,EAAiB;AACf1B,UAAI,CAAC0B,MAAL,CAAY2H,KAAZ;AACArJ,UAAI,CAAC0B,MAAL,CAAYoK,cAAZ,GAA6B,IAA7B;AACD;;AAEDnB,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CAAC,CADF,CAAzB;AAGAxC,UAAM,CAACqB,KAAP,CAAa,YAAY;AACvB;AACA;AACA;AACA1J,UAAI,CAAC+L,2BAAL,GAJuB,CAMvB;AACA;;;AACA9M,OAAC,CAACuD,IAAF,CAAOxC,IAAI,CAACgJ,eAAZ,EAA6B,UAAUvG,QAAV,EAAoB;AAC/CA,gBAAQ;AACT,OAFD;AAGD,KAXD,EA5BiB,CAyCjB;;AACAzC,QAAI,CAACgB,MAAL,CAAYgL,cAAZ,CAA2BhM,IAA3B;AACD,GAxIyB;AA0I1B;AACA;AACAkC,MAAI,EAAE,UAAU6H,GAAV,EAAe;AACnB,QAAI/J,IAAI,GAAG,IAAX;;AACA,QAAIA,IAAI,CAAC0B,MAAT,EAAiB;AACf,UAAI2G,MAAM,CAAC4D,aAAX,EACE5D,MAAM,CAAC6D,MAAP,CAAc,UAAd,EAA0B7B,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAA1B;AACF/J,UAAI,CAAC0B,MAAL,CAAYQ,IAAZ,CAAiBmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAjB;AACD;AACF,GAnJyB;AAqJ1B;AACAqC,WAAS,EAAE,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAC7C,QAAItM,IAAI,GAAG,IAAX;AACA,QAAI+J,GAAG,GAAG;AAACA,SAAG,EAAE,OAAN;AAAesC,YAAM,EAAEA;AAAvB,KAAV;AACA,QAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACFtM,QAAI,CAACkC,IAAL,CAAU6H,GAAV;AACD,GA5JyB;AA8J1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAwC,gBAAc,EAAE,UAAUC,MAAV,EAAkB;AAChC,QAAIxM,IAAI,GAAG,IAAX;AACA,QAAI,CAACA,IAAI,CAACoI,OAAV,EAAmB;AACjB,aAH8B,CAKhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAIpI,IAAI,CAACoK,SAAT,EAAoB;AAClBtG,WAAK,CAAC,YAAY;AAChB9D,YAAI,CAACoK,SAAL,CAAeqC,eAAf;AACD,OAFI,CAAL,CAEGvC,GAFH;AAGD;;AAED,QAAIlK,IAAI,CAACgI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD,UAAI/J,IAAI,CAACkJ,eAAT,EACElJ,IAAI,CAACkC,IAAL,CAAU;AAAC6H,WAAG,EAAE,MAAN;AAAchD,UAAE,EAAEyF,MAAM,CAACzF;AAAzB,OAAV;AACF;AACD;;AACD,QAAI/G,IAAI,CAACgI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD;AACA;AACD;;AAED/J,QAAI,CAACoI,OAAL,CAAa1I,IAAb,CAAkB8M,MAAlB;AACA,QAAIxM,IAAI,CAACwI,aAAT,EACE;AACFxI,QAAI,CAACwI,aAAL,GAAqB,IAArB;;AAEA,QAAIkE,WAAW,GAAG,YAAY;AAC5B,UAAI3C,GAAG,GAAG/J,IAAI,CAACoI,OAAL,IAAgBpI,IAAI,CAACoI,OAAL,CAAauE,KAAb,EAA1B;;AACA,UAAI,CAAC5C,GAAL,EAAU;AACR/J,YAAI,CAACwI,aAAL,GAAqB,KAArB;AACA;AACD;;AAED1E,WAAK,CAAC,YAAY;AAChB,YAAIyE,OAAO,GAAG,IAAd;;AAEA,YAAIqE,OAAO,GAAG,YAAY;AACxB,cAAI,CAACrE,OAAL,EACE,OAFsB,CAEd;;AACVA,iBAAO,GAAG,KAAV;AACAmE,qBAAW;AACZ,SALD;;AAOA1M,YAAI,CAACgB,MAAL,CAAY6L,aAAZ,CAA0BrK,IAA1B,CAA+B,UAAUC,QAAV,EAAoB;AACjDA,kBAAQ,CAACsH,GAAD,EAAM/J,IAAN,CAAR;AACA,iBAAO,IAAP;AACD,SAHD;AAKA,YAAIf,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC8M,iBAAX,EAA8B/C,GAAG,CAACA,GAAlC,CAAJ,EACE/J,IAAI,CAAC8M,iBAAL,CAAuB/C,GAAG,CAACA,GAA3B,EAAgCgD,IAAhC,CAAqC/M,IAArC,EAA2C+J,GAA3C,EAAgD6C,OAAhD,EADF,KAGE5M,IAAI,CAACoM,SAAL,CAAe,aAAf,EAA8BrC,GAA9B;AACF6C,eAAO,GAnBS,CAmBL;AACZ,OApBI,CAAL,CAoBG1C,GApBH;AAqBD,KA5BD;;AA8BAwC,eAAW;AACZ,GAlPyB;AAoP1BI,mBAAiB,EAAE;AACjBE,OAAG,EAAE,UAAUjD,GAAV,EAAe;AAClB,UAAI/J,IAAI,GAAG,IAAX,CADkB,CAGlB;;AACA,UAAI,OAAQ+J,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACkD,IAAZ,KAAsB,QADtB,IAEE,YAAYlD,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAF1B,EAE2D;AACzDnN,YAAI,CAACoM,SAAL,CAAe,wBAAf,EAAyCrC,GAAzC;AACA;AACD;;AAED,UAAI,CAAC/J,IAAI,CAACgB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAL,EAA6C;AAC3CjN,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,OADG;AACMhD,YAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,0BAAuCkC,GAAG,CAACkD,IAA3C;AAFC,SAAV;AAGA;AACD;;AAED,UAAIjN,IAAI,CAACyI,UAAL,CAAgB9C,GAAhB,CAAoBoE,GAAG,CAAChD,EAAxB,CAAJ,EACE;AACA;AACA;AACA,eAtBgB,CAwBlB;AACA;AACA;AACA;AACA;;AACA,UAAI4D,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,YAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,YAAIC,gBAAgB,GAAG;AACrB5E,gBAAM,EAAE3I,IAAI,CAAC2I,MADQ;AAErBgB,uBAAa,EAAE3J,IAAI,CAACoJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,cAAI,EAAE,cAHe;AAIrBP,cAAI,EAAElD,GAAG,CAACkD,IAJW;AAKrBQ,sBAAY,EAAEzN,IAAI,CAAC+G;AALE,SAAvB;;AAQAuG,sBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,YAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,YAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5B7N,cAAI,CAACkC,IAAL,CAAU;AACR6H,eAAG,EAAE,OADG;AACMhD,cAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,iBAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK;AAFC,WAAV;AAOA;AACD;AACF;;AAED,UAAIpC,OAAO,GAAG3L,IAAI,CAACgB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAd;;AAEAjN,UAAI,CAAC4L,kBAAL,CAAwBD,OAAxB,EAAiC5B,GAAG,CAAChD,EAArC,EAAyCgD,GAAG,CAACmD,MAA7C,EAAqDnD,GAAG,CAACkD,IAAzD;AAED,KA1DgB;AA4DjBe,SAAK,EAAE,UAAUjE,GAAV,EAAe;AACpB,UAAI/J,IAAI,GAAG,IAAX;;AAEAA,UAAI,CAACiO,iBAAL,CAAuBlE,GAAG,CAAChD,EAA3B;AACD,KAhEgB;AAkEjBmH,UAAM,EAAE,UAAUnE,GAAV,EAAe6C,OAAf,EAAwB;AAC9B,UAAI5M,IAAI,GAAG,IAAX,CAD8B,CAG9B;AACA;AACA;;AACA,UAAI,OAAQ+J,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACmE,MAAZ,KAAwB,QADxB,IAEE,YAAYnE,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAFtB,IAGE,gBAAgBpD,GAAjB,IAA0B,OAAOA,GAAG,CAACoE,UAAX,KAA0B,QAHzD,EAGqE;AACnEnO,YAAI,CAACoM,SAAL,CAAe,6BAAf,EAA8CrC,GAA9C;AACA;AACD;;AAED,UAAIoE,UAAU,GAAGpE,GAAG,CAACoE,UAAJ,IAAkB,IAAnC,CAd8B,CAgB9B;AACA;AACA;;AACA,UAAIC,KAAK,GAAG,IAAIvK,SAAS,CAACwK,WAAd,EAAZ;AACAD,WAAK,CAACE,cAAN,CAAqB,YAAY;AAC/B;AACA;AACA;AACA;AACA;AACAF,aAAK,CAACG,MAAN;AACAvO,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,SADG;AACQyE,iBAAO,EAAE,CAACzE,GAAG,CAAChD,EAAL;AADjB,SAAV;AAED,OATD,EApB8B,CA+B9B;;AACA,UAAI4E,OAAO,GAAG3L,IAAI,CAACgB,MAAL,CAAYyN,eAAZ,CAA4B1E,GAAG,CAACmE,MAAhC,CAAd;;AACA,UAAI,CAACvC,OAAL,EAAc;AACZ3L,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,QADG;AACOhD,YAAE,EAAEgD,GAAG,CAAChD,EADf;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCkC,GAAG,CAACmE,MAArC;AAFC,SAAV;AAGAE,aAAK,CAACM,GAAN;AACA;AACD;;AAED,UAAIC,SAAS,GAAG,UAAShG,MAAT,EAAiB;AAC/B3I,YAAI,CAAC4O,UAAL,CAAgBjG,MAAhB;AACD,OAFD;;AAIA,UAAIkG,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,oBAAY,EAAE,KADgC;AAE9CpG,cAAM,EAAE3I,IAAI,CAAC2I,MAFiC;AAG9CgG,iBAAS,EAAEA,SAHmC;AAI9C/B,eAAO,EAAEA,OAJqC;AAK9C5K,kBAAU,EAAEhC,IAAI,CAACoJ,gBAL6B;AAM9C+E,kBAAU,EAAEA;AANkC,OAA/B,CAAjB;AASA,YAAMa,OAAO,GAAG,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC/C;AACA;AACA;AACA;AACA,YAAIxE,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,cAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,cAAIC,gBAAgB,GAAG;AACrB5E,kBAAM,EAAE3I,IAAI,CAAC2I,MADQ;AAErBgB,yBAAa,EAAE3J,IAAI,CAACoJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,gBAAI,EAAE,QAHe;AAIrBP,gBAAI,EAAElD,GAAG,CAACmE,MAJW;AAKrBT,wBAAY,EAAEzN,IAAI,CAAC+G;AALE,WAAvB;;AAOAuG,wBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,cAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,cAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5BsB,kBAAM,CAAC,IAAI9G,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK,CAAD,CAAN;AAKA;AACD;AACF;;AAEDmB,eAAO,CAACrL,SAAS,CAACuL,kBAAV,CAA6BC,SAA7B,CACNjB,KADM,EAEN,MAAMkB,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACJR,UADI,EAEJ,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACP9E,GAAG,CAACmD,MADG,EAE5B,cAAcnD,GAAG,CAACmE,MAAlB,GAA2B,GAFC,CAF1B,CAFA,CAAD,CAAP;AAUD,OApCe,CAAhB;;AAsCA,eAASuB,MAAT,GAAkB;AAChBrB,aAAK,CAACM,GAAN;AACA9B,eAAO;AACR;;AAED,YAAM8C,OAAO,GAAG;AACd3F,WAAG,EAAE,QADS;AAEdhD,UAAE,EAAEgD,GAAG,CAAChD;AAFM,OAAhB;AAKAiI,aAAO,CAACW,IAAR,CAAcC,MAAD,IAAY;AACvBH,cAAM;;AACN,YAAIG,MAAM,KAAK5K,SAAf,EAA0B;AACxB0K,iBAAO,CAACE,MAAR,GAAiBA,MAAjB;AACD;;AACD5P,YAAI,CAACkC,IAAL,CAAUwN,OAAV;AACD,OAND,EAMIG,SAAD,IAAe;AAChBJ,cAAM;AACNC,eAAO,CAACrC,KAAR,GAAgByC,qBAAqB,CACnCD,SADmC,mCAET9F,GAAG,CAACmE,MAFK,OAArC;AAIAlO,YAAI,CAACkC,IAAL,CAAUwN,OAAV;AACD,OAbD;AAcD;AAtLgB,GApPO;AA6a1BK,UAAQ,EAAE,UAAUC,CAAV,EAAa;AACrB,QAAIhQ,IAAI,GAAG,IAAX;;AACAA,QAAI,CAACyI,UAAL,CAAgBlE,OAAhB,CAAwByL,CAAxB;;AACAhQ,QAAI,CAAC0I,cAAL,CAAoBnE,OAApB,CAA4ByL,CAA5B;AACD,GAjbyB;AAmb1BC,sBAAoB,EAAE,UAAUC,SAAV,EAAqB;AACzC,QAAIlQ,IAAI,GAAG,IAAX;AACAyG,gBAAY,CAACC,QAAb,CAAsBwJ,SAAtB,EAAiClQ,IAAI,CAAC4I,eAAtC,EAAuD;AACrDjC,UAAI,EAAE,UAAUX,cAAV,EAA0BmK,SAA1B,EAAqCC,UAArC,EAAiD;AACrDA,kBAAU,CAAC7J,IAAX,CAAgB4J,SAAhB;AACD,OAHoD;AAIrDrJ,eAAS,EAAE,UAAUd,cAAV,EAA0BoK,UAA1B,EAAsC;AAC/CA,kBAAU,CAAClK,SAAX,CAAqB3B,OAArB,CAA6B,UAAUmD,OAAV,EAAmBX,EAAnB,EAAuB;AAClD/G,cAAI,CAACkL,SAAL,CAAelF,cAAf,EAA+Be,EAA/B,EAAmCW,OAAO,CAACrD,SAAR,EAAnC;AACD,SAFD;AAGD,OARoD;AASrD6C,cAAQ,EAAE,UAAUlB,cAAV,EAA0BmK,SAA1B,EAAqC;AAC7CA,iBAAS,CAACjK,SAAV,CAAoB3B,OAApB,CAA4B,UAAU8L,GAAV,EAAetJ,EAAf,EAAmB;AAC7C/G,cAAI,CAACqL,WAAL,CAAiBrF,cAAjB,EAAiCe,EAAjC;AACD,SAFD;AAGD;AAboD,KAAvD;AAeD,GApcyB;AAsc1B;AACA;AACA6H,YAAU,EAAE,UAASjG,MAAT,EAAiB;AAC3B,QAAI3I,IAAI,GAAG,IAAX;AAEA,QAAI2I,MAAM,KAAK,IAAX,IAAmB,OAAOA,MAAP,KAAkB,QAAzC,EACE,MAAM,IAAId,KAAJ,CAAU,qDACA,OAAOc,MADjB,CAAN,CAJyB,CAO3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA3I,QAAI,CAAC8I,0BAAL,GAAkC,IAAlC,CAf2B,CAiB3B;AACA;;AACA9I,QAAI,CAAC+P,QAAL,CAAc,UAAU/C,GAAV,EAAe;AAC3BA,SAAG,CAACsD,WAAJ;AACD,KAFD,EAnB2B,CAuB3B;AACA;AACA;;;AACAtQ,QAAI,CAAC6I,UAAL,GAAkB,KAAlB;AACA,QAAIqH,SAAS,GAAGlQ,IAAI,CAAC4I,eAArB;AACA5I,QAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;AACAnE,QAAI,CAAC2I,MAAL,GAAcA,MAAd,CA7B2B,CA+B3B;AACA;AACA;AACA;;AACA2G,OAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CAAuCrK,SAAvC,EAAkD,YAAY;AAC5D;AACA,UAAIuL,YAAY,GAAGvQ,IAAI,CAACyI,UAAxB;AACAzI,UAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACAnE,UAAI,CAAC0I,cAAL,GAAsB,EAAtB;AAEA6H,kBAAY,CAAChM,OAAb,CAAqB,UAAUyI,GAAV,EAAe/B,cAAf,EAA+B;AAClD,YAAIuF,MAAM,GAAGxD,GAAG,CAACyD,SAAJ,EAAb;;AACAzQ,YAAI,CAACyI,UAAL,CAAgB7C,GAAhB,CAAoBqF,cAApB,EAAoCuF,MAApC,EAFkD,CAGlD;AACA;;;AACAA,cAAM,CAACE,WAAP;AACD,OAND,EAN4D,CAc5D;AACA;AACA;;AACA1Q,UAAI,CAAC8I,0BAAL,GAAkC,KAAlC;AACA9I,UAAI,CAACiK,kBAAL;AACD,KAnBD,EAnC2B,CAwD3B;AACA;AACA;;;AACA5B,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC3Q,UAAI,CAAC6I,UAAL,GAAkB,IAAlB;;AACA7I,UAAI,CAACiQ,oBAAL,CAA0BC,SAA1B;;AACA,UAAI,CAACjR,CAAC,CAACoH,OAAF,CAAUrG,IAAI,CAAC+I,aAAf,CAAL,EAAoC;AAClC/I,YAAI,CAAC8K,SAAL,CAAe9K,IAAI,CAAC+I,aAApB;AACA/I,YAAI,CAAC+I,aAAL,GAAqB,EAArB;AACD;AACF,KAPD;AAQD,GA3gByB;AA6gB1B6C,oBAAkB,EAAE,UAAUD,OAAV,EAAmBiF,KAAnB,EAA0B1D,MAA1B,EAAkCD,IAAlC,EAAwC;AAC1D,QAAIjN,IAAI,GAAG,IAAX;AAEA,QAAIgN,GAAG,GAAG,IAAI6D,YAAJ,CACR7Q,IADQ,EACF2L,OADE,EACOiF,KADP,EACc1D,MADd,EACsBD,IADtB,CAAV;AAEA,QAAI2D,KAAJ,EACE5Q,IAAI,CAACyI,UAAL,CAAgB7C,GAAhB,CAAoBgL,KAApB,EAA2B5D,GAA3B,EADF,KAGEhN,IAAI,CAAC0I,cAAL,CAAoBhJ,IAApB,CAAyBsN,GAAzB;;AAEFA,OAAG,CAAC0D,WAAJ;AACD,GAxhByB;AA0hB1B;AACAzC,mBAAiB,EAAE,UAAU2C,KAAV,EAAiBvD,KAAjB,EAAwB;AACzC,QAAIrN,IAAI,GAAG,IAAX;AAEA,QAAI8Q,OAAO,GAAG,IAAd;;AACA,QAAIF,KAAJ,EAAW;AACT,UAAIG,QAAQ,GAAG/Q,IAAI,CAACyI,UAAL,CAAgB3D,GAAhB,CAAoB8L,KAApB,CAAf;;AACA,UAAIG,QAAJ,EAAc;AACZD,eAAO,GAAGC,QAAQ,CAACC,KAAnB;;AACAD,gBAAQ,CAACE,mBAAT;;AACAF,gBAAQ,CAACT,WAAT;;AACAtQ,YAAI,CAACyI,UAAL,CAAgBpD,MAAhB,CAAuBuL,KAAvB;AACD;AACF;;AAED,QAAIM,QAAQ,GAAG;AAACnH,SAAG,EAAE,OAAN;AAAehD,QAAE,EAAE6J;AAAnB,KAAf;;AAEA,QAAIvD,KAAJ,EAAW;AACT6D,cAAQ,CAAC7D,KAAT,GAAiByC,qBAAqB,CACpCzC,KADoC,EAEpCyD,OAAO,GAAI,cAAcA,OAAd,GAAwB,MAAxB,GAAiCF,KAArC,GACF,iBAAiBA,KAHc,CAAtC;AAID;;AAED5Q,QAAI,CAACkC,IAAL,CAAUgP,QAAV;AACD,GAnjByB;AAqjB1B;AACA;AACAnF,6BAA2B,EAAE,YAAY;AACvC,QAAI/L,IAAI,GAAG,IAAX;;AAEAA,QAAI,CAACyI,UAAL,CAAgBlE,OAAhB,CAAwB,UAAUyI,GAAV,EAAejG,EAAf,EAAmB;AACzCiG,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAtQ,QAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;;AAEAnE,QAAI,CAAC0I,cAAL,CAAoBnE,OAApB,CAA4B,UAAUyI,GAAV,EAAe;AACzCA,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAtQ,QAAI,CAAC0I,cAAL,GAAsB,EAAtB;AACD,GAnkByB;AAqkB1B;AACA;AACA;AACAkB,gBAAc,EAAE,YAAY;AAC1B,QAAI5J,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAImR,kBAAkB,GAAGC,QAAQ,CAAC/R,OAAO,CAACC,GAAR,CAAY,sBAAZ,CAAD,CAAR,IAAiD,CAA1E;AAEA,QAAI6R,kBAAkB,KAAK,CAA3B,EACE,OAAOnR,IAAI,CAAC0B,MAAL,CAAY2P,aAAnB;AAEF,QAAIC,YAAY,GAAGtR,IAAI,CAAC0B,MAAL,CAAYoI,OAAZ,CAAoB,iBAApB,CAAnB;AACA,QAAI,CAAE7K,CAAC,CAACsS,QAAF,CAAWD,YAAX,CAAN,EACE,OAAO,IAAP;AACFA,gBAAY,GAAGA,YAAY,CAACE,IAAb,GAAoBC,KAApB,CAA0B,SAA1B,CAAf,CAlB0B,CAoB1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,QAAIN,kBAAkB,GAAG,CAArB,IAA0BA,kBAAkB,GAAGG,YAAY,CAACpM,MAAhE,EACE,OAAO,IAAP;AAEF,WAAOoM,YAAY,CAACA,YAAY,CAACpM,MAAb,GAAsBiM,kBAAvB,CAAnB;AACD;AAzmByB,CAA5B;AA4mBA;;AACA;;AACA;AAEA;AAEA;AACA;;AACA;;;;;;;;AAMA,IAAIN,YAAY,GAAG,UACf7G,OADe,EACN2B,OADM,EACGV,cADH,EACmBiC,MADnB,EAC2BD,IAD3B,EACiC;AAClD,MAAIjN,IAAI,GAAG,IAAX;AACAA,MAAI,CAAC8B,QAAL,GAAgBkI,OAAhB,CAFkD,CAEzB;;AAEzB;;;;;;;;AAOAhK,MAAI,CAACgC,UAAL,GAAkBgI,OAAO,CAACZ,gBAA1B,CAXkD,CAWN;;AAE5CpJ,MAAI,CAAC0R,QAAL,GAAgB/F,OAAhB,CAbkD,CAelD;;AACA3L,MAAI,CAAC2R,eAAL,GAAuB1G,cAAvB,CAhBkD,CAiBlD;;AACAjL,MAAI,CAACgR,KAAL,GAAa/D,IAAb;AAEAjN,MAAI,CAAC4R,OAAL,GAAe1E,MAAM,IAAI,EAAzB,CApBkD,CAsBlD;AACA;AACA;;AACA,MAAIlN,IAAI,CAAC2R,eAAT,EAA0B;AACxB3R,QAAI,CAAC6R,mBAAL,GAA2B,MAAM7R,IAAI,CAAC2R,eAAtC;AACD,GAFD,MAEO;AACL3R,QAAI,CAAC6R,mBAAL,GAA2B,MAAM3J,MAAM,CAACnB,EAAP,EAAjC;AACD,GA7BiD,CA+BlD;;;AACA/G,MAAI,CAAC8R,YAAL,GAAoB,KAApB,CAhCkD,CAkClD;;AACA9R,MAAI,CAAC+R,cAAL,GAAsB,EAAtB,CAnCkD,CAqClD;AACA;;AACA/R,MAAI,CAACgS,UAAL,GAAkB,IAAI7N,GAAJ,EAAlB,CAvCkD,CAyClD;;AACAnE,MAAI,CAACiS,MAAL,GAAc,KAAd,CA1CkD,CA4ClD;;AAEA;;;;;;;;AAOAjS,MAAI,CAAC2I,MAAL,GAAcqB,OAAO,CAACrB,MAAtB,CArDkD,CAuDlD;AACA;AACA;AAEA;AACA;AACA;AACA;;AAEA3I,MAAI,CAACkS,SAAL,GAAiB;AACfC,eAAW,EAAEC,OAAO,CAACD,WADN;AAEfE,WAAO,EAAED,OAAO,CAACC;AAFF,GAAjB;AAKA1H,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CADN,CAAzB;AAED,CAxED;;AA0EA5L,CAAC,CAACyD,MAAF,CAASmO,YAAY,CAAClO,SAAtB,EAAiC;AAC/B+N,aAAW,EAAE,YAAY;AACvB;AACA;AACA;AACA;AACA;AACA;AAEA,QAAI1Q,IAAI,GAAG,IAAX;;AACA,QAAI;AACF,UAAIsS,GAAG,GAAGhD,GAAG,CAACiD,6BAAJ,CAAkClD,SAAlC,CACRrP,IADQ,EAER,MAAMwP,wBAAwB,CAC5BxP,IAAI,CAAC0R,QADuB,EACb1R,IADa,EACPsF,KAAK,CAACI,KAAN,CAAY1F,IAAI,CAAC4R,OAAjB,CADO,EAE5B;AACA;AACA;AACA,sBAAgB5R,IAAI,CAACgR,KAArB,GAA6B,GALD,CAFtB,CAAV;AAUD,KAXD,CAWE,OAAOwB,CAAP,EAAU;AACVxS,UAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD,KAvBsB,CAyBvB;;;AACA,QAAIxS,IAAI,CAACyS,cAAL,EAAJ,EACE;;AAEFzS,QAAI,CAAC0S,qBAAL,CAA2BJ,GAA3B;AACD,GA/B8B;AAiC/BI,uBAAqB,EAAE,UAAUJ,GAAV,EAAe;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,QAAItS,IAAI,GAAG,IAAX;;AACA,QAAI2S,QAAQ,GAAG,UAAUC,CAAV,EAAa;AAC1B,aAAOA,CAAC,IAAIA,CAAC,CAACC,cAAd;AACD,KAFD;;AAGA,QAAIF,QAAQ,CAACL,GAAD,CAAZ,EAAmB;AACjB,UAAI;AACFA,WAAG,CAACO,cAAJ,CAAmB7S,IAAnB;AACD,OAFD,CAEE,OAAOwS,CAAP,EAAU;AACVxS,YAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD,OANgB,CAOjB;AACA;;;AACAxS,UAAI,CAAC8S,KAAL;AACD,KAVD,MAUO,IAAI7T,CAAC,CAAC8T,OAAF,CAAUT,GAAV,CAAJ,EAAoB;AACzB;AACA,UAAI,CAAErT,CAAC,CAAC+T,GAAF,CAAMV,GAAN,EAAWK,QAAX,CAAN,EAA4B;AAC1B3S,YAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,mDAAV,CAAX;AACA;AACD,OALwB,CAMzB;AACA;AACA;;;AACA,UAAIoL,eAAe,GAAG,EAAtB;;AACA,WAAK,IAAIhO,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqN,GAAG,CAACpN,MAAxB,EAAgC,EAAED,CAAlC,EAAqC;AACnC,YAAIe,cAAc,GAAGsM,GAAG,CAACrN,CAAD,CAAH,CAAOiO,kBAAP,EAArB;;AACA,YAAIjU,CAAC,CAAC0G,GAAF,CAAMsN,eAAN,EAAuBjN,cAAvB,CAAJ,EAA4C;AAC1ChG,cAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CACT,+DACE7B,cAFO,CAAX;AAGA;AACD;;AACDiN,uBAAe,CAACjN,cAAD,CAAf,GAAkC,IAAlC;AACD;;AAAA;;AAED,UAAI;AACF/G,SAAC,CAACuD,IAAF,CAAO8P,GAAP,EAAY,UAAUa,GAAV,EAAe;AACzBA,aAAG,CAACN,cAAJ,CAAmB7S,IAAnB;AACD,SAFD;AAGD,OAJD,CAIE,OAAOwS,CAAP,EAAU;AACVxS,YAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD;;AACDxS,UAAI,CAAC8S,KAAL;AACD,KA9BM,MA8BA,IAAIR,GAAJ,EAAS;AACd;AACA;AACA;AACAtS,UAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,kDACE,qBADZ,CAAX;AAED;AACF,GAtG8B;AAwG/B;AACA;AACA;AACA;AACA;AACAyI,aAAW,EAAE,YAAW;AACtB,QAAItQ,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC8R,YAAT,EACE;AACF9R,QAAI,CAAC8R,YAAL,GAAoB,IAApB;;AACA9R,QAAI,CAACoT,kBAAL;;AACAzI,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CAAC,CADP,CAAzB;AAED,GArH8B;AAuH/BuI,oBAAkB,EAAE,YAAY;AAC9B,QAAIpT,IAAI,GAAG,IAAX,CAD8B,CAE9B;;AACA,QAAImG,SAAS,GAAGnG,IAAI,CAAC+R,cAArB;AACA/R,QAAI,CAAC+R,cAAL,GAAsB,EAAtB;;AACA9S,KAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkB,UAAU1D,QAAV,EAAoB;AACpCA,cAAQ;AACT,KAFD;AAGD,GA/H8B;AAiI/B;AACAwO,qBAAmB,EAAE,YAAY;AAC/B,QAAIjR,IAAI,GAAG,IAAX;;AACAqI,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC3Q,UAAI,CAACgS,UAAL,CAAgBzN,OAAhB,CAAwB,UAAU8O,cAAV,EAA0BrN,cAA1B,EAA0C;AAChEqN,sBAAc,CAAC9O,OAAf,CAAuB,UAAU+O,KAAV,EAAiB;AACtCtT,cAAI,CAACoH,OAAL,CAAapB,cAAb,EAA6BhG,IAAI,CAACkS,SAAL,CAAeG,OAAf,CAAuBiB,KAAvB,CAA7B;AACD,SAFD;AAGD,OAJD;AAKD,KAND;AAOD,GA3I8B;AA6I/B;AACA;AACA;AACA;AACA;AACA7C,WAAS,EAAE,YAAY;AACrB,QAAIzQ,IAAI,GAAG,IAAX;AACA,WAAO,IAAI6Q,YAAJ,CACL7Q,IAAI,CAAC8B,QADA,EACU9B,IAAI,CAAC0R,QADf,EACyB1R,IAAI,CAAC2R,eAD9B,EAC+C3R,IAAI,CAAC4R,OADpD,EAEL5R,IAAI,CAACgR,KAFA,CAAP;AAGD,GAvJ8B;;AAyJ/B;;;;;;;AAOA3D,OAAK,EAAE,UAAUA,KAAV,EAAiB;AACtB,QAAIrN,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;;AACFzS,QAAI,CAAC8B,QAAL,CAAcmM,iBAAd,CAAgCjO,IAAI,CAAC2R,eAArC,EAAsDtE,KAAtD;AACD,GArK8B;AAuK/B;AACA;AACA;AACA;;AAEA;;;;;;AAMAxB,MAAI,EAAE,YAAY;AAChB,QAAI7L,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;;AACFzS,QAAI,CAAC8B,QAAL,CAAcmM,iBAAd,CAAgCjO,IAAI,CAAC2R,eAArC;AACD,GAvL8B;;AAyL/B;;;;;;;AAOA4B,QAAM,EAAE,UAAU9Q,QAAV,EAAoB;AAC1B,QAAIzC,IAAI,GAAG,IAAX;AACAyC,YAAQ,GAAG4F,MAAM,CAACoB,eAAP,CAAuBhH,QAAvB,EAAiC,iBAAjC,EAAoDzC,IAApD,CAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACEhQ,QAAQ,GADV,KAGEzC,IAAI,CAAC+R,cAAL,CAAoBrS,IAApB,CAAyB+C,QAAzB;AACH,GAvM8B;AAyM/B;AACA;AACA;AACAgQ,gBAAc,EAAE,YAAY;AAC1B,QAAIzS,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC8R,YAAL,IAAqB9R,IAAI,CAAC8B,QAAL,CAAcsG,OAAd,KAA0B,IAAtD;AACD,GA/M8B;;AAiN/B;;;;;;;;;AASAnB,OAAK,EAAE,UAAUjB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC3C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA,QAAIyM,GAAG,GAAGxT,IAAI,CAACgS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,CAAV;;AACA,QAAIwN,GAAG,IAAI,IAAX,EAAiB;AACfA,SAAG,GAAG,IAAIvP,GAAJ,EAAN;;AACAjE,UAAI,CAACgS,UAAL,CAAgBpM,GAAhB,CAAoBI,cAApB,EAAoCwN,GAApC;AACD;;AACDA,OAAG,CAAC7L,GAAJ,CAAQZ,EAAR;;AACA/G,QAAI,CAAC8B,QAAL,CAAcmF,KAAd,CAAoBjH,IAAI,CAAC6R,mBAAzB,EAA8C7L,cAA9C,EAA8De,EAA9D,EAAkEM,MAAlE;AACD,GAtO8B;;AAwO/B;;;;;;;;;AASAI,SAAO,EAAE,UAAUzB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC7C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA/G,QAAI,CAAC8B,QAAL,CAAc2F,OAAd,CAAsBzH,IAAI,CAAC6R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE,EAAoEM,MAApE;AACD,GAvP8B;;AAyP/B;;;;;;;;AAQAD,SAAO,EAAE,UAAUpB,cAAV,EAA0Be,EAA1B,EAA8B;AACrC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL,CAJqC,CAKrC;AACA;;AACA/G,QAAI,CAACgS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,EAAoCX,MAApC,CAA2C0B,EAA3C;;AACA/G,QAAI,CAAC8B,QAAL,CAAcsF,OAAd,CAAsBpH,IAAI,CAAC6R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE;AACD,GA1Q8B;;AA4Q/B;;;;;;AAMA+L,OAAK,EAAE,YAAY;AACjB,QAAI9S,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF,QAAI,CAACzS,IAAI,CAAC2R,eAAV,EACE,OALe,CAKN;;AACX,QAAI,CAAC3R,IAAI,CAACiS,MAAV,EAAkB;AAChBjS,UAAI,CAAC8B,QAAL,CAAcgJ,SAAd,CAAwB,CAAC9K,IAAI,CAAC2R,eAAN,CAAxB;;AACA3R,UAAI,CAACiS,MAAL,GAAc,IAAd;AACD;AACF;AA5R8B,CAAjC;AA+RA;;AACA;;AACA;;;AAEAwB,MAAM,GAAG,UAAUxL,OAAV,EAAmB;AAC1B,MAAIjI,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACAA,MAAI,CAACiI,OAAL,GAAehJ,CAAC,CAACyU,QAAF,CAAWzL,OAAO,IAAI,EAAtB,EAA0B;AACvCkC,qBAAiB,EAAE,KADoB;AAEvCI,oBAAgB,EAAE,KAFqB;AAGvC;AACApB,kBAAc,EAAE;AAJuB,GAA1B,CAAf,CAV0B,CAiB1B;AACA;AACA;AACA;;AACAnJ,MAAI,CAAC2T,gBAAL,GAAwB,IAAIC,IAAJ,CAAS;AAC/BC,wBAAoB,EAAE;AADS,GAAT,CAAxB,CArB0B,CAyB1B;;AACA7T,MAAI,CAAC6M,aAAL,GAAqB,IAAI+G,IAAJ,CAAS;AAC5BC,wBAAoB,EAAE;AADM,GAAT,CAArB;AAIA7T,MAAI,CAACoN,gBAAL,GAAwB,EAAxB;AACApN,MAAI,CAAC0L,0BAAL,GAAkC,EAAlC;AAEA1L,MAAI,CAACyO,eAAL,GAAuB,EAAvB;AAEAzO,MAAI,CAAC8T,QAAL,GAAgB,IAAI3P,GAAJ,EAAhB,CAnC0B,CAmCC;;AAE3BnE,MAAI,CAAC+T,aAAL,GAAqB,IAAIhU,YAAJ,EAArB;AAEAC,MAAI,CAAC+T,aAAL,CAAmBnR,QAAnB,CAA4B,UAAUlB,MAAV,EAAkB;AAC5C;AACAA,UAAM,CAACoK,cAAP,GAAwB,IAAxB;;AAEA,QAAIM,SAAS,GAAG,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAClD,UAAIvC,GAAG,GAAG;AAACA,WAAG,EAAE,OAAN;AAAesC,cAAM,EAAEA;AAAvB,OAAV;AACA,UAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACF5K,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAZ;AACD,KALD;;AAOArI,UAAM,CAACD,EAAP,CAAU,MAAV,EAAkB,UAAUuS,OAAV,EAAmB;AACnC,UAAI3L,MAAM,CAAC4L,iBAAX,EAA8B;AAC5B5L,cAAM,CAAC6D,MAAP,CAAc,cAAd,EAA8B8H,OAA9B;AACD;;AACD,UAAI;AACF,YAAI;AACF,cAAIjK,GAAG,GAAGM,SAAS,CAAC6J,QAAV,CAAmBF,OAAnB,CAAV;AACD,SAFD,CAEE,OAAOlM,GAAP,EAAY;AACZsE,mBAAS,CAAC,aAAD,CAAT;AACA;AACD;;AACD,YAAIrC,GAAG,KAAK,IAAR,IAAgB,CAACA,GAAG,CAACA,GAAzB,EAA8B;AAC5BqC,mBAAS,CAAC,aAAD,EAAgBrC,GAAhB,CAAT;AACA;AACD;;AAED,YAAIA,GAAG,CAACA,GAAJ,KAAY,SAAhB,EAA2B;AACzB,cAAIrI,MAAM,CAACoK,cAAX,EAA2B;AACzBM,qBAAS,CAAC,mBAAD,EAAsBrC,GAAtB,CAAT;AACA;AACD;;AACDjG,eAAK,CAAC,YAAY;AAChB9D,gBAAI,CAACmU,cAAL,CAAoBzS,MAApB,EAA4BqI,GAA5B;AACD,WAFI,CAAL,CAEGG,GAFH;AAGA;AACD;;AAED,YAAI,CAACxI,MAAM,CAACoK,cAAZ,EAA4B;AAC1BM,mBAAS,CAAC,oBAAD,EAAuBrC,GAAvB,CAAT;AACA;AACD;;AACDrI,cAAM,CAACoK,cAAP,CAAsBS,cAAtB,CAAqCxC,GAArC;AACD,OA5BD,CA4BE,OAAOyI,CAAP,EAAU;AACV;AACAnK,cAAM,CAAC6D,MAAP,CAAc,6CAAd,EAA6DnC,GAA7D,EAAkEyI,CAAlE;AACD;AACF,KApCD;AAsCA9Q,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7B,UAAIC,MAAM,CAACoK,cAAX,EAA2B;AACzBhI,aAAK,CAAC,YAAY;AAChBpC,gBAAM,CAACoK,cAAP,CAAsBzC,KAAtB;AACD,SAFI,CAAL,CAEGa,GAFH;AAGD;AACF,KAND;AAOD,GAxDD;AAyDD,CAhGD;;AAkGAjL,CAAC,CAACyD,MAAF,CAAS+Q,MAAM,CAAC9Q,SAAhB,EAA2B;AAEzB;;;;;;;AAOAyR,cAAY,EAAE,UAAU7K,EAAV,EAAc;AAC1B,QAAIvJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC2T,gBAAL,CAAsB/Q,QAAtB,CAA+B2G,EAA/B,CAAP;AACD,GAZwB;;AAczB;;;;;;;AAOA8K,WAAS,EAAE,UAAU9K,EAAV,EAAc;AACvB,QAAIvJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC6M,aAAL,CAAmBjK,QAAnB,CAA4B2G,EAA5B,CAAP;AACD,GAxBwB;AA0BzB4K,gBAAc,EAAE,UAAUzS,MAAV,EAAkBqI,GAAlB,EAAuB;AACrC,QAAI/J,IAAI,GAAG,IAAX,CADqC,CAGrC;AACA;;AACA,QAAI,EAAE,OAAQ+J,GAAG,CAAC/B,OAAZ,KAAyB,QAAzB,IACA/I,CAAC,CAAC8T,OAAF,CAAUhJ,GAAG,CAACuK,OAAd,CADA,IAEArV,CAAC,CAAC+T,GAAF,CAAMjJ,GAAG,CAACuK,OAAV,EAAmBrV,CAAC,CAACsS,QAArB,CAFA,IAGAtS,CAAC,CAACsV,QAAF,CAAWxK,GAAG,CAACuK,OAAf,EAAwBvK,GAAG,CAAC/B,OAA5B,CAHF,CAAJ,EAG6C;AAC3CtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AACT/B,eAAO,EAAEqC,SAAS,CAACmK,sBAAV,CAAiC,CAAjC;AADA,OAAvB,CAAZ;AAEA9S,YAAM,CAAC2H,KAAP;AACA;AACD,KAboC,CAerC;AACA;;;AACA,QAAIrB,OAAO,GAAGyM,gBAAgB,CAAC1K,GAAG,CAACuK,OAAL,EAAcjK,SAAS,CAACmK,sBAAxB,CAA9B;;AAEA,QAAIzK,GAAG,CAAC/B,OAAJ,KAAgBA,OAApB,EAA6B;AAC3B;AACA;AACA;AACAtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AAAgB/B,eAAO,EAAEA;AAAzB,OAAvB,CAAZ;AACAtG,YAAM,CAAC2H,KAAP;AACA;AACD,KA1BoC,CA4BrC;AACA;AACA;;;AACA3H,UAAM,CAACoK,cAAP,GAAwB,IAAI/D,OAAJ,CAAY/H,IAAZ,EAAkBgI,OAAlB,EAA2BtG,MAA3B,EAAmC1B,IAAI,CAACiI,OAAxC,CAAxB;AACAjI,QAAI,CAAC8T,QAAL,CAAclO,GAAd,CAAkBlE,MAAM,CAACoK,cAAP,CAAsB/E,EAAxC,EAA4CrF,MAAM,CAACoK,cAAnD;AACA9L,QAAI,CAAC2T,gBAAL,CAAsBnR,IAAtB,CAA2B,UAAUC,QAAV,EAAoB;AAC7C,UAAIf,MAAM,CAACoK,cAAX,EACErJ,QAAQ,CAACf,MAAM,CAACoK,cAAP,CAAsB1C,gBAAvB,CAAR;AACF,aAAO,IAAP;AACD,KAJD;AAKD,GAhEwB;;AAiEzB;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;AAQAsL,SAAO,EAAE,UAAUzH,IAAV,EAAgBtB,OAAhB,EAAyB1D,OAAzB,EAAkC;AACzC,QAAIjI,IAAI,GAAG,IAAX;;AAEA,QAAI,CAAEf,CAAC,CAAC0V,QAAF,CAAW1H,IAAX,CAAN,EAAwB;AACtBhF,aAAO,GAAGA,OAAO,IAAI,EAArB;;AAEA,UAAIgF,IAAI,IAAIA,IAAI,IAAIjN,IAAI,CAACoN,gBAAzB,EAA2C;AACzC/E,cAAM,CAAC6D,MAAP,CAAc,uCAAuCe,IAAvC,GAA8C,GAA5D;;AACA;AACD;;AAED,UAAItC,OAAO,CAACiK,WAAR,IAAuB,CAAC3M,OAAO,CAAC4M,OAApC,EAA6C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAI,CAAC7U,IAAI,CAAC8U,wBAAV,EAAoC;AAClC9U,cAAI,CAAC8U,wBAAL,GAAgC,IAAhC;;AACAzM,gBAAM,CAAC6D,MAAP,CACN,0EACA,yEADA,GAEA,uEAFA,GAGA,yCAHA,GAIA,MAJA,GAKA,gEALA,GAMA,MANA,GAOA,oCAPA,GAQA,MARA,GASA,8EATA,GAUA,wDAXM;AAYD;AACF;;AAED,UAAIe,IAAJ,EACEjN,IAAI,CAACoN,gBAAL,CAAsBH,IAAtB,IAA8BtB,OAA9B,CADF,KAEK;AACH3L,YAAI,CAAC0L,0BAAL,CAAgChM,IAAhC,CAAqCiM,OAArC,EADG,CAEH;AACA;AACA;;AACA3L,YAAI,CAAC8T,QAAL,CAAcvP,OAAd,CAAsB,UAAUyF,OAAV,EAAmB;AACvC,cAAI,CAACA,OAAO,CAAClB,0BAAb,EAAyC;AACvChF,iBAAK,CAAC,YAAW;AACfkG,qBAAO,CAAC4B,kBAAR,CAA2BD,OAA3B;AACD,aAFI,CAAL,CAEGzB,GAFH;AAGD;AACF,SAND;AAOD;AACF,KAhDD,MAiDI;AACFjL,OAAC,CAACuD,IAAF,CAAOyK,IAAP,EAAa,UAASvI,KAAT,EAAgBD,GAAhB,EAAqB;AAChCzE,YAAI,CAAC0U,OAAL,CAAajQ,GAAb,EAAkBC,KAAlB,EAAyB,EAAzB;AACD,OAFD;AAGD;AACF,GAzJwB;AA2JzBsH,gBAAc,EAAE,UAAUhC,OAAV,EAAmB;AACjC,QAAIhK,IAAI,GAAG,IAAX;AACAA,QAAI,CAAC8T,QAAL,CAAczO,MAAd,CAAqB2E,OAAO,CAACjD,EAA7B;AACD,GA9JwB;;AAgKzB;;;;;;;AAOAyH,SAAO,EAAE,UAAUA,OAAV,EAAmB;AAC1B,QAAIxO,IAAI,GAAG,IAAX;;AACAf,KAAC,CAACuD,IAAF,CAAOgM,OAAP,EAAgB,UAAUuG,IAAV,EAAgB9H,IAAhB,EAAsB;AACpC,UAAI,OAAO8H,IAAP,KAAgB,UAApB,EACE,MAAM,IAAIlN,KAAJ,CAAU,aAAaoF,IAAb,GAAoB,sBAA9B,CAAN;AACF,UAAIjN,IAAI,CAACyO,eAAL,CAAqBxB,IAArB,CAAJ,EACE,MAAM,IAAIpF,KAAJ,CAAU,qBAAqBoF,IAArB,GAA4B,sBAAtC,CAAN;AACFjN,UAAI,CAACyO,eAAL,CAAqBxB,IAArB,IAA6B8H,IAA7B;AACD,KAND;AAOD,GAhLwB;AAkLzBhI,MAAI,EAAE,UAAUE,IAAV,EAAyB;AAAA,sCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAC7B,QAAIA,IAAI,CAAC4B,MAAL,IAAe,OAAO5B,IAAI,CAACA,IAAI,CAAC4B,MAAL,GAAc,CAAf,CAAX,KAAiC,UAApD,EAAgE;AAC9D;AACA;AACA,UAAIzC,QAAQ,GAAGa,IAAI,CAAC0R,GAAL,EAAf;AACD;;AAED,WAAO,KAAKpR,KAAL,CAAWqJ,IAAX,EAAiB3J,IAAjB,EAAuBb,QAAvB,CAAP;AACD,GA1LwB;AA4LzB;AACAwS,WAAS,EAAE,UAAUhI,IAAV,EAAyB;AAAA,uCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAClC,WAAO,KAAK4R,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,CAAP;AACD,GA/LwB;AAiMzBM,OAAK,EAAE,UAAUqJ,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+BxF,QAA/B,EAAyC;AAC9C;AACA;AACA,QAAI,CAAEA,QAAF,IAAc,OAAOwF,OAAP,KAAmB,UAArC,EAAiD;AAC/CxF,cAAQ,GAAGwF,OAAX;AACAA,aAAO,GAAG,EAAV;AACD,KAHD,MAGO;AACLA,aAAO,GAAGA,OAAO,IAAI,EAArB;AACD;;AAED,UAAM+G,OAAO,GAAG,KAAKkG,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,EAA4B2E,OAA5B,CAAhB,CAV8C,CAY9C;AACA;AACA;AACA;AACA;;AACA,QAAIxF,QAAJ,EAAc;AACZuM,aAAO,CAACW,IAAR,CACEC,MAAM,IAAInN,QAAQ,CAACuC,SAAD,EAAY4K,MAAZ,CADpB,EAEEC,SAAS,IAAIpN,QAAQ,CAACoN,SAAD,CAFvB;AAID,KALD,MAKO;AACL,aAAOb,OAAO,CAACmG,KAAR,EAAP;AACD;AACF,GA1NwB;AA4NzB;AACAD,YAAU,EAAE,UAAUjI,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+B;AACzC;AACA,QAAI0D,OAAO,GAAG,KAAK8C,eAAL,CAAqBxB,IAArB,CAAd;;AACA,QAAI,CAAEtB,OAAN,EAAe;AACb,aAAOsD,OAAO,CAACE,MAAR,CACL,IAAI9G,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCoF,IAAjC,iBADK,CAAP;AAGD,KAPwC,CASzC;AACA;AACA;;;AACA,QAAItE,MAAM,GAAG,IAAb;;AACA,QAAIgG,SAAS,GAAG,YAAW;AACzB,YAAM,IAAI9G,KAAJ,CAAU,wDAAV,CAAN;AACD,KAFD;;AAGA,QAAI7F,UAAU,GAAG,IAAjB;;AACA,QAAIoT,uBAAuB,GAAG9F,GAAG,CAACC,wBAAJ,CAA6BzK,GAA7B,EAA9B;;AACA,QAAIuQ,4BAA4B,GAAG/F,GAAG,CAACiD,6BAAJ,CAAkCzN,GAAlC,EAAnC;;AACA,QAAIqJ,UAAU,GAAG,IAAjB;;AACA,QAAIiH,uBAAJ,EAA6B;AAC3BzM,YAAM,GAAGyM,uBAAuB,CAACzM,MAAjC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3ByM,+BAAuB,CAACzG,SAAxB,CAAkChG,MAAlC;AACD,OAFD;;AAGA3G,gBAAU,GAAGoT,uBAAuB,CAACpT,UAArC;AACAmM,gBAAU,GAAG9D,SAAS,CAACiL,WAAV,CAAsBF,uBAAtB,EAA+CnI,IAA/C,CAAb;AACD,KAPD,MAOO,IAAIoI,4BAAJ,EAAkC;AACvC1M,YAAM,GAAG0M,4BAA4B,CAAC1M,MAAtC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3B0M,oCAA4B,CAACvT,QAA7B,CAAsC8M,UAAtC,CAAiDjG,MAAjD;AACD,OAFD;;AAGA3G,gBAAU,GAAGqT,4BAA4B,CAACrT,UAA1C;AACD;;AAED,QAAI6M,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,kBAAY,EAAE,KADgC;AAE9CpG,YAF8C;AAG9CgG,eAH8C;AAI9C3M,gBAJ8C;AAK9CmM;AAL8C,KAA/B,CAAjB;AAQA,WAAO,IAAIc,OAAJ,CAAYC,OAAO,IAAIA,OAAO,CACnCI,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACER,UADF,EAEE,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACPvJ,KAAK,CAACI,KAAN,CAAYpC,IAAZ,CADO,EAE5B,uBAAuB2J,IAAvB,GAA8B,GAFF,CAFhC,CADmC,CAA9B,EAQJ0C,IARI,CAQCrK,KAAK,CAACI,KARP,CAAP;AASD,GAjRwB;AAmRzB6P,gBAAc,EAAE,UAAUC,SAAV,EAAqB;AACnC,QAAIxV,IAAI,GAAG,IAAX;AACA,QAAIgK,OAAO,GAAGhK,IAAI,CAAC8T,QAAL,CAAchP,GAAd,CAAkB0Q,SAAlB,CAAd;AACA,QAAIxL,OAAJ,EACE,OAAOA,OAAO,CAACf,UAAf,CADF,KAGE,OAAO,IAAP;AACH;AA1RwB,CAA3B;;AA6RA,IAAIwL,gBAAgB,GAAG,UAAUgB,uBAAV,EACUC,uBADV,EACmC;AACxD,MAAIC,cAAc,GAAG1W,CAAC,CAAC6G,IAAF,CAAO2P,uBAAP,EAAgC,UAAUzN,OAAV,EAAmB;AACtE,WAAO/I,CAAC,CAACsV,QAAF,CAAWmB,uBAAX,EAAoC1N,OAApC,CAAP;AACD,GAFoB,CAArB;;AAGA,MAAI,CAAC2N,cAAL,EAAqB;AACnBA,kBAAc,GAAGD,uBAAuB,CAAC,CAAD,CAAxC;AACD;;AACD,SAAOC,cAAP;AACD,CATD;;AAWA9R,SAAS,CAAC+R,iBAAV,GAA8BnB,gBAA9B,C,CAGA;AACA;;AACA,IAAI3E,qBAAqB,GAAG,UAAUD,SAAV,EAAqBgG,OAArB,EAA8B;AACxD,MAAI,CAAChG,SAAL,EAAgB,OAAOA,SAAP,CADwC,CAGxD;AACA;AACA;;AACA,MAAIA,SAAS,CAACiG,YAAd,EAA4B;AAC1B,QAAI,EAAEjG,SAAS,YAAYxH,MAAM,CAACR,KAA9B,CAAJ,EAA0C;AACxC,YAAMkO,eAAe,GAAGlG,SAAS,CAACmG,OAAlC;AACAnG,eAAS,GAAG,IAAIxH,MAAM,CAACR,KAAX,CAAiBgI,SAAS,CAACxC,KAA3B,EAAkCwC,SAAS,CAACxD,MAA5C,EAAoDwD,SAAS,CAACoG,OAA9D,CAAZ;AACApG,eAAS,CAACmG,OAAV,GAAoBD,eAApB;AACD;;AACD,WAAOlG,SAAP;AACD,GAbuD,CAexD;AACA;;;AACA,MAAI,CAACA,SAAS,CAACqG,eAAf,EAAgC;AAC9B7N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAA7B,EAAsChG,SAAtC;;AACA,QAAIA,SAAS,CAACsG,cAAd,EAA8B;AAC5B9N,YAAM,CAAC6D,MAAP,CAAc,0CAAd,EAA0D2D,SAAS,CAACsG,cAApE;;AACA9N,YAAM,CAAC6D,MAAP;AACD;AACF,GAvBuD,CAyBxD;AACA;AACA;AACA;;;AACA,MAAI2D,SAAS,CAACsG,cAAd,EAA8B;AAC5B,QAAItG,SAAS,CAACsG,cAAV,CAAyBL,YAA7B,EACE,OAAOjG,SAAS,CAACsG,cAAjB;;AACF9N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAAf,GAAyB,kCAAzB,GACA,mDADd;AAED;;AAED,SAAO,IAAIxN,MAAM,CAACR,KAAX,CAAiB,GAAjB,EAAsB,uBAAtB,CAAP;AACD,CArCD,C,CAwCA;AACA;;;AACA,IAAI2H,wBAAwB,GAAG,UAAUQ,CAAV,EAAa6F,OAAb,EAAsBvS,IAAtB,EAA4B8S,WAA5B,EAAyC;AACtE9S,MAAI,GAAGA,IAAI,IAAI,EAAf;;AACA,MAAIqH,OAAO,CAAC,uBAAD,CAAX,EAAsC;AACpC,WAAO0L,KAAK,CAACC,gCAAN,CACLtG,CADK,EACF6F,OADE,EACOvS,IADP,EACa8S,WADb,CAAP;AAED;;AACD,SAAOpG,CAAC,CAACpM,KAAF,CAAQiS,OAAR,EAAiBvS,IAAjB,CAAP;AACD,CAPD,C;;;;;;;;;;;ACpuDA,IAAIiT,MAAM,GAAGzX,GAAG,CAACC,OAAJ,CAAY,eAAZ,CAAb,C,CAEA;AACA;AACA;AACA;;;AACA8E,SAAS,CAACwK,WAAV,GAAwB,YAAY;AAClC,MAAIrO,IAAI,GAAG,IAAX;AAEAA,MAAI,CAACwW,KAAL,GAAa,KAAb;AACAxW,MAAI,CAACyW,KAAL,GAAa,KAAb;AACAzW,MAAI,CAAC0W,OAAL,GAAe,KAAf;AACA1W,MAAI,CAAC2W,kBAAL,GAA0B,CAA1B;AACA3W,MAAI,CAAC4W,qBAAL,GAA6B,EAA7B;AACA5W,MAAI,CAAC6W,oBAAL,GAA4B,EAA5B;AACD,CATD,C,CAWA;AACA;AACA;AACA;;;AACAhT,SAAS,CAACuL,kBAAV,GAA+B,IAAI/G,MAAM,CAACyO,mBAAX,EAA/B;;AAEA7X,CAAC,CAACyD,MAAF,CAASmB,SAAS,CAACwK,WAAV,CAAsB1L,SAA/B,EAA0C;AACxC;AACA;AACA;AACA;AACA;AACAoU,YAAU,EAAE,YAAY;AACtB,QAAI/W,IAAI,GAAG,IAAX;AAEA,QAAIA,IAAI,CAAC0W,OAAT,EACE,OAAO;AAAEM,eAAS,EAAE,YAAY,CAAE;AAA3B,KAAP;AAEF,QAAIhX,IAAI,CAACyW,KAAT,EACE,MAAM,IAAI5O,KAAJ,CAAU,uDAAV,CAAN;AAEF7H,QAAI,CAAC2W,kBAAL;AACA,QAAIK,SAAS,GAAG,KAAhB;AACA,WAAO;AACLA,eAAS,EAAE,YAAY;AACrB,YAAIA,SAAJ,EACE,MAAM,IAAInP,KAAJ,CAAU,0CAAV,CAAN;AACFmP,iBAAS,GAAG,IAAZ;AACAhX,YAAI,CAAC2W,kBAAL;;AACA3W,YAAI,CAACiX,UAAL;AACD;AAPI,KAAP;AASD,GA1BuC;AA4BxC;AACA;AACAvI,KAAG,EAAE,YAAY;AACf,QAAI1O,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,KAAK6D,SAAS,CAACuL,kBAAV,CAA6BtK,GAA7B,EAAb,EACE,MAAM+C,KAAK,CAAC,6BAAD,CAAX;AACF7H,QAAI,CAACwW,KAAL,GAAa,IAAb;;AACAxW,QAAI,CAACiX,UAAL;AACD,GApCuC;AAsCxC;AACA;AACA;AACAC,cAAY,EAAE,UAAUnC,IAAV,EAAgB;AAC5B,QAAI/U,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyW,KAAT,EACE,MAAM,IAAI5O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF7H,QAAI,CAAC4W,qBAAL,CAA2BlX,IAA3B,CAAgCqV,IAAhC;AACD,GA/CuC;AAiDxC;AACAzG,gBAAc,EAAE,UAAUyG,IAAV,EAAgB;AAC9B,QAAI/U,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyW,KAAT,EACE,MAAM,IAAI5O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF7H,QAAI,CAAC6W,oBAAL,CAA0BnX,IAA1B,CAA+BqV,IAA/B;AACD,GAxDuC;AA0DxC;AACAoC,YAAU,EAAE,YAAY;AACtB,QAAInX,IAAI,GAAG,IAAX;AACA,QAAIoX,MAAM,GAAG,IAAIb,MAAJ,EAAb;AACAvW,QAAI,CAACsO,cAAL,CAAoB,YAAY;AAC9B8I,YAAM,CAAC,QAAD,CAAN;AACD,KAFD;AAGApX,QAAI,CAAC0O,GAAL;AACA0I,UAAM,CAACC,IAAP;AACD,GAnEuC;AAqExCJ,YAAU,EAAE,YAAY;AACtB,QAAIjX,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyW,KAAT,EACE,MAAM,IAAI5O,KAAJ,CAAU,gCAAV,CAAN;;AACF,QAAI7H,IAAI,CAACwW,KAAL,IAAc,CAACxW,IAAI,CAAC2W,kBAAxB,EAA4C;AAC1C,eAASW,cAAT,CAAyBvC,IAAzB,EAA+B;AAC7B,YAAI;AACFA,cAAI,CAAC/U,IAAD,CAAJ;AACD,SAFD,CAEE,OAAO8H,GAAP,EAAY;AACZO,gBAAM,CAAC6D,MAAP,CAAc,mCAAd,EAAmDpE,GAAnD;AACD;AACF;;AAED9H,UAAI,CAAC2W,kBAAL;;AACA,aAAO3W,IAAI,CAAC4W,qBAAL,CAA2B1R,MAA3B,GAAoC,CAA3C,EAA8C;AAC5C,YAAIiB,SAAS,GAAGnG,IAAI,CAAC4W,qBAArB;AACA5W,YAAI,CAAC4W,qBAAL,GAA6B,EAA7B;;AACA3X,SAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkBmR,cAAlB;AACD;;AACDtX,UAAI,CAAC2W,kBAAL;;AAEA,UAAI,CAAC3W,IAAI,CAAC2W,kBAAV,EAA8B;AAC5B3W,YAAI,CAACyW,KAAL,GAAa,IAAb;AACA,YAAItQ,SAAS,GAAGnG,IAAI,CAAC6W,oBAArB;AACA7W,YAAI,CAAC6W,oBAAL,GAA4B,EAA5B;;AACA5X,SAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkBmR,cAAlB;AACD;AACF;AACF,GAjGuC;AAmGxC;AACA;AACA/I,QAAM,EAAE,YAAY;AAClB,QAAIvO,IAAI,GAAG,IAAX;AACA,QAAI,CAAEA,IAAI,CAACyW,KAAX,EACE,MAAM,IAAI5O,KAAJ,CAAU,yCAAV,CAAN;AACF7H,QAAI,CAAC0W,OAAL,GAAe,IAAf;AACD;AA1GuC,CAA1C,E;;;;;;;;;;;ACvBA;AACA;AACA;AAEA7S,SAAS,CAAC0T,SAAV,GAAsB,UAAUtP,OAAV,EAAmB;AACvC,MAAIjI,IAAI,GAAG,IAAX;AACAiI,SAAO,GAAGA,OAAO,IAAI,EAArB;AAEAjI,MAAI,CAACwX,MAAL,GAAc,CAAd,CAJuC,CAKvC;AACA;AACA;;AACAxX,MAAI,CAACyX,qBAAL,GAA6B,EAA7B;AACAzX,MAAI,CAAC0X,0BAAL,GAAkC,EAAlC;AACA1X,MAAI,CAAC2X,WAAL,GAAmB1P,OAAO,CAAC0P,WAAR,IAAuB,UAA1C;AACA3X,MAAI,CAAC4X,QAAL,GAAgB3P,OAAO,CAAC2P,QAAR,IAAoB,IAApC;AACD,CAZD;;AAcA3Y,CAAC,CAACyD,MAAF,CAASmB,SAAS,CAAC0T,SAAV,CAAoB5U,SAA7B,EAAwC;AACtC;AACAkV,uBAAqB,EAAE,UAAU9N,GAAV,EAAe;AACpC,QAAI/J,IAAI,GAAG,IAAX;;AACA,QAAI,CAAEf,CAAC,CAAC0G,GAAF,CAAMoE,GAAN,EAAW,YAAX,CAAN,EAAgC;AAC9B,aAAO,EAAP;AACD,KAFD,MAEO,IAAI,OAAOA,GAAG,CAACoB,UAAX,KAA2B,QAA/B,EAAyC;AAC9C,UAAIpB,GAAG,CAACoB,UAAJ,KAAmB,EAAvB,EACE,MAAMtD,KAAK,CAAC,+BAAD,CAAX;AACF,aAAOkC,GAAG,CAACoB,UAAX;AACD,KAJM,MAIA;AACL,YAAMtD,KAAK,CAAC,oCAAD,CAAX;AACD;AACF,GAbqC;AAetC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAiQ,QAAM,EAAE,UAAUC,OAAV,EAAmBtV,QAAnB,EAA6B;AACnC,QAAIzC,IAAI,GAAG,IAAX;AACA,QAAI+G,EAAE,GAAG/G,IAAI,CAACwX,MAAL,EAAT;;AAEA,QAAIrM,UAAU,GAAGnL,IAAI,CAAC6X,qBAAL,CAA2BE,OAA3B,CAAjB;;AACA,QAAIC,MAAM,GAAG;AAACD,aAAO,EAAEzS,KAAK,CAACI,KAAN,CAAYqS,OAAZ,CAAV;AAAgCtV,cAAQ,EAAEA;AAA1C,KAAb;;AACA,QAAI,CAAExD,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAACyX,qBAAX,EAAkCtM,UAAlC,CAAN,EAAqD;AACnDnL,UAAI,CAACyX,qBAAL,CAA2BtM,UAA3B,IAAyC,EAAzC;AACAnL,UAAI,CAAC0X,0BAAL,CAAgCvM,UAAhC,IAA8C,CAA9C;AACD;;AACDnL,QAAI,CAACyX,qBAAL,CAA2BtM,UAA3B,EAAuCpE,EAAvC,IAA6CiR,MAA7C;AACAhY,QAAI,CAAC0X,0BAAL,CAAgCvM,UAAhC;;AAEA,QAAInL,IAAI,CAAC4X,QAAL,IAAiBjN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,aAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE7K,IAAI,CAAC2X,WADP,EACoB3X,IAAI,CAAC4X,QADzB,EACmC,CADnC;AAED;;AAED,WAAO;AACL/L,UAAI,EAAE,YAAY;AAChB,YAAI7L,IAAI,CAAC4X,QAAL,IAAiBjN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,iBAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE7K,IAAI,CAAC2X,WADP,EACoB3X,IAAI,CAAC4X,QADzB,EACmC,CAAC,CADpC;AAED;;AACD,eAAO5X,IAAI,CAACyX,qBAAL,CAA2BtM,UAA3B,EAAuCpE,EAAvC,CAAP;AACA/G,YAAI,CAAC0X,0BAAL,CAAgCvM,UAAhC;;AACA,YAAInL,IAAI,CAAC0X,0BAAL,CAAgCvM,UAAhC,MAAgD,CAApD,EAAuD;AACrD,iBAAOnL,IAAI,CAACyX,qBAAL,CAA2BtM,UAA3B,CAAP;AACA,iBAAOnL,IAAI,CAAC0X,0BAAL,CAAgCvM,UAAhC,CAAP;AACD;AACF;AAZI,KAAP;AAcD,GAzDqC;AA2DtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA8M,MAAI,EAAE,UAAUC,YAAV,EAAwB;AAC5B,QAAIlY,IAAI,GAAG,IAAX;;AAEA,QAAImL,UAAU,GAAGnL,IAAI,CAAC6X,qBAAL,CAA2BK,YAA3B,CAAjB;;AAEA,QAAI,CAAEjZ,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAACyX,qBAAX,EAAkCtM,UAAlC,CAAN,EAAqD;AACnD;AACD;;AAED,QAAIgN,sBAAsB,GAAGnY,IAAI,CAACyX,qBAAL,CAA2BtM,UAA3B,CAA7B;AACA,QAAIiN,WAAW,GAAG,EAAlB;;AACAnZ,KAAC,CAACuD,IAAF,CAAO2V,sBAAP,EAA+B,UAAUE,CAAV,EAAatR,EAAb,EAAiB;AAC9C,UAAI/G,IAAI,CAACsY,QAAL,CAAcJ,YAAd,EAA4BG,CAAC,CAACN,OAA9B,CAAJ,EAA4C;AAC1CK,mBAAW,CAAC1Y,IAAZ,CAAiBqH,EAAjB;AACD;AACF,KAJD,EAX4B,CAiB5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA9H,KAAC,CAACuD,IAAF,CAAO4V,WAAP,EAAoB,UAAUrR,EAAV,EAAc;AAChC,UAAI9H,CAAC,CAAC0G,GAAF,CAAMwS,sBAAN,EAA8BpR,EAA9B,CAAJ,EAAuC;AACrCoR,8BAAsB,CAACpR,EAAD,CAAtB,CAA2BtE,QAA3B,CAAoCyV,YAApC;AACD;AACF,KAJD;AAKD,GAlGqC;AAoGtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAI,UAAQ,EAAE,UAAUJ,YAAV,EAAwBH,OAAxB,EAAiC;AACzC;AACA;AACA;AACA;AACA;AACA,QAAI,OAAOG,YAAY,CAACnR,EAApB,KAA4B,QAA5B,IACA,OAAOgR,OAAO,CAAChR,EAAf,KAAuB,QADvB,IAEAmR,YAAY,CAACnR,EAAb,KAAoBgR,OAAO,CAAChR,EAFhC,EAEoC;AAClC,aAAO,KAAP;AACD;;AACD,QAAImR,YAAY,CAACnR,EAAb,YAA2BqL,OAAO,CAACmG,QAAnC,IACAR,OAAO,CAAChR,EAAR,YAAsBqL,OAAO,CAACmG,QAD9B,IAEA,CAAEL,YAAY,CAACnR,EAAb,CAAgBxB,MAAhB,CAAuBwS,OAAO,CAAChR,EAA/B,CAFN,EAE0C;AACxC,aAAO,KAAP;AACD;;AAED,WAAO9H,CAAC,CAAC+T,GAAF,CAAM+E,OAAN,EAAe,UAAUS,YAAV,EAAwB/T,GAAxB,EAA6B;AACjD,aAAO,CAACxF,CAAC,CAAC0G,GAAF,CAAMuS,YAAN,EAAoBzT,GAApB,CAAD,IACLa,KAAK,CAACC,MAAN,CAAaiT,YAAb,EAA2BN,YAAY,CAACzT,GAAD,CAAvC,CADF;AAED,KAHM,CAAP;AAID;AA1IqC,CAAxC,E,CA6IA;AACA;AACA;AACA;AACA;;;AACAZ,SAAS,CAAC4U,qBAAV,GAAkC,IAAI5U,SAAS,CAAC0T,SAAd,CAAwB;AACxDK,UAAQ,EAAE;AAD8C,CAAxB,CAAlC,C;;;;;;;;;;;ACpKA,IAAIvY,OAAO,CAACC,GAAR,CAAYoZ,0BAAhB,EAA4C;AAC1C7Y,2BAAyB,CAAC6Y,0BAA1B,GACErZ,OAAO,CAACC,GAAR,CAAYoZ,0BADd;AAED;;AAEDrQ,MAAM,CAACrH,MAAP,GAAgB,IAAIyS,MAAJ,EAAhB;;AAEApL,MAAM,CAACsQ,OAAP,GAAiB,UAAUT,YAAV,EAAwB;AACvCrU,WAAS,CAAC4U,qBAAV,CAAgCR,IAAhC,CAAqCC,YAArC;AACD,CAFD,C,CAIA;AACA;;;AACAjZ,CAAC,CAACuD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,EAAuB,MAAvB,EAA+B,OAA/B,EAAwC,cAAxC,EAAwD,WAAxD,CAAP,EACO,UAAUyK,IAAV,EAAgB;AACd5E,QAAM,CAAC4E,IAAD,CAAN,GAAehO,CAAC,CAAC2H,IAAF,CAAOyB,MAAM,CAACrH,MAAP,CAAciM,IAAd,CAAP,EAA4B5E,MAAM,CAACrH,MAAnC,CAAf;AACD,CAHR,E,CAKA;AACA;AACA;;;AACAqH,MAAM,CAACuQ,cAAP,GAAwBvQ,MAAM,CAACrH,MAA/B,C","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n var extensions = [];\n\n var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n if (websocketCompressionConfig) {\n extensions.push(Npm.require('permessage-deflate').configure(\n websocketCompressionConfig\n ));\n }\n\n return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n var self = this;\n self.registration_callbacks = [];\n self.open_sockets = [];\n\n // Because we are installing directly onto WebApp.httpServer instead of using\n // WebApp.app, we have to process the path prefix ourselves.\n self.prefix = pathPrefix + '/sockjs';\n RoutePolicy.declare(self.prefix + '/', 'network');\n\n // set up sockjs\n var sockjs = Npm.require('sockjs');\n var serverOptions = {\n prefix: self.prefix,\n log: function() {},\n // this is the default, but we code it explicitly because we depend\n // on it in stream_client:HEARTBEAT_TIMEOUT\n heartbeat_delay: 45000,\n // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n // bound for that much time, SockJS might not notice that the user has\n // reconnected because the timer (of disconnect_delay ms) can fire before\n // SockJS processes the new connection. Eventually we'll fix this by not\n // combining CPU-heavy processing with SockJS termination (eg a proxy which\n // converts to Unix sockets) but for now, raise the delay.\n disconnect_delay: 60 * 1000,\n // Set the USE_JSESSIONID environment variable to enable setting the\n // JSESSIONID cookie. This is useful for setting up proxies with\n // session affinity.\n jsessionid: !!process.env.USE_JSESSIONID\n };\n\n // If you know your server environment (eg, proxies) will prevent websockets\n // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n // browsers) will not waste time attempting to use them.\n // (Your server will still have a /websocket endpoint.)\n if (process.env.DISABLE_WEBSOCKETS) {\n serverOptions.websocket = false;\n } else {\n serverOptions.faye_server_options = {\n extensions: websocketExtensions()\n };\n }\n\n self.server = sockjs.createServer(serverOptions);\n\n // Install the sockjs handlers, but we want to keep around our own particular\n // request handler that adjusts idle timeouts while we have an outstanding\n // request. This compensates for the fact that sockjs removes all listeners\n // for \"request\" to add its own.\n WebApp.httpServer.removeListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n self.server.installHandlers(WebApp.httpServer);\n WebApp.httpServer.addListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n\n // Support the /websocket endpoint\n self._redirectWebsocketEndpoint();\n\n self.server.on('connection', function (socket) {\n // We want to make sure that if a client connects to us and does the initial\n // Websocket handshake but never gets to the DDP handshake, that we\n // eventually kill the socket. Once the DDP handshake happens, DDP\n // heartbeating will work. And before the Websocket handshake, the timeouts\n // we set at the server level in webapp_server.js will work. But\n // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n // is an \"in between\" state where this doesn't happen. We work around this\n // by explicitly setting the socket timeout to a relatively large time here,\n // and setting it back to zero when we set up the heartbeat in\n // livedata_server.js.\n socket.setWebsocketTimeout = function (timeout) {\n if ((socket.protocol === 'websocket' ||\n socket.protocol === 'websocket-raw')\n && socket._session.recv) {\n socket._session.recv.connection.setTimeout(timeout);\n }\n };\n socket.setWebsocketTimeout(45 * 1000);\n\n socket.send = function (data) {\n socket.write(data);\n };\n socket.on('close', function () {\n self.open_sockets = _.without(self.open_sockets, socket);\n });\n self.open_sockets.push(socket);\n\n // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n // will force old clients to reload. Remove this once we're not\n // concerned about people upgrading from a pre-0.7.0 release. Also,\n // remove the clause in the client that ignores the welcome message\n // (livedata_connection.js)\n socket.send(JSON.stringify({server_id: \"0\"}));\n\n // call all our callbacks when we get a new socket. they will do the\n // work of setting up handlers and such for specific messages.\n _.each(self.registration_callbacks, function (callback) {\n callback(socket);\n });\n });\n\n};\n\n_.extend(StreamServer.prototype, {\n // call my callback when a new socket connects.\n // also call it for all current connections.\n register: function (callback) {\n var self = this;\n self.registration_callbacks.push(callback);\n _.each(self.all_sockets(), function (socket) {\n callback(socket);\n });\n },\n\n // get a list of all sockets\n all_sockets: function () {\n var self = this;\n return _.values(self.open_sockets);\n },\n\n // Redirect /websocket to /sockjs/websocket in order to not expose\n // sockjs to clients that want to use raw websockets\n _redirectWebsocketEndpoint: function() {\n var self = this;\n // Unfortunately we can't use a connect middleware here since\n // sockjs installs itself prior to all existing listeners\n // (meaning prior to any connect middlewares) so we need to take\n // an approach similar to overshadowListeners in\n // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n _.each(['request', 'upgrade'], function(event) {\n var httpServer = WebApp.httpServer;\n var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n httpServer.removeAllListeners(event);\n\n // request and upgrade have different arguments passed but\n // we only care about the first one which is always request\n var newListener = function(request /*, moreArguments */) {\n // Store arguments for use within the closure below\n var args = arguments;\n\n // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n // preserving query string.\n var parsedUrl = url.parse(request.url);\n if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n parsedUrl.pathname === pathPrefix + '/websocket/') {\n parsedUrl.pathname = self.prefix + '/websocket';\n request.url = url.format(parsedUrl);\n }\n _.each(oldHttpServerListeners, function(oldListener) {\n oldListener.apply(httpServer, args);\n });\n };\n httpServer.addListener(event, newListener);\n });\n }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n var self = this;\n self.existsIn = new Set(); // set of subscriptionHandle\n self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n getFields: function () {\n var self = this;\n var ret = {};\n self.dataByKey.forEach(function (precedenceList, key) {\n ret[key] = precedenceList[0].value;\n });\n return ret;\n },\n\n clearField: function (subscriptionHandle, key, changeCollector) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n var precedenceList = self.dataByKey.get(key);\n\n // It's okay to clear fields that didn't exist. No need to throw\n // an error.\n if (!precedenceList)\n return;\n\n var removedValue = undefined;\n for (var i = 0; i < precedenceList.length; i++) {\n var precedence = precedenceList[i];\n if (precedence.subscriptionHandle === subscriptionHandle) {\n // The view's value can only change if this subscription is the one that\n // used to have precedence.\n if (i === 0)\n removedValue = precedence.value;\n precedenceList.splice(i, 1);\n break;\n }\n }\n if (precedenceList.length === 0) {\n self.dataByKey.delete(key);\n changeCollector[key] = undefined;\n } else if (removedValue !== undefined &&\n !EJSON.equals(removedValue, precedenceList[0].value)) {\n changeCollector[key] = precedenceList[0].value;\n }\n },\n\n changeField: function (subscriptionHandle, key, value,\n changeCollector, isAdd) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n\n // Don't share state with the data passed in by the user.\n value = EJSON.clone(value);\n\n if (!self.dataByKey.has(key)) {\n self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n value: value}]);\n changeCollector[key] = value;\n return;\n }\n var precedenceList = self.dataByKey.get(key);\n var elt;\n if (!isAdd) {\n elt = precedenceList.find(function (precedence) {\n return precedence.subscriptionHandle === subscriptionHandle;\n });\n }\n\n if (elt) {\n if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n // this subscription is changing the value of this field.\n changeCollector[key] = value;\n }\n elt.value = value;\n } else {\n // this subscription is newly caring about this field\n precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n }\n\n }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n var self = this;\n self.collectionName = collectionName;\n self.documents = new Map();\n self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n isEmpty: function () {\n var self = this;\n return self.documents.size === 0;\n },\n\n diff: function (previous) {\n var self = this;\n DiffSequence.diffMaps(previous.documents, self.documents, {\n both: _.bind(self.diffDocument, self),\n\n rightOnly: function (id, nowDV) {\n self.callbacks.added(self.collectionName, id, nowDV.getFields());\n },\n\n leftOnly: function (id, prevDV) {\n self.callbacks.removed(self.collectionName, id);\n }\n });\n },\n\n diffDocument: function (id, prevDV, nowDV) {\n var self = this;\n var fields = {};\n DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n both: function (key, prev, now) {\n if (!EJSON.equals(prev, now))\n fields[key] = now;\n },\n rightOnly: function (key, now) {\n fields[key] = now;\n },\n leftOnly: function(key, prev) {\n fields[key] = undefined;\n }\n });\n self.callbacks.changed(self.collectionName, id, fields);\n },\n\n added: function (subscriptionHandle, id, fields) {\n var self = this;\n var docView = self.documents.get(id);\n var added = false;\n if (!docView) {\n added = true;\n docView = new SessionDocumentView();\n self.documents.set(id, docView);\n }\n docView.existsIn.add(subscriptionHandle);\n var changeCollector = {};\n _.each(fields, function (value, key) {\n docView.changeField(\n subscriptionHandle, key, value, changeCollector, true);\n });\n if (added)\n self.callbacks.added(self.collectionName, id, changeCollector);\n else\n self.callbacks.changed(self.collectionName, id, changeCollector);\n },\n\n changed: function (subscriptionHandle, id, changed) {\n var self = this;\n var changedResult = {};\n var docView = self.documents.get(id);\n if (!docView)\n throw new Error(\"Could not find element with id \" + id + \" to change\");\n _.each(changed, function (value, key) {\n if (value === undefined)\n docView.clearField(subscriptionHandle, key, changedResult);\n else\n docView.changeField(subscriptionHandle, key, value, changedResult);\n });\n self.callbacks.changed(self.collectionName, id, changedResult);\n },\n\n removed: function (subscriptionHandle, id) {\n var self = this;\n var docView = self.documents.get(id);\n if (!docView) {\n var err = new Error(\"Removed nonexistent document \" + id);\n throw err;\n }\n docView.existsIn.delete(subscriptionHandle);\n if (docView.existsIn.size === 0) {\n // it is gone from everyone\n self.callbacks.removed(self.collectionName, id);\n self.documents.delete(id);\n } else {\n var changed = {};\n // remove this subscription from every precedence list\n // and record the changes\n docView.dataByKey.forEach(function (precedenceList, key) {\n docView.clearField(subscriptionHandle, key, changed);\n });\n\n self.callbacks.changed(self.collectionName, id, changed);\n }\n }\n});\n\n/******************************************************************************/\n/* Session */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n var self = this;\n self.id = Random.id();\n\n self.server = server;\n self.version = version;\n\n self.initialized = false;\n self.socket = socket;\n\n // set to null when the session is destroyed. multiple places below\n // use this to determine if the session is alive or not.\n self.inQueue = new Meteor._DoubleEndedQueue();\n\n self.blocked = false;\n self.workerRunning = false;\n\n // Sub objects for active subscriptions\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n self.userId = null;\n\n self.collectionViews = new Map();\n\n // Set this to false to not send messages when collectionViews are\n // modified. This is done when rerunning subs in _setUserId and those messages\n // are calculated via a diff instead.\n self._isSending = true;\n\n // If this is true, don't start a newly-created universal publisher on this\n // session. The session will take care of starting it when appropriate.\n self._dontStartNewUniversalSubs = false;\n\n // when we are rerunning subscriptions, any ready messages\n // we want to buffer up for when we are done rerunning subscriptions\n self._pendingReady = [];\n\n // List of callbacks to call when this connection is closed.\n self._closeCallbacks = [];\n\n\n // XXX HACK: If a sockjs connection, save off the URL. This is\n // temporary and will go away in the near future.\n self._socketUrl = socket.url;\n\n // Allow tests to disable responding to pings.\n self._respondToPings = options.respondToPings;\n\n // This object is the public interface to the session. In the public\n // API, it is called the `connection` object. Internally we call it\n // a `connectionHandle` to avoid ambiguity.\n self.connectionHandle = {\n id: self.id,\n close: function () {\n self.close();\n },\n onClose: function (fn) {\n var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n if (self.inQueue) {\n self._closeCallbacks.push(cb);\n } else {\n // if we're already closed, call the callback.\n Meteor.defer(cb);\n }\n },\n clientAddress: self._clientAddress(),\n httpHeaders: self.socket.headers\n };\n\n self.send({ msg: 'connected', session: self.id });\n\n // On initial connect, spin up all the universal publishers.\n Fiber(function () {\n self.startUniversalSubs();\n }).run();\n\n if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n // We no longer need the low level timeout because we have heartbeating.\n socket.setWebsocketTimeout(0);\n\n self.heartbeat = new DDPCommon.Heartbeat({\n heartbeatInterval: options.heartbeatInterval,\n heartbeatTimeout: options.heartbeatTimeout,\n onTimeout: function () {\n self.close();\n },\n sendPing: function () {\n self.send({msg: 'ping'});\n }\n });\n self.heartbeat.start();\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n sendReady: function (subscriptionIds) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"ready\", subs: subscriptionIds});\n else {\n _.each(subscriptionIds, function (subscriptionId) {\n self._pendingReady.push(subscriptionId);\n });\n }\n },\n\n sendAdded: function (collectionName, id, fields) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n },\n\n sendChanged: function (collectionName, id, fields) {\n var self = this;\n if (_.isEmpty(fields))\n return;\n\n if (self._isSending) {\n self.send({\n msg: \"changed\",\n collection: collectionName,\n id: id,\n fields: fields\n });\n }\n },\n\n sendRemoved: function (collectionName, id) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"removed\", collection: collectionName, id: id});\n },\n\n getSendCallbacks: function () {\n var self = this;\n return {\n added: _.bind(self.sendAdded, self),\n changed: _.bind(self.sendChanged, self),\n removed: _.bind(self.sendRemoved, self)\n };\n },\n\n getCollectionView: function (collectionName) {\n var self = this;\n var ret = self.collectionViews.get(collectionName);\n if (!ret) {\n ret = new SessionCollectionView(collectionName,\n self.getSendCallbacks());\n self.collectionViews.set(collectionName, ret);\n }\n return ret;\n },\n\n added: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.added(subscriptionHandle, id, fields);\n },\n\n removed: function (subscriptionHandle, collectionName, id) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.removed(subscriptionHandle, id);\n if (view.isEmpty()) {\n self.collectionViews.delete(collectionName);\n }\n },\n\n changed: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.changed(subscriptionHandle, id, fields);\n },\n\n startUniversalSubs: function () {\n var self = this;\n // Make a shallow copy of the set of universal handlers and start them. If\n // additional universal publishers start while we're running them (due to\n // yielding), they will run separately as part of Server.publish.\n var handlers = _.clone(self.server.universal_publish_handlers);\n _.each(handlers, function (handler) {\n self._startSubscription(handler);\n });\n },\n\n // Destroy this session and unregister it at the server.\n close: function () {\n var self = this;\n\n // Destroy this session, even if it's not registered at the\n // server. Stop all processing and tear everything down. If a socket\n // was attached, close it.\n\n // Already destroyed.\n if (! self.inQueue)\n return;\n\n // Drop the merge box data immediately.\n self.inQueue = null;\n self.collectionViews = new Map();\n\n if (self.heartbeat) {\n self.heartbeat.stop();\n self.heartbeat = null;\n }\n\n if (self.socket) {\n self.socket.close();\n self.socket._meteorSession = null;\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", -1);\n\n Meteor.defer(function () {\n // stop callbacks can yield, so we defer this on close.\n // sub._isDeactivated() detects that we set inQueue to null and\n // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n self._deactivateAllSubscriptions();\n\n // Defer calling the close callbacks, so that the caller closing\n // the session isn't waiting for all the callbacks to complete.\n _.each(self._closeCallbacks, function (callback) {\n callback();\n });\n });\n\n // Unregister the session.\n self.server._removeSession(self);\n },\n\n // Send a message (doing nothing if no socket is connected right now.)\n // It should be a JSON object (it will be stringified.)\n send: function (msg) {\n var self = this;\n if (self.socket) {\n if (Meteor._printSentDDP)\n Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n self.socket.send(DDPCommon.stringifyDDP(msg));\n }\n },\n\n // Send a connection error.\n sendError: function (reason, offendingMessage) {\n var self = this;\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n self.send(msg);\n },\n\n // Process 'msg' as an incoming message. (But as a guard against\n // race conditions during reconnection, ignore the message if\n // 'socket' is not the currently connected socket.)\n //\n // We run the messages from the client one at a time, in the order\n // given by the client. The message handler is passed an idempotent\n // function 'unblock' which it may call to allow other messages to\n // begin running in parallel in another fiber (for example, a method\n // that wants to yield.) Otherwise, it is automatically unblocked\n // when it returns.\n //\n // Actually, we don't have to 'totally order' the messages in this\n // way, but it's the easiest thing that's correct. (unsub needs to\n // be ordered against sub, methods need to be ordered against each\n // other.)\n processMessage: function (msg_in) {\n var self = this;\n if (!self.inQueue) // we have been destroyed.\n return;\n\n // Respond to ping and pong messages immediately without queuing.\n // If the negotiated DDP version is \"pre1\" which didn't support\n // pings, preserve the \"pre1\" behavior of responding with a \"bad\n // request\" for the unknown messages.\n //\n // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n // needs a Fiber. We could actually use regular setTimeout and avoid\n // these new fibers, but it is easier to just make everything use\n // Meteor.setTimeout and not think too hard.\n //\n // Any message counts as receiving a pong, as it demonstrates that\n // the client is still alive.\n if (self.heartbeat) {\n Fiber(function () {\n self.heartbeat.messageReceived();\n }).run();\n }\n\n if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n if (self._respondToPings)\n self.send({msg: \"pong\", id: msg_in.id});\n return;\n }\n if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n // Since everything is a pong, nothing to do\n return;\n }\n\n self.inQueue.push(msg_in);\n if (self.workerRunning)\n return;\n self.workerRunning = true;\n\n var processNext = function () {\n var msg = self.inQueue && self.inQueue.shift();\n if (!msg) {\n self.workerRunning = false;\n return;\n }\n\n Fiber(function () {\n var blocked = true;\n\n var unblock = function () {\n if (!blocked)\n return; // idempotent\n blocked = false;\n processNext();\n };\n\n self.server.onMessageHook.each(function (callback) {\n callback(msg, self);\n return true;\n });\n\n if (_.has(self.protocol_handlers, msg.msg))\n self.protocol_handlers[msg.msg].call(self, msg, unblock);\n else\n self.sendError('Bad request', msg);\n unblock(); // in case the handler didn't already do it\n }).run();\n };\n\n processNext();\n },\n\n protocol_handlers: {\n sub: function (msg) {\n var self = this;\n\n // reject malformed messages\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.name) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array))) {\n self.sendError(\"Malformed subscription\", msg);\n return;\n }\n\n if (!self.server.publish_handlers[msg.name]) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n return;\n }\n\n if (self._namedSubs.has(msg.id))\n // subs are idempotent, or rather, they are ignored if a sub\n // with that id already exists. this is important during\n // reconnect.\n return;\n\n // XXX It'd be much better if we had generic hooks where any package can\n // hook into subscription handling, but in the mean while we special case\n // ddp-rate-limiter package. This is also done for weak requirements to\n // add the ddp-rate-limiter package in case we don't have Accounts. A\n // user trying to use the ddp-rate-limiter must explicitly require it.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"subscription\",\n name: msg.name,\n connectionId: self.id\n };\n\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n if (!rateLimitResult.allowed) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(\n 'too-many-requests',\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset})\n });\n return;\n }\n }\n\n var handler = self.server.publish_handlers[msg.name];\n\n self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n },\n\n unsub: function (msg) {\n var self = this;\n\n self._stopSubscription(msg.id);\n },\n\n method: function (msg, unblock) {\n var self = this;\n\n // reject malformed messages\n // For now, we silently ignore unknown attributes,\n // for forwards compatibility.\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.method) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array)) ||\n (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n self.sendError(\"Malformed method invocation\", msg);\n return;\n }\n\n var randomSeed = msg.randomSeed || null;\n\n // set up to mark the method as satisfied once all observers\n // (and subscriptions) have reacted to any writes that were\n // done.\n var fence = new DDPServer._WriteFence;\n fence.onAllCommitted(function () {\n // Retire the fence so that future writes are allowed.\n // This means that callbacks like timers are free to use\n // the fence, and if they fire before it's armed (for\n // example, because the method waits for them) their\n // writes will be included in the fence.\n fence.retire();\n self.send({\n msg: 'updated', methods: [msg.id]});\n });\n\n // find the handler\n var handler = self.server.method_handlers[msg.method];\n if (!handler) {\n self.send({\n msg: 'result', id: msg.id,\n error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n fence.arm();\n return;\n }\n\n var setUserId = function(userId) {\n self._setUserId(userId);\n };\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId: self.userId,\n setUserId: setUserId,\n unblock: unblock,\n connection: self.connectionHandle,\n randomSeed: randomSeed\n });\n\n const promise = new Promise((resolve, reject) => {\n // XXX It'd be better if we could hook into method handlers better but\n // for now, we need to check if the ddp-rate-limiter exists since we\n // have a weak requirement for the ddp-rate-limiter package to be added\n // to our application.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"method\",\n name: msg.method,\n connectionId: self.id\n };\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n if (!rateLimitResult.allowed) {\n reject(new Meteor.Error(\n \"too-many-requests\",\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset}\n ));\n return;\n }\n }\n\n resolve(DDPServer._CurrentWriteFence.withValue(\n fence,\n () => DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, msg.params,\n \"call to '\" + msg.method + \"'\"\n )\n )\n ));\n });\n\n function finish() {\n fence.arm();\n unblock();\n }\n\n const payload = {\n msg: \"result\",\n id: msg.id\n };\n\n promise.then((result) => {\n finish();\n if (result !== undefined) {\n payload.result = result;\n }\n self.send(payload);\n }, (exception) => {\n finish();\n payload.error = wrapInternalException(\n exception,\n `while invoking method '${msg.method}'`\n );\n self.send(payload);\n });\n }\n },\n\n _eachSub: function (f) {\n var self = this;\n self._namedSubs.forEach(f);\n self._universalSubs.forEach(f);\n },\n\n _diffCollectionViews: function (beforeCVs) {\n var self = this;\n DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n both: function (collectionName, leftValue, rightValue) {\n rightValue.diff(leftValue);\n },\n rightOnly: function (collectionName, rightValue) {\n rightValue.documents.forEach(function (docView, id) {\n self.sendAdded(collectionName, id, docView.getFields());\n });\n },\n leftOnly: function (collectionName, leftValue) {\n leftValue.documents.forEach(function (doc, id) {\n self.sendRemoved(collectionName, id);\n });\n }\n });\n },\n\n // Sets the current user id in all appropriate contexts and reruns\n // all subscriptions\n _setUserId: function(userId) {\n var self = this;\n\n if (userId !== null && typeof userId !== \"string\")\n throw new Error(\"setUserId must be called on string or null, not \" +\n typeof userId);\n\n // Prevent newly-created universal subscriptions from being added to our\n // session; they will be found below when we call startUniversalSubs.\n //\n // (We don't have to worry about named subscriptions, because we only add\n // them when we process a 'sub' message. We are currently processing a\n // 'method' message, and the method did not unblock, because it is illegal\n // to call setUserId after unblock. Thus we cannot be concurrently adding a\n // new named subscription.)\n self._dontStartNewUniversalSubs = true;\n\n // Prevent current subs from updating our collectionViews and call their\n // stop callbacks. This may yield.\n self._eachSub(function (sub) {\n sub._deactivate();\n });\n\n // All subs should now be deactivated. Stop sending messages to the client,\n // save the state of the published collections, reset to an empty view, and\n // update the userId.\n self._isSending = false;\n var beforeCVs = self.collectionViews;\n self.collectionViews = new Map();\n self.userId = userId;\n\n // _setUserId is normally called from a Meteor method with\n // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n // expected to be set inside a publish function, so we temporary unset it.\n // Inside a publish function DDP._CurrentPublicationInvocation is set.\n DDP._CurrentMethodInvocation.withValue(undefined, function () {\n // Save the old named subs, and reset to having no subscriptions.\n var oldNamedSubs = self._namedSubs;\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n oldNamedSubs.forEach(function (sub, subscriptionId) {\n var newSub = sub._recreate();\n self._namedSubs.set(subscriptionId, newSub);\n // nb: if the handler throws or calls this.error(), it will in fact\n // immediately send its 'nosub'. This is OK, though.\n newSub._runHandler();\n });\n\n // Allow newly-created universal subs to be started on our connection in\n // parallel with the ones we're spinning up here, and spin up universal\n // subs.\n self._dontStartNewUniversalSubs = false;\n self.startUniversalSubs();\n });\n\n // Start sending messages again, beginning with the diff from the previous\n // state of the world to the current state. No yields are allowed during\n // this diff, so that other changes cannot interleave.\n Meteor._noYieldsAllowed(function () {\n self._isSending = true;\n self._diffCollectionViews(beforeCVs);\n if (!_.isEmpty(self._pendingReady)) {\n self.sendReady(self._pendingReady);\n self._pendingReady = [];\n }\n });\n },\n\n _startSubscription: function (handler, subId, params, name) {\n var self = this;\n\n var sub = new Subscription(\n self, handler, subId, params, name);\n if (subId)\n self._namedSubs.set(subId, sub);\n else\n self._universalSubs.push(sub);\n\n sub._runHandler();\n },\n\n // tear down specified subscription\n _stopSubscription: function (subId, error) {\n var self = this;\n\n var subName = null;\n if (subId) {\n var maybeSub = self._namedSubs.get(subId);\n if (maybeSub) {\n subName = maybeSub._name;\n maybeSub._removeAllDocuments();\n maybeSub._deactivate();\n self._namedSubs.delete(subId);\n }\n }\n\n var response = {msg: 'nosub', id: subId};\n\n if (error) {\n response.error = wrapInternalException(\n error,\n subName ? (\"from sub \" + subName + \" id \" + subId)\n : (\"from sub id \" + subId));\n }\n\n self.send(response);\n },\n\n // tear down all subscriptions. Note that this does NOT send removed or nosub\n // messages, since we assume the client is gone.\n _deactivateAllSubscriptions: function () {\n var self = this;\n\n self._namedSubs.forEach(function (sub, id) {\n sub._deactivate();\n });\n self._namedSubs = new Map();\n\n self._universalSubs.forEach(function (sub) {\n sub._deactivate();\n });\n self._universalSubs = [];\n },\n\n // Determine the remote client's IP address, based on the\n // HTTP_FORWARDED_COUNT environment variable representing how many\n // proxies the server is behind.\n _clientAddress: function () {\n var self = this;\n\n // For the reported client address for a connection to be correct,\n // the developer must set the HTTP_FORWARDED_COUNT environment\n // variable to an integer representing the number of hops they\n // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n // server is behind one proxy.\n //\n // This could be computed once at startup instead of every time.\n var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n if (httpForwardedCount === 0)\n return self.socket.remoteAddress;\n\n var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n if (! _.isString(forwardedFor))\n return null;\n forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n // Typically the first value in the `x-forwarded-for` header is\n // the original IP address of the client connecting to the first\n // proxy. However, the end user can easily spoof the header, in\n // which case the first value(s) will be the fake IP address from\n // the user pretending to be a proxy reporting the original IP\n // address value. By counting HTTP_FORWARDED_COUNT back from the\n // end of the list, we ensure that we get the IP address being\n // reported by *our* first proxy.\n\n if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n return null;\n\n return forwardedFor[forwardedFor.length - httpForwardedCount];\n }\n});\n\n/******************************************************************************/\n/* Subscription */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n session, handler, subscriptionId, params, name) {\n var self = this;\n self._session = session; // type is Session\n\n /**\n * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n * @locus Server\n * @name connection\n * @memberOf Subscription\n * @instance\n */\n self.connection = session.connectionHandle; // public API object\n\n self._handler = handler;\n\n // my subscription ID (generated by client, undefined for universal subs).\n self._subscriptionId = subscriptionId;\n // undefined for universal subs\n self._name = name;\n\n self._params = params || [];\n\n // Only named subscriptions have IDs, but we need some sort of string\n // internally to keep track of all subscriptions inside\n // SessionDocumentViews. We use this subscriptionHandle for that.\n if (self._subscriptionId) {\n self._subscriptionHandle = 'N' + self._subscriptionId;\n } else {\n self._subscriptionHandle = 'U' + Random.id();\n }\n\n // has _deactivate been called?\n self._deactivated = false;\n\n // stop callbacks to g/c this sub. called w/ zero arguments.\n self._stopCallbacks = [];\n\n // the set of (collection, documentid) that this subscription has\n // an opinion about\n self._documents = new Map();\n\n // remember if we are ready.\n self._ready = false;\n\n // Part of the public API: the user of this sub.\n\n /**\n * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n * @locus Server\n * @memberOf Subscription\n * @name userId\n * @instance\n */\n self.userId = session.userId;\n\n // For now, the id filter is going to default to\n // the to/from DDP methods on MongoID, to\n // specifically deal with mongo/minimongo ObjectIds.\n\n // Later, you will be able to make this be \"raw\"\n // if you want to publish a collection that you know\n // just has strings for keys and no funny business, to\n // a ddp consumer that isn't minimongo\n\n self._idFilter = {\n idStringify: MongoID.idStringify,\n idParse: MongoID.idParse\n };\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n _runHandler: function () {\n // XXX should we unblock() here? Either before running the publish\n // function, or before running _publishCursor.\n //\n // Right now, each publish function blocks all future publishes and\n // methods waiting on data from Mongo (or whatever else the function\n // blocks on). This probably slows page load in common cases.\n\n var self = this;\n try {\n var res = DDP._CurrentPublicationInvocation.withValue(\n self,\n () => maybeAuditArgumentChecks(\n self._handler, self, EJSON.clone(self._params),\n // It's OK that this would look weird for universal subscriptions,\n // because they have no arguments so there can never be an\n // audit-argument-checks failure.\n \"publisher '\" + self._name + \"'\"\n )\n );\n } catch (e) {\n self.error(e);\n return;\n }\n\n // Did the handler call this.error or this.stop?\n if (self._isDeactivated())\n return;\n\n self._publishHandlerResult(res);\n },\n\n _publishHandlerResult: function (res) {\n // SPECIAL CASE: Instead of writing their own callbacks that invoke\n // this.added/changed/ready/etc, the user can just return a collection\n // cursor or array of cursors from the publish function; we call their\n // _publishCursor method which starts observing the cursor and publishes the\n // results. Note that _publishCursor does NOT call ready().\n //\n // XXX This uses an undocumented interface which only the Mongo cursor\n // interface publishes. Should we make this interface public and encourage\n // users to implement it themselves? Arguably, it's unnecessary; users can\n // already write their own functions like\n // var publishMyReactiveThingy = function (name, handler) {\n // Meteor.publish(name, function () {\n // var reactiveThingy = handler();\n // reactiveThingy.publishMe();\n // });\n // };\n\n var self = this;\n var isCursor = function (c) {\n return c && c._publishCursor;\n };\n if (isCursor(res)) {\n try {\n res._publishCursor(self);\n } catch (e) {\n self.error(e);\n return;\n }\n // _publishCursor only returns after the initial added callbacks have run.\n // mark subscription as ready.\n self.ready();\n } else if (_.isArray(res)) {\n // check all the elements are cursors\n if (! _.all(res, isCursor)) {\n self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n return;\n }\n // find duplicate collection names\n // XXX we should support overlapping cursors, but that would require the\n // merge box to allow overlap within a subscription\n var collectionNames = {};\n for (var i = 0; i < res.length; ++i) {\n var collectionName = res[i]._getCollectionName();\n if (_.has(collectionNames, collectionName)) {\n self.error(new Error(\n \"Publish function returned multiple cursors for collection \" +\n collectionName));\n return;\n }\n collectionNames[collectionName] = true;\n };\n\n try {\n _.each(res, function (cur) {\n cur._publishCursor(self);\n });\n } catch (e) {\n self.error(e);\n return;\n }\n self.ready();\n } else if (res) {\n // truthy values other than cursors or arrays are probably a\n // user mistake (possible returning a Mongo document via, say,\n // `coll.findOne()`).\n self.error(new Error(\"Publish function can only return a Cursor or \"\n + \"an array of Cursors\"));\n }\n },\n\n // This calls all stop callbacks and prevents the handler from updating any\n // SessionCollectionViews further. It's used when the user unsubscribes or\n // disconnects, as well as during setUserId re-runs. It does *NOT* send\n // removed messages for the published objects; if that is necessary, call\n // _removeAllDocuments first.\n _deactivate: function() {\n var self = this;\n if (self._deactivated)\n return;\n self._deactivated = true;\n self._callStopCallbacks();\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", -1);\n },\n\n _callStopCallbacks: function () {\n var self = this;\n // tell listeners, so they can clean up\n var callbacks = self._stopCallbacks;\n self._stopCallbacks = [];\n _.each(callbacks, function (callback) {\n callback();\n });\n },\n\n // Send remove messages for every document.\n _removeAllDocuments: function () {\n var self = this;\n Meteor._noYieldsAllowed(function () {\n self._documents.forEach(function (collectionDocs, collectionName) {\n collectionDocs.forEach(function (strId) {\n self.removed(collectionName, self._idFilter.idParse(strId));\n });\n });\n });\n },\n\n // Returns a new Subscription for the same session with the same\n // initial creation parameters. This isn't a clone: it doesn't have\n // the same _documents cache, stopped state or callbacks; may have a\n // different _subscriptionHandle, and gets its userId from the\n // session, not from this object.\n _recreate: function () {\n var self = this;\n return new Subscription(\n self._session, self._handler, self._subscriptionId, self._params,\n self._name);\n },\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n * @locus Server\n * @param {Error} error The error to pass to the client.\n * @instance\n * @memberOf Subscription\n */\n error: function (error) {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId, error);\n },\n\n // Note that while our DDP client will notice that you've called stop() on the\n // server (and clean up its _subscriptions table) we don't actually provide a\n // mechanism for an app to notice this (the subscribe onError callback only\n // triggers if there is an error).\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error.\n * @locus Server\n * @instance\n * @memberOf Subscription\n */\n stop: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId);\n },\n\n /**\n * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {Function} func The callback function\n */\n onStop: function (callback) {\n var self = this;\n callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n if (self._isDeactivated())\n callback();\n else\n self._stopCallbacks.push(callback);\n },\n\n // This returns true if the sub has been deactivated, *OR* if the session was\n // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n // happened yet.\n _isDeactivated: function () {\n var self = this;\n return self._deactivated || self._session.inQueue === null;\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the new document.\n * @param {String} id The new document's ID.\n * @param {Object} fields The fields in the new document. If `_id` is present it is ignored.\n */\n added: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n let ids = self._documents.get(collectionName);\n if (ids == null) {\n ids = new Set();\n self._documents.set(collectionName, ids);\n }\n ids.add(id);\n self._session.added(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the changed document.\n * @param {String} id The changed document's ID.\n * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored.\n */\n changed: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that the document has been removed from.\n * @param {String} id The ID of the document that has been removed.\n */\n removed: function (collectionName, id) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n // We don't bother to delete sets of things in a collection if the\n // collection is empty. It could break _removeAllDocuments.\n self._documents.get(collectionName).delete(id);\n self._session.removed(self._subscriptionHandle, collectionName, id);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any.\n * @locus Server\n * @memberOf Subscription\n * @instance\n */\n ready: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n if (!self._subscriptionId)\n return; // unnecessary but ignored for universal sub\n if (!self._ready) {\n self._session.sendReady([self._subscriptionId]);\n self._ready = true;\n }\n }\n});\n\n/******************************************************************************/\n/* Server */\n/******************************************************************************/\n\nServer = function (options) {\n var self = this;\n\n // The default heartbeat interval is 30 seconds on the server and 35\n // seconds on the client. Since the client doesn't need to send a\n // ping as long as it is receiving pings, this means that pings\n // normally go from the server to the client.\n //\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n self.options = _.defaults(options || {}, {\n heartbeatInterval: 15000,\n heartbeatTimeout: 15000,\n // For testing, allow responding to pings to be disabled.\n respondToPings: true\n });\n\n // Map of callbacks to call when a new connection comes in to the\n // server and completes DDP version negotiation. Use an object instead\n // of an array so we can safely remove one from the list while\n // iterating over it.\n self.onConnectionHook = new Hook({\n debugPrintExceptions: \"onConnection callback\"\n });\n\n // Map of callbacks to call when a new message comes in.\n self.onMessageHook = new Hook({\n debugPrintExceptions: \"onMessage callback\"\n });\n\n self.publish_handlers = {};\n self.universal_publish_handlers = [];\n\n self.method_handlers = {};\n\n self.sessions = new Map(); // map from id to session\n\n self.stream_server = new StreamServer;\n\n self.stream_server.register(function (socket) {\n // socket implements the SockJSConnection interface\n socket._meteorSession = null;\n\n var sendError = function (reason, offendingMessage) {\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n socket.send(DDPCommon.stringifyDDP(msg));\n };\n\n socket.on('data', function (raw_msg) {\n if (Meteor._printReceivedDDP) {\n Meteor._debug(\"Received DDP\", raw_msg);\n }\n try {\n try {\n var msg = DDPCommon.parseDDP(raw_msg);\n } catch (err) {\n sendError('Parse error');\n return;\n }\n if (msg === null || !msg.msg) {\n sendError('Bad request', msg);\n return;\n }\n\n if (msg.msg === 'connect') {\n if (socket._meteorSession) {\n sendError(\"Already connected\", msg);\n return;\n }\n Fiber(function () {\n self._handleConnect(socket, msg);\n }).run();\n return;\n }\n\n if (!socket._meteorSession) {\n sendError('Must connect first', msg);\n return;\n }\n socket._meteorSession.processMessage(msg);\n } catch (e) {\n // XXX print stack nicely\n Meteor._debug(\"Internal exception while processing message\", msg, e);\n }\n });\n\n socket.on('close', function () {\n if (socket._meteorSession) {\n Fiber(function () {\n socket._meteorSession.close();\n }).run();\n }\n });\n });\n};\n\n_.extend(Server.prototype, {\n\n /**\n * @summary Register a callback to be called when a new DDP connection is made to the server.\n * @locus Server\n * @param {function} callback The function to call when a new DDP connection is established.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onConnection: function (fn) {\n var self = this;\n return self.onConnectionHook.register(fn);\n },\n\n /**\n * @summary Register a callback to be called when a new DDP message is received.\n * @locus Server\n * @param {function} callback The function to call when a new DDP message is received.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onMessage: function (fn) {\n var self = this;\n return self.onMessageHook.register(fn);\n },\n\n _handleConnect: function (socket, msg) {\n var self = this;\n\n // The connect message must specify a version and an array of supported\n // versions, and it must claim to support what it is proposing.\n if (!(typeof (msg.version) === 'string' &&\n _.isArray(msg.support) &&\n _.all(msg.support, _.isString) &&\n _.contains(msg.support, msg.version))) {\n socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n socket.close();\n return;\n }\n\n // In the future, handle session resumption: something like:\n // socket._meteorSession = self.sessions[msg.session]\n var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n if (msg.version !== version) {\n // The best version to use (according to the client's stated preferences)\n // is not the one the client is trying to use. Inform them about the best\n // version to use.\n socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n socket.close();\n return;\n }\n\n // Yay, version matches! Create a new session.\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n socket._meteorSession = new Session(self, version, socket, self.options);\n self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n self.onConnectionHook.each(function (callback) {\n if (socket._meteorSession)\n callback(socket._meteorSession.connectionHandle);\n return true;\n });\n },\n /**\n * Register a publish handler function.\n *\n * @param name {String} identifier for query\n * @param handler {Function} publish handler\n * @param options {Object}\n *\n * Server will call handler function on each new subscription,\n * either when receiving DDP sub message for a named subscription, or on\n * DDP connect for a universal subscription.\n *\n * If name is null, this will be a subscription that is\n * automatically established and permanently on for all connected\n * client, instead of a subscription that can be turned on and off\n * with subscribe().\n *\n * options to contain:\n * - (mostly internal) is_auto: true if generated automatically\n * from an autopublish hook. this is for cosmetic purposes only\n * (it lets us determine whether to print a warning suggesting\n * that you turn off autopublish.)\n */\n\n /**\n * @summary Publish a record set.\n * @memberOf Meteor\n * @importFromPackage meteor\n * @locus Server\n * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments.\n */\n publish: function (name, handler, options) {\n var self = this;\n\n if (! _.isObject(name)) {\n options = options || {};\n\n if (name && name in self.publish_handlers) {\n Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n return;\n }\n\n if (Package.autopublish && !options.is_auto) {\n // They have autopublish on, yet they're trying to manually\n // picking stuff to publish. They probably should turn off\n // autopublish. (This check isn't perfect -- if you create a\n // publish before you turn on autopublish, it won't catch\n // it. But this will definitely handle the simple case where\n // you've added the autopublish package to your app, and are\n // calling publish from your app code.)\n if (!self.warned_about_autopublish) {\n self.warned_about_autopublish = true;\n Meteor._debug(\n \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n \"** will still be sent to all clients.\\n\" +\n \"**\\n\" +\n \"** Turn off autopublish by removing the autopublish package:\\n\" +\n \"**\\n\" +\n \"** $ meteor remove autopublish\\n\" +\n \"**\\n\" +\n \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n \"** for each collection that you want clients to see.\\n\");\n }\n }\n\n if (name)\n self.publish_handlers[name] = handler;\n else {\n self.universal_publish_handlers.push(handler);\n // Spin up the new publisher on any existing session too. Run each\n // session's subscription in a new Fiber, so that there's no change for\n // self.sessions to change while we're running this loop.\n self.sessions.forEach(function (session) {\n if (!session._dontStartNewUniversalSubs) {\n Fiber(function() {\n session._startSubscription(handler);\n }).run();\n }\n });\n }\n }\n else{\n _.each(name, function(value, key) {\n self.publish(key, value, {});\n });\n }\n },\n\n _removeSession: function (session) {\n var self = this;\n self.sessions.delete(session.id);\n },\n\n /**\n * @summary Defines functions that can be invoked over the network by clients.\n * @locus Anywhere\n * @param {Object} methods Dictionary whose keys are method names and values are functions.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n methods: function (methods) {\n var self = this;\n _.each(methods, function (func, name) {\n if (typeof func !== 'function')\n throw new Error(\"Method '\" + name + \"' must be a function\");\n if (self.method_handlers[name])\n throw new Error(\"A method named '\" + name + \"' is already defined\");\n self.method_handlers[name] = func;\n });\n },\n\n call: function (name, ...args) {\n if (args.length && typeof args[args.length - 1] === \"function\") {\n // If it's a function, the last argument is the result callback, not\n // a parameter to the remote method.\n var callback = args.pop();\n }\n\n return this.apply(name, args, callback);\n },\n\n // A version of the call method that always returns a Promise.\n callAsync: function (name, ...args) {\n return this.applyAsync(name, args);\n },\n\n apply: function (name, args, options, callback) {\n // We were passed 3 arguments. They may be either (name, args, options)\n // or (name, args, callback)\n if (! callback && typeof options === 'function') {\n callback = options;\n options = {};\n } else {\n options = options || {};\n }\n\n const promise = this.applyAsync(name, args, options);\n\n // Return the result in whichever way the caller asked for it. Note that we\n // do NOT block on the write fence in an analogous way to how the client\n // blocks on the relevant data being visible, so you are NOT guaranteed that\n // cursor observe callbacks have fired when your callback is invoked. (We\n // can change this if there's a real use case.)\n if (callback) {\n promise.then(\n result => callback(undefined, result),\n exception => callback(exception)\n );\n } else {\n return promise.await();\n }\n },\n\n // @param options {Optional Object}\n applyAsync: function (name, args, options) {\n // Run the handler\n var handler = this.method_handlers[name];\n if (! handler) {\n return Promise.reject(\n new Meteor.Error(404, `Method '${name}' not found`)\n );\n }\n\n // If this is a method call from within another method or publish function,\n // get the user state from the outer method or publish function, otherwise\n // don't allow setUserId to be called\n var userId = null;\n var setUserId = function() {\n throw new Error(\"Can't call setUserId on a server initiated method call\");\n };\n var connection = null;\n var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n var randomSeed = null;\n if (currentMethodInvocation) {\n userId = currentMethodInvocation.userId;\n setUserId = function(userId) {\n currentMethodInvocation.setUserId(userId);\n };\n connection = currentMethodInvocation.connection;\n randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n } else if (currentPublicationInvocation) {\n userId = currentPublicationInvocation.userId;\n setUserId = function(userId) {\n currentPublicationInvocation._session._setUserId(userId);\n };\n connection = currentPublicationInvocation.connection;\n }\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId,\n setUserId,\n connection,\n randomSeed\n });\n\n return new Promise(resolve => resolve(\n DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, EJSON.clone(args),\n \"internal call to '\" + name + \"'\"\n )\n )\n )).then(EJSON.clone);\n },\n\n _urlForSession: function (sessionId) {\n var self = this;\n var session = self.sessions.get(sessionId);\n if (session)\n return session._socketUrl;\n else\n return null;\n }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n serverSupportedVersions) {\n var correctVersion = _.find(clientSupportedVersions, function (version) {\n return _.contains(serverSupportedVersions, version);\n });\n if (!correctVersion) {\n correctVersion = serverSupportedVersions[0];\n }\n return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n if (!exception) return exception;\n\n // To allow packages to throw errors intended for the client but not have to\n // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n // error before it is thrown.\n if (exception.isClientSafe) {\n if (!(exception instanceof Meteor.Error)) {\n const originalMessage = exception.message;\n exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n exception.message = originalMessage;\n }\n return exception;\n }\n\n // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n // the server log.\n if (!exception._expectedByTest) {\n Meteor._debug(\"Exception \" + context, exception);\n if (exception.sanitizedError) {\n Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n Meteor._debug();\n }\n }\n\n // Did the error contain more details that could have been useful if caught in\n // server code (or if thrown from non-client-originated code), but also\n // provided a \"sanitized\" version with more context than 500 Internal server\n // error? Use that.\n if (exception.sanitizedError) {\n if (exception.sanitizedError.isClientSafe)\n return exception.sanitizedError;\n Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n \"does not have isClientSafe property set; ignoring\");\n }\n\n return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n args = args || [];\n if (Package['audit-argument-checks']) {\n return Match._failIfArgumentsAreNotAllChecked(\n f, context, args, description);\n }\n return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n var self = this;\n\n self.armed = false;\n self.fired = false;\n self.retired = false;\n self.outstanding_writes = 0;\n self.before_fire_callbacks = [];\n self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n // Start tracking a write, and return an object to represent it. The\n // object has a single method, committed(). This method should be\n // called when the write is fully committed and propagated. You can\n // continue to add writes to the WriteFence up until it is triggered\n // (calls its callbacks because all writes have committed.)\n beginWrite: function () {\n var self = this;\n\n if (self.retired)\n return { committed: function () {} };\n\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to add writes\");\n\n self.outstanding_writes++;\n var committed = false;\n return {\n committed: function () {\n if (committed)\n throw new Error(\"committed called twice on the same write\");\n committed = true;\n self.outstanding_writes--;\n self._maybeFire();\n }\n };\n },\n\n // Arm the fence. Once the fence is armed, and there are no more\n // uncommitted writes, it will activate.\n arm: function () {\n var self = this;\n if (self === DDPServer._CurrentWriteFence.get())\n throw Error(\"Can't arm the current fence\");\n self.armed = true;\n self._maybeFire();\n },\n\n // Register a function to be called once before firing the fence.\n // Callback function can add new writes to the fence, in which case\n // it won't fire until those writes are done as well.\n onBeforeFire: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.before_fire_callbacks.push(func);\n },\n\n // Register a function to be called when the fence fires.\n onAllCommitted: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.completion_callbacks.push(func);\n },\n\n // Convenience function. Arms the fence, then blocks until it fires.\n armAndWait: function () {\n var self = this;\n var future = new Future;\n self.onAllCommitted(function () {\n future['return']();\n });\n self.arm();\n future.wait();\n },\n\n _maybeFire: function () {\n var self = this;\n if (self.fired)\n throw new Error(\"write fence already activated?\");\n if (self.armed && !self.outstanding_writes) {\n function invokeCallback (func) {\n try {\n func(self);\n } catch (err) {\n Meteor._debug(\"exception in write fence callback\", err);\n }\n }\n\n self.outstanding_writes++;\n while (self.before_fire_callbacks.length > 0) {\n var callbacks = self.before_fire_callbacks;\n self.before_fire_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n self.outstanding_writes--;\n\n if (!self.outstanding_writes) {\n self.fired = true;\n var callbacks = self.completion_callbacks;\n self.completion_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n }\n },\n\n // Deactivate this fence so that adding more writes has no effect.\n // The fence must have already fired.\n retire: function () {\n var self = this;\n if (! self.fired)\n throw new Error(\"Can't retire a fence that hasn't fired.\");\n self.retired = true;\n }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n var self = this;\n options = options || {};\n\n self.nextId = 1;\n // map from collection name (string) -> listener id -> object. each object has\n // keys 'trigger', 'callback'. As a hack, the empty string means \"no\n // collection\".\n self.listenersByCollection = {};\n self.listenersByCollectionCount = {};\n self.factPackage = options.factPackage || \"livedata\";\n self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n // msg is a trigger or a notification\n _collectionForMessage: function (msg) {\n var self = this;\n if (! _.has(msg, 'collection')) {\n return '';\n } else if (typeof(msg.collection) === 'string') {\n if (msg.collection === '')\n throw Error(\"Message has empty collection!\");\n return msg.collection;\n } else {\n throw Error(\"Message has non-string collection!\");\n }\n },\n\n // Listen for notification that match 'trigger'. A notification\n // matches if it has the key-value pairs in trigger as a\n // subset. When a notification matches, call 'callback', passing\n // the actual notification.\n //\n // Returns a listen handle, which is an object with a method\n // stop(). Call stop() to stop listening.\n //\n // XXX It should be legal to call fire() from inside a listen()\n // callback?\n listen: function (trigger, callback) {\n var self = this;\n var id = self.nextId++;\n\n var collection = self._collectionForMessage(trigger);\n var record = {trigger: EJSON.clone(trigger), callback: callback};\n if (! _.has(self.listenersByCollection, collection)) {\n self.listenersByCollection[collection] = {};\n self.listenersByCollectionCount[collection] = 0;\n }\n self.listenersByCollection[collection][id] = record;\n self.listenersByCollectionCount[collection]++;\n\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, 1);\n }\n\n return {\n stop: function () {\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, -1);\n }\n delete self.listenersByCollection[collection][id];\n self.listenersByCollectionCount[collection]--;\n if (self.listenersByCollectionCount[collection] === 0) {\n delete self.listenersByCollection[collection];\n delete self.listenersByCollectionCount[collection];\n }\n }\n };\n },\n\n // Fire the provided 'notification' (an object whose attribute\n // values are all JSON-compatibile) -- inform all matching listeners\n // (registered with listen()).\n //\n // If fire() is called inside a write fence, then each of the\n // listener callbacks will be called inside the write fence as well.\n //\n // The listeners may be invoked in parallel, rather than serially.\n fire: function (notification) {\n var self = this;\n\n var collection = self._collectionForMessage(notification);\n\n if (! _.has(self.listenersByCollection, collection)) {\n return;\n }\n\n var listenersForCollection = self.listenersByCollection[collection];\n var callbackIds = [];\n _.each(listenersForCollection, function (l, id) {\n if (self._matches(notification, l.trigger)) {\n callbackIds.push(id);\n }\n });\n\n // Listener callbacks can yield, so we need to first find all the ones that\n // match in a single iteration over self.listenersByCollection (which can't\n // be mutated during this iteration), and then invoke the matching\n // callbacks, checking before each call to ensure they haven't stopped.\n // Note that we don't have to check that\n // self.listenersByCollection[collection] still === listenersForCollection,\n // because the only way that stops being true is if listenersForCollection\n // first gets reduced down to the empty object (and then never gets\n // increased again).\n _.each(callbackIds, function (id) {\n if (_.has(listenersForCollection, id)) {\n listenersForCollection[id].callback(notification);\n }\n });\n },\n\n // A notification matches a trigger if all keys that exist in both are equal.\n //\n // Examples:\n // N:{collection: \"C\"} matches T:{collection: \"C\"}\n // (a non-targeted write to a collection matches a\n // non-targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n // (a targeted write to a collection matches a non-targeted query)\n // N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n // (a non-targeted write to a collection matches a\n // targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n // (a targeted write to a collection matches a targeted query targeted\n // at the same document)\n // N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n // (a targeted write to a collection does not match a targeted query\n // targeted at a different document)\n _matches: function (notification, trigger) {\n // Most notifications that use the crossbar have a string `collection` and\n // maybe an `id` that is a string or ObjectID. We're already dividing up\n // triggers by collection, but let's fast-track \"nope, different ID\" (and\n // avoid the overly generic EJSON.equals). This makes a noticeable\n // performance difference; see https://github.com/meteor/meteor/pull/3697\n if (typeof(notification.id) === 'string' &&\n typeof(trigger.id) === 'string' &&\n notification.id !== trigger.id) {\n return false;\n }\n if (notification.id instanceof MongoID.ObjectID &&\n trigger.id instanceof MongoID.ObjectID &&\n ! notification.id.equals(trigger.id)) {\n return false;\n }\n\n return _.all(trigger, function (triggerValue, key) {\n return !_.has(notification, key) ||\n EJSON.equals(triggerValue, notification[key]);\n });\n }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n function (name) {\n Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} \ No newline at end of file +{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n var extensions = [];\n\n var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n if (websocketCompressionConfig) {\n extensions.push(Npm.require('permessage-deflate').configure(\n websocketCompressionConfig\n ));\n }\n\n return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n var self = this;\n self.registration_callbacks = [];\n self.open_sockets = [];\n\n // Because we are installing directly onto WebApp.httpServer instead of using\n // WebApp.app, we have to process the path prefix ourselves.\n self.prefix = pathPrefix + '/sockjs';\n RoutePolicy.declare(self.prefix + '/', 'network');\n\n // set up sockjs\n var sockjs = Npm.require('sockjs');\n var serverOptions = {\n prefix: self.prefix,\n log: function() {},\n // this is the default, but we code it explicitly because we depend\n // on it in stream_client:HEARTBEAT_TIMEOUT\n heartbeat_delay: 45000,\n // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n // bound for that much time, SockJS might not notice that the user has\n // reconnected because the timer (of disconnect_delay ms) can fire before\n // SockJS processes the new connection. Eventually we'll fix this by not\n // combining CPU-heavy processing with SockJS termination (eg a proxy which\n // converts to Unix sockets) but for now, raise the delay.\n disconnect_delay: 60 * 1000,\n // Set the USE_JSESSIONID environment variable to enable setting the\n // JSESSIONID cookie. This is useful for setting up proxies with\n // session affinity.\n jsessionid: !!process.env.USE_JSESSIONID\n };\n\n // If you know your server environment (eg, proxies) will prevent websockets\n // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n // browsers) will not waste time attempting to use them.\n // (Your server will still have a /websocket endpoint.)\n if (process.env.DISABLE_WEBSOCKETS) {\n serverOptions.websocket = false;\n } else {\n serverOptions.faye_server_options = {\n extensions: websocketExtensions()\n };\n }\n\n self.server = sockjs.createServer(serverOptions);\n\n // Install the sockjs handlers, but we want to keep around our own particular\n // request handler that adjusts idle timeouts while we have an outstanding\n // request. This compensates for the fact that sockjs removes all listeners\n // for \"request\" to add its own.\n WebApp.httpServer.removeListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n self.server.installHandlers(WebApp.httpServer);\n WebApp.httpServer.addListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n\n // Support the /websocket endpoint\n self._redirectWebsocketEndpoint();\n\n self.server.on('connection', function (socket) {\n // We want to make sure that if a client connects to us and does the initial\n // Websocket handshake but never gets to the DDP handshake, that we\n // eventually kill the socket. Once the DDP handshake happens, DDP\n // heartbeating will work. And before the Websocket handshake, the timeouts\n // we set at the server level in webapp_server.js will work. But\n // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n // is an \"in between\" state where this doesn't happen. We work around this\n // by explicitly setting the socket timeout to a relatively large time here,\n // and setting it back to zero when we set up the heartbeat in\n // livedata_server.js.\n socket.setWebsocketTimeout = function (timeout) {\n if ((socket.protocol === 'websocket' ||\n socket.protocol === 'websocket-raw')\n && socket._session.recv) {\n socket._session.recv.connection.setTimeout(timeout);\n }\n };\n socket.setWebsocketTimeout(45 * 1000);\n\n socket.send = function (data) {\n socket.write(data);\n };\n socket.on('close', function () {\n self.open_sockets = _.without(self.open_sockets, socket);\n });\n self.open_sockets.push(socket);\n\n // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n // will force old clients to reload. Remove this once we're not\n // concerned about people upgrading from a pre-0.7.0 release. Also,\n // remove the clause in the client that ignores the welcome message\n // (livedata_connection.js)\n socket.send(JSON.stringify({server_id: \"0\"}));\n\n // call all our callbacks when we get a new socket. they will do the\n // work of setting up handlers and such for specific messages.\n _.each(self.registration_callbacks, function (callback) {\n callback(socket);\n });\n });\n\n};\n\n_.extend(StreamServer.prototype, {\n // call my callback when a new socket connects.\n // also call it for all current connections.\n register: function (callback) {\n var self = this;\n self.registration_callbacks.push(callback);\n _.each(self.all_sockets(), function (socket) {\n callback(socket);\n });\n },\n\n // get a list of all sockets\n all_sockets: function () {\n var self = this;\n return _.values(self.open_sockets);\n },\n\n // Redirect /websocket to /sockjs/websocket in order to not expose\n // sockjs to clients that want to use raw websockets\n _redirectWebsocketEndpoint: function() {\n var self = this;\n // Unfortunately we can't use a connect middleware here since\n // sockjs installs itself prior to all existing listeners\n // (meaning prior to any connect middlewares) so we need to take\n // an approach similar to overshadowListeners in\n // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n _.each(['request', 'upgrade'], function(event) {\n var httpServer = WebApp.httpServer;\n var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n httpServer.removeAllListeners(event);\n\n // request and upgrade have different arguments passed but\n // we only care about the first one which is always request\n var newListener = function(request /*, moreArguments */) {\n // Store arguments for use within the closure below\n var args = arguments;\n\n // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n // preserving query string.\n var parsedUrl = url.parse(request.url);\n if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n parsedUrl.pathname === pathPrefix + '/websocket/') {\n parsedUrl.pathname = self.prefix + '/websocket';\n request.url = url.format(parsedUrl);\n }\n _.each(oldHttpServerListeners, function(oldListener) {\n oldListener.apply(httpServer, args);\n });\n };\n httpServer.addListener(event, newListener);\n });\n }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n var self = this;\n self.existsIn = new Set(); // set of subscriptionHandle\n self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n getFields: function () {\n var self = this;\n var ret = {};\n self.dataByKey.forEach(function (precedenceList, key) {\n ret[key] = precedenceList[0].value;\n });\n return ret;\n },\n\n clearField: function (subscriptionHandle, key, changeCollector) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n var precedenceList = self.dataByKey.get(key);\n\n // It's okay to clear fields that didn't exist. No need to throw\n // an error.\n if (!precedenceList)\n return;\n\n var removedValue = undefined;\n for (var i = 0; i < precedenceList.length; i++) {\n var precedence = precedenceList[i];\n if (precedence.subscriptionHandle === subscriptionHandle) {\n // The view's value can only change if this subscription is the one that\n // used to have precedence.\n if (i === 0)\n removedValue = precedence.value;\n precedenceList.splice(i, 1);\n break;\n }\n }\n if (precedenceList.length === 0) {\n self.dataByKey.delete(key);\n changeCollector[key] = undefined;\n } else if (removedValue !== undefined &&\n !EJSON.equals(removedValue, precedenceList[0].value)) {\n changeCollector[key] = precedenceList[0].value;\n }\n },\n\n changeField: function (subscriptionHandle, key, value,\n changeCollector, isAdd) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n\n // Don't share state with the data passed in by the user.\n value = EJSON.clone(value);\n\n if (!self.dataByKey.has(key)) {\n self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n value: value}]);\n changeCollector[key] = value;\n return;\n }\n var precedenceList = self.dataByKey.get(key);\n var elt;\n if (!isAdd) {\n elt = precedenceList.find(function (precedence) {\n return precedence.subscriptionHandle === subscriptionHandle;\n });\n }\n\n if (elt) {\n if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n // this subscription is changing the value of this field.\n changeCollector[key] = value;\n }\n elt.value = value;\n } else {\n // this subscription is newly caring about this field\n precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n }\n\n }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n var self = this;\n self.collectionName = collectionName;\n self.documents = new Map();\n self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n isEmpty: function () {\n var self = this;\n return self.documents.size === 0;\n },\n\n diff: function (previous) {\n var self = this;\n DiffSequence.diffMaps(previous.documents, self.documents, {\n both: _.bind(self.diffDocument, self),\n\n rightOnly: function (id, nowDV) {\n self.callbacks.added(self.collectionName, id, nowDV.getFields());\n },\n\n leftOnly: function (id, prevDV) {\n self.callbacks.removed(self.collectionName, id);\n }\n });\n },\n\n diffDocument: function (id, prevDV, nowDV) {\n var self = this;\n var fields = {};\n DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n both: function (key, prev, now) {\n if (!EJSON.equals(prev, now))\n fields[key] = now;\n },\n rightOnly: function (key, now) {\n fields[key] = now;\n },\n leftOnly: function(key, prev) {\n fields[key] = undefined;\n }\n });\n self.callbacks.changed(self.collectionName, id, fields);\n },\n\n added: function (subscriptionHandle, id, fields) {\n var self = this;\n var docView = self.documents.get(id);\n var added = false;\n if (!docView) {\n added = true;\n docView = new SessionDocumentView();\n self.documents.set(id, docView);\n }\n docView.existsIn.add(subscriptionHandle);\n var changeCollector = {};\n _.each(fields, function (value, key) {\n docView.changeField(\n subscriptionHandle, key, value, changeCollector, true);\n });\n if (added)\n self.callbacks.added(self.collectionName, id, changeCollector);\n else\n self.callbacks.changed(self.collectionName, id, changeCollector);\n },\n\n changed: function (subscriptionHandle, id, changed) {\n var self = this;\n var changedResult = {};\n var docView = self.documents.get(id);\n if (!docView)\n throw new Error(\"Could not find element with id \" + id + \" to change\");\n _.each(changed, function (value, key) {\n if (value === undefined)\n docView.clearField(subscriptionHandle, key, changedResult);\n else\n docView.changeField(subscriptionHandle, key, value, changedResult);\n });\n self.callbacks.changed(self.collectionName, id, changedResult);\n },\n\n removed: function (subscriptionHandle, id) {\n var self = this;\n var docView = self.documents.get(id);\n if (!docView) {\n var err = new Error(\"Removed nonexistent document \" + id);\n throw err;\n }\n docView.existsIn.delete(subscriptionHandle);\n if (docView.existsIn.size === 0) {\n // it is gone from everyone\n self.callbacks.removed(self.collectionName, id);\n self.documents.delete(id);\n } else {\n var changed = {};\n // remove this subscription from every precedence list\n // and record the changes\n docView.dataByKey.forEach(function (precedenceList, key) {\n docView.clearField(subscriptionHandle, key, changed);\n });\n\n self.callbacks.changed(self.collectionName, id, changed);\n }\n }\n});\n\n/******************************************************************************/\n/* Session */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n var self = this;\n self.id = Random.id();\n\n self.server = server;\n self.version = version;\n\n self.initialized = false;\n self.socket = socket;\n\n // set to null when the session is destroyed. multiple places below\n // use this to determine if the session is alive or not.\n self.inQueue = new Meteor._DoubleEndedQueue();\n\n self.blocked = false;\n self.workerRunning = false;\n\n // Sub objects for active subscriptions\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n self.userId = null;\n\n self.collectionViews = new Map();\n\n // Set this to false to not send messages when collectionViews are\n // modified. This is done when rerunning subs in _setUserId and those messages\n // are calculated via a diff instead.\n self._isSending = true;\n\n // If this is true, don't start a newly-created universal publisher on this\n // session. The session will take care of starting it when appropriate.\n self._dontStartNewUniversalSubs = false;\n\n // when we are rerunning subscriptions, any ready messages\n // we want to buffer up for when we are done rerunning subscriptions\n self._pendingReady = [];\n\n // List of callbacks to call when this connection is closed.\n self._closeCallbacks = [];\n\n\n // XXX HACK: If a sockjs connection, save off the URL. This is\n // temporary and will go away in the near future.\n self._socketUrl = socket.url;\n\n // Allow tests to disable responding to pings.\n self._respondToPings = options.respondToPings;\n\n // This object is the public interface to the session. In the public\n // API, it is called the `connection` object. Internally we call it\n // a `connectionHandle` to avoid ambiguity.\n self.connectionHandle = {\n id: self.id,\n close: function () {\n self.close();\n },\n onClose: function (fn) {\n var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n if (self.inQueue) {\n self._closeCallbacks.push(cb);\n } else {\n // if we're already closed, call the callback.\n Meteor.defer(cb);\n }\n },\n clientAddress: self._clientAddress(),\n httpHeaders: self.socket.headers\n };\n\n self.send({ msg: 'connected', session: self.id });\n\n // On initial connect, spin up all the universal publishers.\n Fiber(function () {\n self.startUniversalSubs();\n }).run();\n\n if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n // We no longer need the low level timeout because we have heartbeating.\n socket.setWebsocketTimeout(0);\n\n self.heartbeat = new DDPCommon.Heartbeat({\n heartbeatInterval: options.heartbeatInterval,\n heartbeatTimeout: options.heartbeatTimeout,\n onTimeout: function () {\n self.close();\n },\n sendPing: function () {\n self.send({msg: 'ping'});\n }\n });\n self.heartbeat.start();\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n sendReady: function (subscriptionIds) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"ready\", subs: subscriptionIds});\n else {\n _.each(subscriptionIds, function (subscriptionId) {\n self._pendingReady.push(subscriptionId);\n });\n }\n },\n\n sendAdded: function (collectionName, id, fields) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n },\n\n sendChanged: function (collectionName, id, fields) {\n var self = this;\n if (_.isEmpty(fields))\n return;\n\n if (self._isSending) {\n self.send({\n msg: \"changed\",\n collection: collectionName,\n id: id,\n fields: fields\n });\n }\n },\n\n sendRemoved: function (collectionName, id) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"removed\", collection: collectionName, id: id});\n },\n\n getSendCallbacks: function () {\n var self = this;\n return {\n added: _.bind(self.sendAdded, self),\n changed: _.bind(self.sendChanged, self),\n removed: _.bind(self.sendRemoved, self)\n };\n },\n\n getCollectionView: function (collectionName) {\n var self = this;\n var ret = self.collectionViews.get(collectionName);\n if (!ret) {\n ret = new SessionCollectionView(collectionName,\n self.getSendCallbacks());\n self.collectionViews.set(collectionName, ret);\n }\n return ret;\n },\n\n added: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.added(subscriptionHandle, id, fields);\n },\n\n removed: function (subscriptionHandle, collectionName, id) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.removed(subscriptionHandle, id);\n if (view.isEmpty()) {\n self.collectionViews.delete(collectionName);\n }\n },\n\n changed: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.changed(subscriptionHandle, id, fields);\n },\n\n startUniversalSubs: function () {\n var self = this;\n // Make a shallow copy of the set of universal handlers and start them. If\n // additional universal publishers start while we're running them (due to\n // yielding), they will run separately as part of Server.publish.\n var handlers = _.clone(self.server.universal_publish_handlers);\n _.each(handlers, function (handler) {\n self._startSubscription(handler);\n });\n },\n\n // Destroy this session and unregister it at the server.\n close: function () {\n var self = this;\n\n // Destroy this session, even if it's not registered at the\n // server. Stop all processing and tear everything down. If a socket\n // was attached, close it.\n\n // Already destroyed.\n if (! self.inQueue)\n return;\n\n // Drop the merge box data immediately.\n self.inQueue = null;\n self.collectionViews = new Map();\n\n if (self.heartbeat) {\n self.heartbeat.stop();\n self.heartbeat = null;\n }\n\n if (self.socket) {\n self.socket.close();\n self.socket._meteorSession = null;\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", -1);\n\n Meteor.defer(function () {\n // stop callbacks can yield, so we defer this on close.\n // sub._isDeactivated() detects that we set inQueue to null and\n // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n self._deactivateAllSubscriptions();\n\n // Defer calling the close callbacks, so that the caller closing\n // the session isn't waiting for all the callbacks to complete.\n _.each(self._closeCallbacks, function (callback) {\n callback();\n });\n });\n\n // Unregister the session.\n self.server._removeSession(self);\n },\n\n // Send a message (doing nothing if no socket is connected right now.)\n // It should be a JSON object (it will be stringified.)\n send: function (msg) {\n var self = this;\n if (self.socket) {\n if (Meteor._printSentDDP)\n Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n self.socket.send(DDPCommon.stringifyDDP(msg));\n }\n },\n\n // Send a connection error.\n sendError: function (reason, offendingMessage) {\n var self = this;\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n self.send(msg);\n },\n\n // Process 'msg' as an incoming message. (But as a guard against\n // race conditions during reconnection, ignore the message if\n // 'socket' is not the currently connected socket.)\n //\n // We run the messages from the client one at a time, in the order\n // given by the client. The message handler is passed an idempotent\n // function 'unblock' which it may call to allow other messages to\n // begin running in parallel in another fiber (for example, a method\n // that wants to yield.) Otherwise, it is automatically unblocked\n // when it returns.\n //\n // Actually, we don't have to 'totally order' the messages in this\n // way, but it's the easiest thing that's correct. (unsub needs to\n // be ordered against sub, methods need to be ordered against each\n // other.)\n processMessage: function (msg_in) {\n var self = this;\n if (!self.inQueue) // we have been destroyed.\n return;\n\n // Respond to ping and pong messages immediately without queuing.\n // If the negotiated DDP version is \"pre1\" which didn't support\n // pings, preserve the \"pre1\" behavior of responding with a \"bad\n // request\" for the unknown messages.\n //\n // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n // needs a Fiber. We could actually use regular setTimeout and avoid\n // these new fibers, but it is easier to just make everything use\n // Meteor.setTimeout and not think too hard.\n //\n // Any message counts as receiving a pong, as it demonstrates that\n // the client is still alive.\n if (self.heartbeat) {\n Fiber(function () {\n self.heartbeat.messageReceived();\n }).run();\n }\n\n if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n if (self._respondToPings)\n self.send({msg: \"pong\", id: msg_in.id});\n return;\n }\n if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n // Since everything is a pong, nothing to do\n return;\n }\n\n self.inQueue.push(msg_in);\n if (self.workerRunning)\n return;\n self.workerRunning = true;\n\n var processNext = function () {\n var msg = self.inQueue && self.inQueue.shift();\n if (!msg) {\n self.workerRunning = false;\n return;\n }\n\n Fiber(function () {\n var blocked = true;\n\n var unblock = function () {\n if (!blocked)\n return; // idempotent\n blocked = false;\n processNext();\n };\n\n self.server.onMessageHook.each(function (callback) {\n callback(msg, self);\n return true;\n });\n\n if (_.has(self.protocol_handlers, msg.msg))\n self.protocol_handlers[msg.msg].call(self, msg, unblock);\n else\n self.sendError('Bad request', msg);\n unblock(); // in case the handler didn't already do it\n }).run();\n };\n\n processNext();\n },\n\n protocol_handlers: {\n sub: function (msg) {\n var self = this;\n\n // reject malformed messages\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.name) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array))) {\n self.sendError(\"Malformed subscription\", msg);\n return;\n }\n\n if (!self.server.publish_handlers[msg.name]) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n return;\n }\n\n if (self._namedSubs.has(msg.id))\n // subs are idempotent, or rather, they are ignored if a sub\n // with that id already exists. this is important during\n // reconnect.\n return;\n\n // XXX It'd be much better if we had generic hooks where any package can\n // hook into subscription handling, but in the mean while we special case\n // ddp-rate-limiter package. This is also done for weak requirements to\n // add the ddp-rate-limiter package in case we don't have Accounts. A\n // user trying to use the ddp-rate-limiter must explicitly require it.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"subscription\",\n name: msg.name,\n connectionId: self.id\n };\n\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n if (!rateLimitResult.allowed) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(\n 'too-many-requests',\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset})\n });\n return;\n }\n }\n\n var handler = self.server.publish_handlers[msg.name];\n\n self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n },\n\n unsub: function (msg) {\n var self = this;\n\n self._stopSubscription(msg.id);\n },\n\n method: function (msg, unblock) {\n var self = this;\n\n // reject malformed messages\n // For now, we silently ignore unknown attributes,\n // for forwards compatibility.\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.method) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array)) ||\n (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n self.sendError(\"Malformed method invocation\", msg);\n return;\n }\n\n var randomSeed = msg.randomSeed || null;\n\n // set up to mark the method as satisfied once all observers\n // (and subscriptions) have reacted to any writes that were\n // done.\n var fence = new DDPServer._WriteFence;\n fence.onAllCommitted(function () {\n // Retire the fence so that future writes are allowed.\n // This means that callbacks like timers are free to use\n // the fence, and if they fire before it's armed (for\n // example, because the method waits for them) their\n // writes will be included in the fence.\n fence.retire();\n self.send({\n msg: 'updated', methods: [msg.id]});\n });\n\n // find the handler\n var handler = self.server.method_handlers[msg.method];\n if (!handler) {\n self.send({\n msg: 'result', id: msg.id,\n error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n fence.arm();\n return;\n }\n\n var setUserId = function(userId) {\n self._setUserId(userId);\n };\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId: self.userId,\n setUserId: setUserId,\n unblock: unblock,\n connection: self.connectionHandle,\n randomSeed: randomSeed\n });\n\n const promise = new Promise((resolve, reject) => {\n // XXX It'd be better if we could hook into method handlers better but\n // for now, we need to check if the ddp-rate-limiter exists since we\n // have a weak requirement for the ddp-rate-limiter package to be added\n // to our application.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"method\",\n name: msg.method,\n connectionId: self.id\n };\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n if (!rateLimitResult.allowed) {\n reject(new Meteor.Error(\n \"too-many-requests\",\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset}\n ));\n return;\n }\n }\n\n resolve(DDPServer._CurrentWriteFence.withValue(\n fence,\n () => DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, msg.params,\n \"call to '\" + msg.method + \"'\"\n )\n )\n ));\n });\n\n function finish() {\n fence.arm();\n unblock();\n }\n\n const payload = {\n msg: \"result\",\n id: msg.id\n };\n\n promise.then((result) => {\n finish();\n if (result !== undefined) {\n payload.result = result;\n }\n self.send(payload);\n }, (exception) => {\n finish();\n payload.error = wrapInternalException(\n exception,\n `while invoking method '${msg.method}'`\n );\n self.send(payload);\n });\n }\n },\n\n _eachSub: function (f) {\n var self = this;\n self._namedSubs.forEach(f);\n self._universalSubs.forEach(f);\n },\n\n _diffCollectionViews: function (beforeCVs) {\n var self = this;\n DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n both: function (collectionName, leftValue, rightValue) {\n rightValue.diff(leftValue);\n },\n rightOnly: function (collectionName, rightValue) {\n rightValue.documents.forEach(function (docView, id) {\n self.sendAdded(collectionName, id, docView.getFields());\n });\n },\n leftOnly: function (collectionName, leftValue) {\n leftValue.documents.forEach(function (doc, id) {\n self.sendRemoved(collectionName, id);\n });\n }\n });\n },\n\n // Sets the current user id in all appropriate contexts and reruns\n // all subscriptions\n _setUserId: function(userId) {\n var self = this;\n\n if (userId !== null && typeof userId !== \"string\")\n throw new Error(\"setUserId must be called on string or null, not \" +\n typeof userId);\n\n // Prevent newly-created universal subscriptions from being added to our\n // session; they will be found below when we call startUniversalSubs.\n //\n // (We don't have to worry about named subscriptions, because we only add\n // them when we process a 'sub' message. We are currently processing a\n // 'method' message, and the method did not unblock, because it is illegal\n // to call setUserId after unblock. Thus we cannot be concurrently adding a\n // new named subscription.)\n self._dontStartNewUniversalSubs = true;\n\n // Prevent current subs from updating our collectionViews and call their\n // stop callbacks. This may yield.\n self._eachSub(function (sub) {\n sub._deactivate();\n });\n\n // All subs should now be deactivated. Stop sending messages to the client,\n // save the state of the published collections, reset to an empty view, and\n // update the userId.\n self._isSending = false;\n var beforeCVs = self.collectionViews;\n self.collectionViews = new Map();\n self.userId = userId;\n\n // _setUserId is normally called from a Meteor method with\n // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n // expected to be set inside a publish function, so we temporary unset it.\n // Inside a publish function DDP._CurrentPublicationInvocation is set.\n DDP._CurrentMethodInvocation.withValue(undefined, function () {\n // Save the old named subs, and reset to having no subscriptions.\n var oldNamedSubs = self._namedSubs;\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n oldNamedSubs.forEach(function (sub, subscriptionId) {\n var newSub = sub._recreate();\n self._namedSubs.set(subscriptionId, newSub);\n // nb: if the handler throws or calls this.error(), it will in fact\n // immediately send its 'nosub'. This is OK, though.\n newSub._runHandler();\n });\n\n // Allow newly-created universal subs to be started on our connection in\n // parallel with the ones we're spinning up here, and spin up universal\n // subs.\n self._dontStartNewUniversalSubs = false;\n self.startUniversalSubs();\n });\n\n // Start sending messages again, beginning with the diff from the previous\n // state of the world to the current state. No yields are allowed during\n // this diff, so that other changes cannot interleave.\n Meteor._noYieldsAllowed(function () {\n self._isSending = true;\n self._diffCollectionViews(beforeCVs);\n if (!_.isEmpty(self._pendingReady)) {\n self.sendReady(self._pendingReady);\n self._pendingReady = [];\n }\n });\n },\n\n _startSubscription: function (handler, subId, params, name) {\n var self = this;\n\n var sub = new Subscription(\n self, handler, subId, params, name);\n if (subId)\n self._namedSubs.set(subId, sub);\n else\n self._universalSubs.push(sub);\n\n sub._runHandler();\n },\n\n // tear down specified subscription\n _stopSubscription: function (subId, error) {\n var self = this;\n\n var subName = null;\n if (subId) {\n var maybeSub = self._namedSubs.get(subId);\n if (maybeSub) {\n subName = maybeSub._name;\n maybeSub._removeAllDocuments();\n maybeSub._deactivate();\n self._namedSubs.delete(subId);\n }\n }\n\n var response = {msg: 'nosub', id: subId};\n\n if (error) {\n response.error = wrapInternalException(\n error,\n subName ? (\"from sub \" + subName + \" id \" + subId)\n : (\"from sub id \" + subId));\n }\n\n self.send(response);\n },\n\n // tear down all subscriptions. Note that this does NOT send removed or nosub\n // messages, since we assume the client is gone.\n _deactivateAllSubscriptions: function () {\n var self = this;\n\n self._namedSubs.forEach(function (sub, id) {\n sub._deactivate();\n });\n self._namedSubs = new Map();\n\n self._universalSubs.forEach(function (sub) {\n sub._deactivate();\n });\n self._universalSubs = [];\n },\n\n // Determine the remote client's IP address, based on the\n // HTTP_FORWARDED_COUNT environment variable representing how many\n // proxies the server is behind.\n _clientAddress: function () {\n var self = this;\n\n // For the reported client address for a connection to be correct,\n // the developer must set the HTTP_FORWARDED_COUNT environment\n // variable to an integer representing the number of hops they\n // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n // server is behind one proxy.\n //\n // This could be computed once at startup instead of every time.\n var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n if (httpForwardedCount === 0)\n return self.socket.remoteAddress;\n\n var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n if (! _.isString(forwardedFor))\n return null;\n forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n // Typically the first value in the `x-forwarded-for` header is\n // the original IP address of the client connecting to the first\n // proxy. However, the end user can easily spoof the header, in\n // which case the first value(s) will be the fake IP address from\n // the user pretending to be a proxy reporting the original IP\n // address value. By counting HTTP_FORWARDED_COUNT back from the\n // end of the list, we ensure that we get the IP address being\n // reported by *our* first proxy.\n\n if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n return null;\n\n return forwardedFor[forwardedFor.length - httpForwardedCount];\n }\n});\n\n/******************************************************************************/\n/* Subscription */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n session, handler, subscriptionId, params, name) {\n var self = this;\n self._session = session; // type is Session\n\n /**\n * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n * @locus Server\n * @name connection\n * @memberOf Subscription\n * @instance\n */\n self.connection = session.connectionHandle; // public API object\n\n self._handler = handler;\n\n // my subscription ID (generated by client, undefined for universal subs).\n self._subscriptionId = subscriptionId;\n // undefined for universal subs\n self._name = name;\n\n self._params = params || [];\n\n // Only named subscriptions have IDs, but we need some sort of string\n // internally to keep track of all subscriptions inside\n // SessionDocumentViews. We use this subscriptionHandle for that.\n if (self._subscriptionId) {\n self._subscriptionHandle = 'N' + self._subscriptionId;\n } else {\n self._subscriptionHandle = 'U' + Random.id();\n }\n\n // has _deactivate been called?\n self._deactivated = false;\n\n // stop callbacks to g/c this sub. called w/ zero arguments.\n self._stopCallbacks = [];\n\n // the set of (collection, documentid) that this subscription has\n // an opinion about\n self._documents = new Map();\n\n // remember if we are ready.\n self._ready = false;\n\n // Part of the public API: the user of this sub.\n\n /**\n * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n * @locus Server\n * @memberOf Subscription\n * @name userId\n * @instance\n */\n self.userId = session.userId;\n\n // For now, the id filter is going to default to\n // the to/from DDP methods on MongoID, to\n // specifically deal with mongo/minimongo ObjectIds.\n\n // Later, you will be able to make this be \"raw\"\n // if you want to publish a collection that you know\n // just has strings for keys and no funny business, to\n // a ddp consumer that isn't minimongo\n\n self._idFilter = {\n idStringify: MongoID.idStringify,\n idParse: MongoID.idParse\n };\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n _runHandler: function () {\n // XXX should we unblock() here? Either before running the publish\n // function, or before running _publishCursor.\n //\n // Right now, each publish function blocks all future publishes and\n // methods waiting on data from Mongo (or whatever else the function\n // blocks on). This probably slows page load in common cases.\n\n var self = this;\n try {\n var res = DDP._CurrentPublicationInvocation.withValue(\n self,\n () => maybeAuditArgumentChecks(\n self._handler, self, EJSON.clone(self._params),\n // It's OK that this would look weird for universal subscriptions,\n // because they have no arguments so there can never be an\n // audit-argument-checks failure.\n \"publisher '\" + self._name + \"'\"\n )\n );\n } catch (e) {\n self.error(e);\n return;\n }\n\n // Did the handler call this.error or this.stop?\n if (self._isDeactivated())\n return;\n\n self._publishHandlerResult(res);\n },\n\n _publishHandlerResult: function (res) {\n // SPECIAL CASE: Instead of writing their own callbacks that invoke\n // this.added/changed/ready/etc, the user can just return a collection\n // cursor or array of cursors from the publish function; we call their\n // _publishCursor method which starts observing the cursor and publishes the\n // results. Note that _publishCursor does NOT call ready().\n //\n // XXX This uses an undocumented interface which only the Mongo cursor\n // interface publishes. Should we make this interface public and encourage\n // users to implement it themselves? Arguably, it's unnecessary; users can\n // already write their own functions like\n // var publishMyReactiveThingy = function (name, handler) {\n // Meteor.publish(name, function () {\n // var reactiveThingy = handler();\n // reactiveThingy.publishMe();\n // });\n // };\n\n var self = this;\n var isCursor = function (c) {\n return c && c._publishCursor;\n };\n if (isCursor(res)) {\n try {\n res._publishCursor(self);\n } catch (e) {\n self.error(e);\n return;\n }\n // _publishCursor only returns after the initial added callbacks have run.\n // mark subscription as ready.\n self.ready();\n } else if (_.isArray(res)) {\n // check all the elements are cursors\n if (! _.all(res, isCursor)) {\n self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n return;\n }\n // find duplicate collection names\n // XXX we should support overlapping cursors, but that would require the\n // merge box to allow overlap within a subscription\n var collectionNames = {};\n for (var i = 0; i < res.length; ++i) {\n var collectionName = res[i]._getCollectionName();\n if (_.has(collectionNames, collectionName)) {\n self.error(new Error(\n \"Publish function returned multiple cursors for collection \" +\n collectionName));\n return;\n }\n collectionNames[collectionName] = true;\n };\n\n try {\n _.each(res, function (cur) {\n cur._publishCursor(self);\n });\n } catch (e) {\n self.error(e);\n return;\n }\n self.ready();\n } else if (res) {\n // truthy values other than cursors or arrays are probably a\n // user mistake (possible returning a Mongo document via, say,\n // `coll.findOne()`).\n self.error(new Error(\"Publish function can only return a Cursor or \"\n + \"an array of Cursors\"));\n }\n },\n\n // This calls all stop callbacks and prevents the handler from updating any\n // SessionCollectionViews further. It's used when the user unsubscribes or\n // disconnects, as well as during setUserId re-runs. It does *NOT* send\n // removed messages for the published objects; if that is necessary, call\n // _removeAllDocuments first.\n _deactivate: function() {\n var self = this;\n if (self._deactivated)\n return;\n self._deactivated = true;\n self._callStopCallbacks();\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", -1);\n },\n\n _callStopCallbacks: function () {\n var self = this;\n // tell listeners, so they can clean up\n var callbacks = self._stopCallbacks;\n self._stopCallbacks = [];\n _.each(callbacks, function (callback) {\n callback();\n });\n },\n\n // Send remove messages for every document.\n _removeAllDocuments: function () {\n var self = this;\n Meteor._noYieldsAllowed(function () {\n self._documents.forEach(function (collectionDocs, collectionName) {\n collectionDocs.forEach(function (strId) {\n self.removed(collectionName, self._idFilter.idParse(strId));\n });\n });\n });\n },\n\n // Returns a new Subscription for the same session with the same\n // initial creation parameters. This isn't a clone: it doesn't have\n // the same _documents cache, stopped state or callbacks; may have a\n // different _subscriptionHandle, and gets its userId from the\n // session, not from this object.\n _recreate: function () {\n var self = this;\n return new Subscription(\n self._session, self._handler, self._subscriptionId, self._params,\n self._name);\n },\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n * @locus Server\n * @param {Error} error The error to pass to the client.\n * @instance\n * @memberOf Subscription\n */\n error: function (error) {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId, error);\n },\n\n // Note that while our DDP client will notice that you've called stop() on the\n // server (and clean up its _subscriptions table) we don't actually provide a\n // mechanism for an app to notice this (the subscribe onError callback only\n // triggers if there is an error).\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error.\n * @locus Server\n * @instance\n * @memberOf Subscription\n */\n stop: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId);\n },\n\n /**\n * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {Function} func The callback function\n */\n onStop: function (callback) {\n var self = this;\n callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n if (self._isDeactivated())\n callback();\n else\n self._stopCallbacks.push(callback);\n },\n\n // This returns true if the sub has been deactivated, *OR* if the session was\n // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n // happened yet.\n _isDeactivated: function () {\n var self = this;\n return self._deactivated || self._session.inQueue === null;\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the new document.\n * @param {String} id The new document's ID.\n * @param {Object} fields The fields in the new document. If `_id` is present it is ignored.\n */\n added: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n let ids = self._documents.get(collectionName);\n if (ids == null) {\n ids = new Set();\n self._documents.set(collectionName, ids);\n }\n ids.add(id);\n self._session.added(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the changed document.\n * @param {String} id The changed document's ID.\n * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored.\n */\n changed: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that the document has been removed from.\n * @param {String} id The ID of the document that has been removed.\n */\n removed: function (collectionName, id) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n // We don't bother to delete sets of things in a collection if the\n // collection is empty. It could break _removeAllDocuments.\n self._documents.get(collectionName).delete(id);\n self._session.removed(self._subscriptionHandle, collectionName, id);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any.\n * @locus Server\n * @memberOf Subscription\n * @instance\n */\n ready: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n if (!self._subscriptionId)\n return; // unnecessary but ignored for universal sub\n if (!self._ready) {\n self._session.sendReady([self._subscriptionId]);\n self._ready = true;\n }\n }\n});\n\n/******************************************************************************/\n/* Server */\n/******************************************************************************/\n\nServer = function (options) {\n var self = this;\n\n // The default heartbeat interval is 30 seconds on the server and 35\n // seconds on the client. Since the client doesn't need to send a\n // ping as long as it is receiving pings, this means that pings\n // normally go from the server to the client.\n //\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n self.options = _.defaults(options || {}, {\n heartbeatInterval: 15000,\n heartbeatTimeout: 15000,\n // For testing, allow responding to pings to be disabled.\n respondToPings: true\n });\n\n // Map of callbacks to call when a new connection comes in to the\n // server and completes DDP version negotiation. Use an object instead\n // of an array so we can safely remove one from the list while\n // iterating over it.\n self.onConnectionHook = new Hook({\n debugPrintExceptions: \"onConnection callback\"\n });\n\n // Map of callbacks to call when a new message comes in.\n self.onMessageHook = new Hook({\n debugPrintExceptions: \"onMessage callback\"\n });\n\n self.publish_handlers = {};\n self.universal_publish_handlers = [];\n\n self.method_handlers = {};\n\n self.sessions = new Map(); // map from id to session\n\n self.stream_server = new StreamServer;\n\n self.stream_server.register(function (socket) {\n // socket implements the SockJSConnection interface\n socket._meteorSession = null;\n\n var sendError = function (reason, offendingMessage) {\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n socket.send(DDPCommon.stringifyDDP(msg));\n };\n\n socket.on('data', function (raw_msg) {\n if (Meteor._printReceivedDDP) {\n Meteor._debug(\"Received DDP\", raw_msg);\n }\n try {\n try {\n var msg = DDPCommon.parseDDP(raw_msg);\n } catch (err) {\n sendError('Parse error');\n return;\n }\n if (msg === null || !msg.msg) {\n sendError('Bad request', msg);\n return;\n }\n\n if (msg.msg === 'connect') {\n if (socket._meteorSession) {\n sendError(\"Already connected\", msg);\n return;\n }\n Fiber(function () {\n self._handleConnect(socket, msg);\n }).run();\n return;\n }\n\n if (!socket._meteorSession) {\n sendError('Must connect first', msg);\n return;\n }\n socket._meteorSession.processMessage(msg);\n } catch (e) {\n // XXX print stack nicely\n Meteor._debug(\"Internal exception while processing message\", msg, e);\n }\n });\n\n socket.on('close', function () {\n if (socket._meteorSession) {\n Fiber(function () {\n socket._meteorSession.close();\n }).run();\n }\n });\n });\n};\n\n_.extend(Server.prototype, {\n\n /**\n * @summary Register a callback to be called when a new DDP connection is made to the server.\n * @locus Server\n * @param {function} callback The function to call when a new DDP connection is established.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onConnection: function (fn) {\n var self = this;\n return self.onConnectionHook.register(fn);\n },\n\n /**\n * @summary Register a callback to be called when a new DDP message is received.\n * @locus Server\n * @param {function} callback The function to call when a new DDP message is received.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onMessage: function (fn) {\n var self = this;\n return self.onMessageHook.register(fn);\n },\n\n _handleConnect: function (socket, msg) {\n var self = this;\n\n // The connect message must specify a version and an array of supported\n // versions, and it must claim to support what it is proposing.\n if (!(typeof (msg.version) === 'string' &&\n _.isArray(msg.support) &&\n _.all(msg.support, _.isString) &&\n _.contains(msg.support, msg.version))) {\n socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n socket.close();\n return;\n }\n\n // In the future, handle session resumption: something like:\n // socket._meteorSession = self.sessions[msg.session]\n var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n if (msg.version !== version) {\n // The best version to use (according to the client's stated preferences)\n // is not the one the client is trying to use. Inform them about the best\n // version to use.\n socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n socket.close();\n return;\n }\n\n // Yay, version matches! Create a new session.\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n socket._meteorSession = new Session(self, version, socket, self.options);\n self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n self.onConnectionHook.each(function (callback) {\n if (socket._meteorSession)\n callback(socket._meteorSession.connectionHandle);\n return true;\n });\n },\n /**\n * Register a publish handler function.\n *\n * @param name {String} identifier for query\n * @param handler {Function} publish handler\n * @param options {Object}\n *\n * Server will call handler function on each new subscription,\n * either when receiving DDP sub message for a named subscription, or on\n * DDP connect for a universal subscription.\n *\n * If name is null, this will be a subscription that is\n * automatically established and permanently on for all connected\n * client, instead of a subscription that can be turned on and off\n * with subscribe().\n *\n * options to contain:\n * - (mostly internal) is_auto: true if generated automatically\n * from an autopublish hook. this is for cosmetic purposes only\n * (it lets us determine whether to print a warning suggesting\n * that you turn off autopublish.)\n */\n\n /**\n * @summary Publish a record set.\n * @memberOf Meteor\n * @importFromPackage meteor\n * @locus Server\n * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments.\n */\n publish: function (name, handler, options) {\n var self = this;\n\n if (! _.isObject(name)) {\n options = options || {};\n\n if (name && name in self.publish_handlers) {\n Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n return;\n }\n\n if (Package.autopublish && !options.is_auto) {\n // They have autopublish on, yet they're trying to manually\n // picking stuff to publish. They probably should turn off\n // autopublish. (This check isn't perfect -- if you create a\n // publish before you turn on autopublish, it won't catch\n // it. But this will definitely handle the simple case where\n // you've added the autopublish package to your app, and are\n // calling publish from your app code.)\n if (!self.warned_about_autopublish) {\n self.warned_about_autopublish = true;\n Meteor._debug(\n \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n \"** will still be sent to all clients.\\n\" +\n \"**\\n\" +\n \"** Turn off autopublish by removing the autopublish package:\\n\" +\n \"**\\n\" +\n \"** $ meteor remove autopublish\\n\" +\n \"**\\n\" +\n \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n \"** for each collection that you want clients to see.\\n\");\n }\n }\n\n if (name)\n self.publish_handlers[name] = handler;\n else {\n self.universal_publish_handlers.push(handler);\n // Spin up the new publisher on any existing session too. Run each\n // session's subscription in a new Fiber, so that there's no change for\n // self.sessions to change while we're running this loop.\n self.sessions.forEach(function (session) {\n if (!session._dontStartNewUniversalSubs) {\n Fiber(function() {\n session._startSubscription(handler);\n }).run();\n }\n });\n }\n }\n else{\n _.each(name, function(value, key) {\n self.publish(key, value, {});\n });\n }\n },\n\n _removeSession: function (session) {\n var self = this;\n self.sessions.delete(session.id);\n },\n\n /**\n * @summary Defines functions that can be invoked over the network by clients.\n * @locus Anywhere\n * @param {Object} methods Dictionary whose keys are method names and values are functions.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n methods: function (methods) {\n var self = this;\n _.each(methods, function (func, name) {\n if (typeof func !== 'function')\n throw new Error(\"Method '\" + name + \"' must be a function\");\n if (self.method_handlers[name])\n throw new Error(\"A method named '\" + name + \"' is already defined\");\n self.method_handlers[name] = func;\n });\n },\n\n call: function (name, ...args) {\n if (args.length && typeof args[args.length - 1] === \"function\") {\n // If it's a function, the last argument is the result callback, not\n // a parameter to the remote method.\n var callback = args.pop();\n }\n\n return this.apply(name, args, callback);\n },\n\n // A version of the call method that always returns a Promise.\n callAsync: function (name, ...args) {\n return this.applyAsync(name, args);\n },\n\n apply: function (name, args, options, callback) {\n // We were passed 3 arguments. They may be either (name, args, options)\n // or (name, args, callback)\n if (! callback && typeof options === 'function') {\n callback = options;\n options = {};\n } else {\n options = options || {};\n }\n\n const promise = this.applyAsync(name, args, options);\n\n // Return the result in whichever way the caller asked for it. Note that we\n // do NOT block on the write fence in an analogous way to how the client\n // blocks on the relevant data being visible, so you are NOT guaranteed that\n // cursor observe callbacks have fired when your callback is invoked. (We\n // can change this if there's a real use case.)\n if (callback) {\n promise.then(\n result => callback(undefined, result),\n exception => callback(exception)\n );\n } else {\n return promise.await();\n }\n },\n\n // @param options {Optional Object}\n applyAsync: function (name, args, options) {\n // Run the handler\n var handler = this.method_handlers[name];\n if (! handler) {\n return Promise.reject(\n new Meteor.Error(404, `Method '${name}' not found`)\n );\n }\n\n // If this is a method call from within another method or publish function,\n // get the user state from the outer method or publish function, otherwise\n // don't allow setUserId to be called\n var userId = null;\n var setUserId = function() {\n throw new Error(\"Can't call setUserId on a server initiated method call\");\n };\n var connection = null;\n var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n var randomSeed = null;\n if (currentMethodInvocation) {\n userId = currentMethodInvocation.userId;\n setUserId = function(userId) {\n currentMethodInvocation.setUserId(userId);\n };\n connection = currentMethodInvocation.connection;\n randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n } else if (currentPublicationInvocation) {\n userId = currentPublicationInvocation.userId;\n setUserId = function(userId) {\n currentPublicationInvocation._session._setUserId(userId);\n };\n connection = currentPublicationInvocation.connection;\n }\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId,\n setUserId,\n connection,\n randomSeed\n });\n\n return new Promise(resolve => resolve(\n DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, EJSON.clone(args),\n \"internal call to '\" + name + \"'\"\n )\n )\n )).then(EJSON.clone);\n },\n\n _urlForSession: function (sessionId) {\n var self = this;\n var session = self.sessions.get(sessionId);\n if (session)\n return session._socketUrl;\n else\n return null;\n }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n serverSupportedVersions) {\n var correctVersion = _.find(clientSupportedVersions, function (version) {\n return _.contains(serverSupportedVersions, version);\n });\n if (!correctVersion) {\n correctVersion = serverSupportedVersions[0];\n }\n return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n if (!exception) return exception;\n\n // To allow packages to throw errors intended for the client but not have to\n // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n // error before it is thrown.\n if (exception.isClientSafe) {\n if (!(exception instanceof Meteor.Error)) {\n const originalMessage = exception.message;\n exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n exception.message = originalMessage;\n }\n return exception;\n }\n\n // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n // the server log.\n if (!exception._expectedByTest) {\n Meteor._debug(\"Exception \" + context, exception.stack);\n if (exception.sanitizedError) {\n Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n Meteor._debug();\n }\n }\n\n // Did the error contain more details that could have been useful if caught in\n // server code (or if thrown from non-client-originated code), but also\n // provided a \"sanitized\" version with more context than 500 Internal server\n // error? Use that.\n if (exception.sanitizedError) {\n if (exception.sanitizedError.isClientSafe)\n return exception.sanitizedError;\n Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n \"does not have isClientSafe property set; ignoring\");\n }\n\n return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n args = args || [];\n if (Package['audit-argument-checks']) {\n return Match._failIfArgumentsAreNotAllChecked(\n f, context, args, description);\n }\n return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n var self = this;\n\n self.armed = false;\n self.fired = false;\n self.retired = false;\n self.outstanding_writes = 0;\n self.before_fire_callbacks = [];\n self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n // Start tracking a write, and return an object to represent it. The\n // object has a single method, committed(). This method should be\n // called when the write is fully committed and propagated. You can\n // continue to add writes to the WriteFence up until it is triggered\n // (calls its callbacks because all writes have committed.)\n beginWrite: function () {\n var self = this;\n\n if (self.retired)\n return { committed: function () {} };\n\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to add writes\");\n\n self.outstanding_writes++;\n var committed = false;\n return {\n committed: function () {\n if (committed)\n throw new Error(\"committed called twice on the same write\");\n committed = true;\n self.outstanding_writes--;\n self._maybeFire();\n }\n };\n },\n\n // Arm the fence. Once the fence is armed, and there are no more\n // uncommitted writes, it will activate.\n arm: function () {\n var self = this;\n if (self === DDPServer._CurrentWriteFence.get())\n throw Error(\"Can't arm the current fence\");\n self.armed = true;\n self._maybeFire();\n },\n\n // Register a function to be called once before firing the fence.\n // Callback function can add new writes to the fence, in which case\n // it won't fire until those writes are done as well.\n onBeforeFire: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.before_fire_callbacks.push(func);\n },\n\n // Register a function to be called when the fence fires.\n onAllCommitted: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.completion_callbacks.push(func);\n },\n\n // Convenience function. Arms the fence, then blocks until it fires.\n armAndWait: function () {\n var self = this;\n var future = new Future;\n self.onAllCommitted(function () {\n future['return']();\n });\n self.arm();\n future.wait();\n },\n\n _maybeFire: function () {\n var self = this;\n if (self.fired)\n throw new Error(\"write fence already activated?\");\n if (self.armed && !self.outstanding_writes) {\n function invokeCallback (func) {\n try {\n func(self);\n } catch (err) {\n Meteor._debug(\"exception in write fence callback\", err);\n }\n }\n\n self.outstanding_writes++;\n while (self.before_fire_callbacks.length > 0) {\n var callbacks = self.before_fire_callbacks;\n self.before_fire_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n self.outstanding_writes--;\n\n if (!self.outstanding_writes) {\n self.fired = true;\n var callbacks = self.completion_callbacks;\n self.completion_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n }\n },\n\n // Deactivate this fence so that adding more writes has no effect.\n // The fence must have already fired.\n retire: function () {\n var self = this;\n if (! self.fired)\n throw new Error(\"Can't retire a fence that hasn't fired.\");\n self.retired = true;\n }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n var self = this;\n options = options || {};\n\n self.nextId = 1;\n // map from collection name (string) -> listener id -> object. each object has\n // keys 'trigger', 'callback'. As a hack, the empty string means \"no\n // collection\".\n self.listenersByCollection = {};\n self.listenersByCollectionCount = {};\n self.factPackage = options.factPackage || \"livedata\";\n self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n // msg is a trigger or a notification\n _collectionForMessage: function (msg) {\n var self = this;\n if (! _.has(msg, 'collection')) {\n return '';\n } else if (typeof(msg.collection) === 'string') {\n if (msg.collection === '')\n throw Error(\"Message has empty collection!\");\n return msg.collection;\n } else {\n throw Error(\"Message has non-string collection!\");\n }\n },\n\n // Listen for notification that match 'trigger'. A notification\n // matches if it has the key-value pairs in trigger as a\n // subset. When a notification matches, call 'callback', passing\n // the actual notification.\n //\n // Returns a listen handle, which is an object with a method\n // stop(). Call stop() to stop listening.\n //\n // XXX It should be legal to call fire() from inside a listen()\n // callback?\n listen: function (trigger, callback) {\n var self = this;\n var id = self.nextId++;\n\n var collection = self._collectionForMessage(trigger);\n var record = {trigger: EJSON.clone(trigger), callback: callback};\n if (! _.has(self.listenersByCollection, collection)) {\n self.listenersByCollection[collection] = {};\n self.listenersByCollectionCount[collection] = 0;\n }\n self.listenersByCollection[collection][id] = record;\n self.listenersByCollectionCount[collection]++;\n\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, 1);\n }\n\n return {\n stop: function () {\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, -1);\n }\n delete self.listenersByCollection[collection][id];\n self.listenersByCollectionCount[collection]--;\n if (self.listenersByCollectionCount[collection] === 0) {\n delete self.listenersByCollection[collection];\n delete self.listenersByCollectionCount[collection];\n }\n }\n };\n },\n\n // Fire the provided 'notification' (an object whose attribute\n // values are all JSON-compatibile) -- inform all matching listeners\n // (registered with listen()).\n //\n // If fire() is called inside a write fence, then each of the\n // listener callbacks will be called inside the write fence as well.\n //\n // The listeners may be invoked in parallel, rather than serially.\n fire: function (notification) {\n var self = this;\n\n var collection = self._collectionForMessage(notification);\n\n if (! _.has(self.listenersByCollection, collection)) {\n return;\n }\n\n var listenersForCollection = self.listenersByCollection[collection];\n var callbackIds = [];\n _.each(listenersForCollection, function (l, id) {\n if (self._matches(notification, l.trigger)) {\n callbackIds.push(id);\n }\n });\n\n // Listener callbacks can yield, so we need to first find all the ones that\n // match in a single iteration over self.listenersByCollection (which can't\n // be mutated during this iteration), and then invoke the matching\n // callbacks, checking before each call to ensure they haven't stopped.\n // Note that we don't have to check that\n // self.listenersByCollection[collection] still === listenersForCollection,\n // because the only way that stops being true is if listenersForCollection\n // first gets reduced down to the empty object (and then never gets\n // increased again).\n _.each(callbackIds, function (id) {\n if (_.has(listenersForCollection, id)) {\n listenersForCollection[id].callback(notification);\n }\n });\n },\n\n // A notification matches a trigger if all keys that exist in both are equal.\n //\n // Examples:\n // N:{collection: \"C\"} matches T:{collection: \"C\"}\n // (a non-targeted write to a collection matches a\n // non-targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n // (a targeted write to a collection matches a non-targeted query)\n // N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n // (a non-targeted write to a collection matches a\n // targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n // (a targeted write to a collection matches a targeted query targeted\n // at the same document)\n // N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n // (a targeted write to a collection does not match a targeted query\n // targeted at a different document)\n _matches: function (notification, trigger) {\n // Most notifications that use the crossbar have a string `collection` and\n // maybe an `id` that is a string or ObjectID. We're already dividing up\n // triggers by collection, but let's fast-track \"nope, different ID\" (and\n // avoid the overly generic EJSON.equals). This makes a noticeable\n // performance difference; see https://github.com/meteor/meteor/pull/3697\n if (typeof(notification.id) === 'string' &&\n typeof(trigger.id) === 'string' &&\n notification.id !== trigger.id) {\n return false;\n }\n if (notification.id instanceof MongoID.ObjectID &&\n trigger.id instanceof MongoID.ObjectID &&\n ! notification.id.equals(trigger.id)) {\n return false;\n }\n\n return _.all(trigger, function (triggerValue, key) {\n return !_.has(notification, key) ||\n EJSON.equals(triggerValue, notification[key]);\n });\n }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n function (name) {\n Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} \ No newline at end of file diff --git a/server/bundle/programs/server/packages/modules.js b/server/bundle/programs/server/packages/modules.js index 3827730c7f..895c268e35 100644 --- a/server/bundle/programs/server/packages/modules.js +++ b/server/bundle/programs/server/packages/modules.js @@ -463,7 +463,7 @@ module.useNode(); // module.exports = { "name": "@steedos/objectql", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "lib/index.js" }; @@ -490,7 +490,7 @@ module.useNode(); // module.exports = { "name": "@steedos/i18n", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "lib/index.js" }; @@ -517,7 +517,7 @@ module.useNode(); // module.exports = { "name": "@steedos/core", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "lib/index.js" }; @@ -544,7 +544,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-meteor-package-loader", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "index.js" }; @@ -571,7 +571,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-api", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "index.js" }; @@ -598,7 +598,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-metadata-server", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "index.js" }; @@ -625,7 +625,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-package-registry", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "package.service.js" }; @@ -652,7 +652,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-objectql", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "package.service.js" }; @@ -679,7 +679,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-ui", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "package.service.js" }; @@ -706,7 +706,7 @@ module.useNode(); // module.exports = { "name": "@steedos/service-pages", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "package.service.js" }; @@ -733,7 +733,7 @@ module.useNode(); // module.exports = { "name": "@steedos/router", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "lib/index.js" }; @@ -760,7 +760,7 @@ module.useNode(); // module.exports = { "name": "@steedos/auth", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "lib/index.js" }; @@ -787,7 +787,7 @@ module.useNode(); // module.exports = { "name": "@steedos/workflow", - "version": "2.7.4-beta.1", + "version": "2.7.4-beta.2", "main": "index.js" }; diff --git a/server/bundle/programs/web.browser.legacy/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js b/server/bundle/programs/web.browser.legacy/7d27de16d6eab9175efa4d52871e8cc6588f4811.js similarity index 99% rename from server/bundle/programs/web.browser.legacy/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js rename to server/bundle/programs/web.browser.legacy/7d27de16d6eab9175efa4d52871e8cc6588f4811.js index a92b7b4af7..3947c05c4c 100644 --- a/server/bundle/programs/web.browser.legacy/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js +++ b/server/bundle/programs/web.browser.legacy/7d27de16d6eab9175efa4d52871e8cc6588f4811.js @@ -68,7 +68,7 @@ object-assign * Copyright 2011-2019 Twitter, Inc. * Licensed under the MIT license */ -if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(jQuery),function(e){"use strict";function t(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var n in t)if(void 0!==e.style[n])return{end:t[n]};return!1}e.fn.emulateTransitionEnd=function(t){var n=!1,r=this,i;return e(this).one("bsTransitionEnd",(function(){n=!0})),setTimeout((function(){n||e(r).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=t(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(jQuery),function(e){"use strict";var t='[data-dismiss="alert"]',n=function(n){e(n).on("click",t,this.close)};function r(t){return this.each((function(){var r=e(this),i=r.data("bs.alert");i||r.data("bs.alert",i=new n(this)),"string"==typeof t&&i[t].call(r)}))}n.VERSION="3.4.1",n.TRANSITION_DURATION=150,n.prototype.close=function(t){var r=e(this),i=r.attr("data-target");i||(i=(i=r.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=e(document).find(i);function s(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=r.closest(".alert")),o.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),e.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",s).emulateTransitionEnd(n.TRANSITION_DURATION):s())};var i=e.fn.alert;e.fn.alert=r,e.fn.alert.Constructor=n,e.fn.alert.noConflict=function(){return e.fn.alert=i,this},e(document).on("click.bs.alert.data-api",t,n.prototype.close)}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.isLoading=!1};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.button"),o="object"==typeof n&&n;i||r.data("bs.button",i=new t(this,o)),"toggle"==n?i.toggle():n&&i.setState(n)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var n="disabled",r=this.$element,i=r.is("input")?"val":"html",o=r.data();t+="Text",null==o.resetText&&r.data("resetText",r[i]()),setTimeout(e.proxy((function(){r[i](null==o[t]?this.options[t]:o[t]),"loadingText"==t?(this.isLoading=!0,r.addClass(n).attr(n,n).prop(n,!0)):this.isLoading&&(this.isLoading=!1,r.removeClass(n).removeAttr(n).prop(n,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var n=this.$element.find("input");"radio"==n.prop("type")?(n.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==n.prop("type")&&(n.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),n.prop("checked",this.$element.hasClass("active")),e&&n.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var r=e.fn.button;e.fn.button=n,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=r,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var r=e(t.target).closest(".btn");n.call(r,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),r.is("input,button")?r.trigger("focus"):r.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(jQuery),function(e){"use strict";var t=function(t,n){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=n,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.carousel"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n),s="string"==typeof n?n:o.slide;i||r.data("bs.carousel",i=new t(this,o)),"number"==typeof n?i.to(n):s?i[s]():o.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var n=this.getItemIndex(t),r;if(("prev"==e&&0===n||"next"==e&&n==this.$items.length-1)&&!this.options.wrap)return t;var i,o=(n+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(o)},t.prototype.to=function(e){var t=this,n=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):n==e?this.pause().cycle():this.slide(e>n?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(n,r){var i=this.$element.find(".item.active"),o=r||this.getItemForDirection(n,i),s=this.interval,a="next"==n?"left":"right",u=this;if(o.hasClass("active"))return this.sliding=!1;var f=o[0],c=e.Event("slide.bs.carousel",{relatedTarget:f,direction:a});if(this.$element.trigger(c),!c.isDefaultPrevented()){if(this.sliding=!0,s&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var l=e(this.$indicators.children()[this.getItemIndex(o)]);l&&l.addClass("active")}var h=e.Event("slid.bs.carousel",{relatedTarget:f,direction:a});return e.support.transition&&this.$element.hasClass("slide")?(o.addClass(n),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(a),o.addClass(a),i.one("bsTransitionEnd",(function(){o.removeClass([n,a].join(" ")).addClass("active"),i.removeClass(["active",a].join(" ")),u.sliding=!1,setTimeout((function(){u.$element.trigger(h)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(h)),s&&this.cycle(),this}};var r=e.fn.carousel;e.fn.carousel=n,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=r,this};var i=function(t){var r=e(this),i=r.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=r.attr("data-target")||i,s=e(document).find(o);if(s.hasClass("carousel")){var a=e.extend({},s.data(),r.data()),u=r.attr("data-slide-to");u&&(a.interval=!1),n.call(s,a),u&&s.data("bs.carousel").to(u),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);n.call(t,t.data())}))}))}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.$trigger=e('[data-toggle="collapse"][href="#'+n.id+'"],[data-toggle="collapse"][data-target="#'+n.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var n,r=t.attr("data-target")||(n=t.attr("href"))&&n.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(r)}function r(n){return this.each((function(){var r=e(this),i=r.data("bs.collapse"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n);!i&&o.toggle&&/show|hide/.test(n)&&(o.toggle=!1),i||r.data("bs.collapse",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){var e;return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var n,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(n=i.data("bs.collapse"))&&n.transitioning)){var o=e.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){i&&i.length&&(r.call(i,"hide"),n||i.data("bs.collapse",null));var s=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[s](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var a=function(){this.$element.removeClass("collapsing").addClass("collapse in")[s](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return a.call(this);var u=e.camelCase(["scroll",s].join("-"));this.$element.one("bsTransitionEnd",e.proxy(a,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[s](this.$element[0][u])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var n=e.Event("hide.bs.collapse");if(this.$element.trigger(n),!n.isDefaultPrevented()){var r=this.dimension();this.$element[r](this.$element[r]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[r](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,r){var i=e(r);this.addAriaAndCollapsedClass(n(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var n=e.hasClass("in");e.attr("aria-expanded",n),t.toggleClass("collapsed",!n).attr("aria-expanded",n)};var i=e.fn.collapse;e.fn.collapse=r,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var o=n(i),s,a=o.data("bs.collapse")?"toggle":i.data();r.call(o,a)}))}(jQuery),function(e){"use strict";var t=".dropdown-backdrop",n='[data-toggle="dropdown"]',r=function(t){e(t).on("click.bs.dropdown",this.toggle)};function i(t){var n=t.attr("data-target");n||(n=(n=t.attr("href"))&&/#[A-Za-z]/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,""));var r="#"!==n?e(document).find(n):null;return r&&r.length?r:t.parent()}function o(r){r&&3===r.which||(e(t).remove(),e(n).each((function(){var t=e(this),n=i(t),o={relatedTarget:this};n.hasClass("open")&&(r&&"click"==r.type&&/input|textarea/i.test(r.target.tagName)&&e.contains(n[0],r.target)||(n.trigger(r=e.Event("hide.bs.dropdown",o)),r.isDefaultPrevented()||(t.attr("aria-expanded","false"),n.removeClass("open").trigger(e.Event("hidden.bs.dropdown",o)))))})))}function s(t){return this.each((function(){var n=e(this),i=n.data("bs.dropdown");i||n.data("bs.dropdown",i=new r(this)),"string"==typeof t&&i[t].call(n)}))}r.VERSION="3.4.1",r.prototype.toggle=function(t){var n=e(this);if(!n.is(".disabled, :disabled")){var r=i(n),s=r.hasClass("open");if(o(),!s){"ontouchstart"in document.documentElement&&!r.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",o);var a={relatedTarget:this};if(r.trigger(t=e.Event("show.bs.dropdown",a)),t.isDefaultPrevented())return;n.trigger("focus").attr("aria-expanded","true"),r.toggleClass("open").trigger(e.Event("shown.bs.dropdown",a))}return!1}},r.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var r=e(this);if(t.preventDefault(),t.stopPropagation(),!r.is(".disabled, :disabled")){var o=i(r),s=o.hasClass("open");if(!s&&27!=t.which||s&&27==t.which)return 27==t.which&&o.find(n).trigger("focus"),r.trigger("click");var a=" li:not(.disabled):visible a",u=o.find(".dropdown-menu"+a);if(u.length){var f=u.index(t.target);38==t.which&&f>0&&f--,40==t.which&&fdocument.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},f.prototype.init=function(t,n,r){if(this.enabled=!0,this.type=t,this.$element=e(n),this.options=this.getOptions(r),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),o=i.length;o--;){var s=i[o];if("click"==s)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=s){var a="hover"==s?"mouseenter":"focusin",u="hover"==s?"mouseleave":"focusout";this.$element.on(a+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(u+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},f.prototype.getDefaults=function(){return f.DEFAULTS},f.prototype.getOptions=function(n){var r=this.$element.data();for(var i in r)r.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete r[i];return(n=e.extend({},this.getDefaults(),r,n)).delay&&"number"==typeof n.delay&&(n.delay={show:n.delay,hide:n.delay}),n.sanitize&&(n.template=u(n.template,n.whiteList,n.sanitizeFn)),n},f.prototype.getDelegateOptions=function(){var t={},n=this.getDefaults();return this._options&&e.each(this._options,(function(e,r){n[e]!=r&&(t[e]=r)})),t},f.prototype.enter=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusin"==t.type?"focus":"hover"]=!0),n.tip().hasClass("in")||"in"==n.hoverState)n.hoverState="in";else{if(clearTimeout(n.timeout),n.hoverState="in",!n.options.delay||!n.options.delay.show)return n.show();n.timeout=setTimeout((function(){"in"==n.hoverState&&n.show()}),n.options.delay.show)}},f.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},f.prototype.leave=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusout"==t.type?"focus":"hover"]=!1),!n.isInStateTrue()){if(clearTimeout(n.timeout),n.hoverState="out",!n.options.delay||!n.options.delay.hide)return n.hide();n.timeout=setTimeout((function(){"out"==n.hoverState&&n.hide()}),n.options.delay.hide)}},f.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var n=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!n)return;var r=this,i=this.tip(),o=this.getUID(this.type);this.setContent(),i.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&i.addClass("fade");var s="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,a=/\s?auto?\s?/i,u=a.test(s);u&&(s=s.replace(a,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(s).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var c=this.getPosition(),l=i[0].offsetWidth,h=i[0].offsetHeight;if(u){var d=s,p=this.getPosition(this.$viewport);s="bottom"==s&&c.bottom+h>p.bottom?"top":"top"==s&&c.top-hp.width?"left":"left"==s&&c.left-ls.top+s.height&&(i.top=s.top+s.height-u)}else{var f=t.left-o,c=t.left+o+n;fs.right&&(i.left=s.left+s.width-c)}return i},f.prototype.getTitle=function(){var e,t=this.$element,n=this.options;return e=t.attr("data-original-title")||("function"==typeof n.title?n.title.call(t[0]):n.title)},f.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},f.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},f.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},f.prototype.enable=function(){this.enabled=!0},f.prototype.disable=function(){this.enabled=!1},f.prototype.toggleEnabled=function(){this.enabled=!this.enabled},f.prototype.toggle=function(t){var n=this;t&&((n=e(t.currentTarget).data("bs."+this.type))||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n))),t?(n.inState.click=!n.inState.click,n.isInStateTrue()?n.enter(n):n.leave(n)):n.tip().hasClass("in")?n.leave(n):n.enter(n)},f.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},f.prototype.sanitizeHtml=function(e){return u(e,this.options.whiteList,this.options.sanitizeFn)};var l=e.fn.tooltip;e.fn.tooltip=c,e.fn.tooltip.Constructor=f,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=l,this}}(jQuery),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");function n(n){return this.each((function(){var r=e(this),i=r.data("bs.popover"),o="object"==typeof n&&n;!i&&/destroy|hide/.test(n)||(i||r.data("bs.popover",i=new t(this,o)),"string"==typeof n&&i[n]())}))}t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:''}),t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype),t.prototype.constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),n=this.getContent();if(this.options.html){var r=typeof n;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===r&&(n=this.sanitizeHtml(n))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===r?"html":"append"](n)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(n);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var r=e.fn.popover;e.fn.popover=n,e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=r,this}}(jQuery),function(e){"use strict";function t(n,r){this.$body=e(document.body),this.$scrollElement=e(n).is(document.body)?e(window):e(n),this.options=e.extend({},t.DEFAULTS,r),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function n(n){return this.each((function(){var r=e(this),i=r.data("bs.scrollspy"),o="object"==typeof n&&n;i||r.data("bs.scrollspy",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,n="offset",r=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(n="position",r=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),o=/^#./.test(i)&&e(i);return o&&o.length&&o.is(":visible")&&[[o[n]().top+r,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.getScrollHeight(),n=this.options.offset+t-this.$scrollElement.height(),r=this.offsets,i=this.targets,o=this.activeTarget,s;if(this.scrollHeight!=t&&this.refresh(),e>=n)return o!=(s=i[i.length-1])&&this.activate(s);if(o&&e=r[s]&&(void 0===r[s+1]||e .active"),s=i&&e.support.transition&&(o.length&&o.hasClass("fade")||!!r.find("> .fade").length);function a(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),n.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),s?(n[0].offsetWidth,n.addClass("in")):n.removeClass("fade"),n.parent(".dropdown-menu").length&&n.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&s?o.one("bsTransitionEnd",a).emulateTransitionEnd(t.TRANSITION_DURATION):a(),o.removeClass("in")};var r=e.fn.tab;e.fn.tab=n,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=r,this};var i=function(t){t.preventDefault(),n.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(e){"use strict";var t=function(n,r){this.options=e.extend({},t.DEFAULTS,r);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(n),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.affix"),o="object"==typeof n&&n;i||r.data("bs.affix",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,n,r){var i=this.$target.scrollTop(),o=this.$element.offset(),s=this.$target.height();if(null!=n&&"top"==this.affixed)return i=e-r&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),n=this.$element.offset();return this.pinnedOffset=n.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var n=this.$element.height(),r=this.options.offset,i=r.top,o=r.bottom,s=Math.max(e(document).height(),e(document.body).height());"object"!=typeof r&&(o=i=r),"function"==typeof i&&(i=r.top(this.$element)),"function"==typeof o&&(o=r.bottom(this.$element));var a=this.getState(s,n,i,o);if(this.affixed!=a){null!=this.unpin&&this.$element.css("top","");var u="affix"+(a?"-"+a:""),f=e.Event(u+".bs.affix");if(this.$element.trigger(f),f.isDefaultPrevented())return;this.affixed=a,this.unpin="bottom"==a?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(u).trigger(u.replace("affix","affixed")+".bs.affix")}"bottom"==a&&this.$element.offset({top:s-n-o})}};var r=e.fn.affix;e.fn.affix=n,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=r,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),r=t.data();r.offset=r.offset||{},null!=r.offsetBottom&&(r.offset.bottom=r.offsetBottom),null!=r.offsetTop&&(r.offset.top=r.offsetTop),n.call(t,r)}))}))}(jQuery)}}}},fibers:{"package.json":function e(t,n,e){e.exports={name:"fibers",version:"5.0.3",main:"fibers"}},"fibers.js":function e(t,n,e,r,i){if(process.fiberLib)e.exports=process.fiberLib;else{var o=t("fs"),s=t("path"),a=t("detect-libc");Math.random();var u=s.join(i,"bin",process.platform+"-"+process.arch+"-"+process.versions.modules+("linux"===process.platform?"-"+a.family:""),"fibers");try{process.fiberLib=e.exports=t(u).Fiber}catch(c){throw console.error("## There is an issue with `node-fibers` ##\n`"+u+".node` is missing.\n\nTry running this to fix the issue: "+process.execPath+" "+i.replace(" ","\\ ")+"/build"),console.error(c.stack||c.message||c),new Error("Missing binary. See message above.")}f(e.exports)}function f(e){try{var t=process.binding("async_wrap"),n;if(t.asyncIdStackSize instanceof Function)n=t.asyncIdStackSize;else{if(void 0===t.constants.kStackLength)throw new Error("Couldn't figure out how to get async stack size");l=t.constants.kStackLength,n=function(){return t.async_hook_fields[l]}}var r=t.popAsyncContext||t.popAsyncIds,i=t.pushAsyncContext||t.pushAsyncIds,o,s;if(!r||!i)throw new Error("Push/pop do not exist");o=void 0===t.constants.kExecutionAsyncId?t.constants.kCurrentAsyncId:t.constants.kExecutionAsyncId,s=void 0===t.constants.kTriggerAsyncId?t.constants.kCurrentTriggerId:t.constants.kTriggerAsyncId;var a=t.async_id_fields||t.async_uid_fields;function u(){for(var e=n(),t=new Array(e);e>0;--e){var i=a[o];t[e-1]={asyncId:i,triggerId:a[s]},r(i)}return t}function f(e){for(var t=0;t0)i.changeLanguage(e,r);else if(0!=a[u]){a[u]=0;var f=new XMLHttpRequest;f.overrideMimeType("application/json"),f.open("GET",u,!1),f.send(null),200===f.status?a[u]=1:a[u]=-1,n.addResourceBundle(e,s,JSON.parse(f.response)||{}),i.changeLanguage(e,r)}};n.changeLanguage=p;var g=function(e,t,n){return i.format(e,t,n)};n.format=g;var b=function(){return i.languages};n.getLanguages=b;var m=function(e,t){return i.loadLanguages(e,t)};n.loadLanguages=m;var v=function(e,t){return i.loadNamespaces(e,t)};n.loadNamespaces=v;var y=function(e,t){return i.on(e,t)};n.on=y;var _=function(e,t){return i.off(e,t)};n.off=_,r.__exportStar(t("./i18n/i18n"),n),r.__exportStar(t("./i18n/i18n.app"),n),r.__exportStar(t("./translations"),n)},i18n:{"i18n.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.fallbackKeys=n.getObjectI18nTemplate=n.translationI18nObjects=n.addObjectsI18n=n.translationI18nObject=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="_",a="base",u="core",f="translation",c=function(e,t){var n={lng:t,ns:f};if((0,r.exists)(e,n))return(0,r._t)(e,n)},l=function(e){return"".concat(e,"__object")},h=function(e,t){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t)},d=function(e,t){var n=h(e,t);return"".concat(n).concat("_","inlineHelpText")},p=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","group").concat("_").concat(n)},g=function(e,t,n){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t).concat("_","options").concat("_").concat(n)},b=function(e,t){return"".concat(e).concat("_","action").concat("_").concat(t)},m=function(e,t){return"".concat(e).concat("_","listview").concat("_").concat(t)},v=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},y=function(e,t,n){var r=l(t);return c(r,e)||n||""},_=function(e,t,n,r,i){var o=h(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=_(e,a,n,r,i))}return s||r||""},w=function(e,t,n,r,i){var o=d(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=w(e,a,n,r,i))}return s||r||""},k=function(e,t,n,r){var i=p(t,n);return c(i,e)||r||""},j=function(e,t,n,r,i,o){var s=g(t,n,r),a=c(s,e);if(!a){var u=v(o);u&&"base"!=t&&"core"!=t&&(a=j(e,u,n,r,i,o))}return a||i||""},x=function(e,t,n,r,i){var o=b(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=x(e,a,n,r,i))}return s||r||""},S=function(e,t,n,r,i){var o=m(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=S(e,a,n,r,i))}return s||r||""},D=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},E=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;return e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(D(e))}))):n.push(D(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},A=function(e,t,n){n.label=y(e,t,n.label),i.each(n.fields,(function(r,o){if(r.label=_(e,t,o,r.label,n.datasource),r.inlineHelpText&&(r.inlineHelpText=w(e,t,o,r.inlineHelpText,n.datasource)),r.group&&(r.group=k(e,t,r.group,r.group)),r.options){var s=[];i.each(r.options,(function(r){if(i.has(r,"value")){var a=j(e,t,o,r.value,r.label,n.datasource);s.push(i.extend({},r,{label:a}))}else s.push(r)})),r.options=s}})),i.each(n.actions,(function(r,i){r.label=x(e,t,i,r.label,n.datasource)})),i.each(n.list_views,(function(r,i){r.label=S(e,t,i,r.label,n.datasource)}))};n.translationI18nObject=A;var C=function(e){i.each(e,(function(e){(0,r.addResourceBundle)(e.lng,f,e.data,!0,!0)}))};n.addObjectsI18n=C;var M=function(e,t){i.each(t,(function(t,r){(0,n.translationI18nObject)(e,r,t)}))};n.translationI18nObjects=M;var O=function(e,t,n){var r=o(n);E(r);var s={};return s[l(t)]=y(e,t,r.label),i.each(r.fields,(function(n,o){s[h(t,o)]=_(e,t,o,n.label),n.inlineHelpText&&(s[d(t,o)]=w(e,t,o,n.inlineHelpText,r.datasource)),n.group&&(s[p(t,n.group)]=k(e,t,n.group,n.group)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[g(t,o,n.value)]=j(e,t,o,n.value,n.label))}))})),i.each(r.actions,(function(n,r){s[b(t,r)]=x(e,t,r,n.label)})),i.each(r.list_views,(function(n,r){s[m(t,r)]=S(e,t,r,n.label)})),s};n.getObjectI18nTemplate=O,n.fallbackKeys={getObjectLabelKey:l,getObjectFieldLabelKey:h,getObjectFieldInlineHelpTextLabelKey:d,getObjectFieldGroupKey:p,getObjectFieldOptionsLabelKey:g,getObjectActionLabelKey:b,getObjectListviewLabelKey:m}},"i18n.app.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.appFallbackKeys=n.getAppI18nTemplate=n.translationI18nApps=n.translationI18nMenus=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="translation",a="_",u=function(e,t){var n={lng:t,ns:s};if((0,r.exists)(e,n))return(0,r._t)(e,n)},f=function(e){return"app".concat("_").concat(e).concat("_","name")},c=function(e){return"app".concat("_").concat(e).concat("_","description")},l=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","tab_group").concat("_").concat(n)},h=function(e){return"menu".concat("_").concat(e)},d=function(e){return"tab".concat("_").concat(e)},p=function(e,t,n){var r=f(t);return u(r,e)||n||""},g=function(e,t,n){var r=c(t);return u(r,e)||n||""},b=function(e,t,n){var r=h(t);return u(r,e)||n||""},m=function(e,t,r){r.label=p(e,t,r.label||r.name),r.description=g(e,t,r.description),(0,n.translationI18nMenus)(e,r.admin_menus)},v=function(e,t){i.each(t,(function(t){var n=b(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationI18nMenus=v;var y=function(e,t){i.each(t,(function(t,n){m(e,n,t)}))};n.translationI18nApps=y;var _=function(e,t,n){var r=o(n),s={};return s[f(t)]=p(e,t,r.label||r.name),s[c(t)]=g(e,t,r.description),i.each(r.admin_menus,(function(t){s[h(t._id)]=b(e,t._id,t.label||t.name)})),s};n.getAppI18nTemplate=_,n.appFallbackKeys={getAppLabelKey:f,getAppDescriptionKey:c,getAppGroupKey:l,getMenuLabelKey:h,getTabKey:d}}},translations:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.SteedosTranslationPrefixKeys=n.convertObject=void 0;var r=t("tslib"),i=t("underscore");r.__exportStar(t("./objectTranslation"),n),r.__exportStar(t("./translation"),n),r.__exportStar(t("./templates/objectTranslation"),n),r.__exportStar(t("./templates/translation"),n);var o=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},s=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(o(e))}))):n.push(o(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else if(e.options&&i.isArray(e.options))try{i.forEach(e.options,(function(e){i.isString(e)?n.push(o(e)):n.push(e)})),e.options=n}catch(r){console.error("Creator.convertFieldsOptions",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},a;n.convertObject=s,function(e){e.Object="CustomObject",e.Field="CustomField",e.Action="CustomAction",e.Listview="CustomListview",e.Permission="CustomPermission",e.ValidationRule="CustomValidationRule",e.Application="CustomApplication",e.Tab="CustomTabs",e.Permissionset="CustomPermissionset",e.Profile="CustomProfile",e.Report="CustomReport",e.Workflow="Workflow",e.Layout="Layout",e.Client="Client",e.Server="Server",e.Function="Function",e.Router="Router",e.Trigger="Trigger"}(a=n.SteedosTranslationPrefixKeys||(n.SteedosTranslationPrefixKeys={}))},"objectTranslation.js":function e(t,n,e,r){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addObjectsTranslation=n.getObjectTranslationTemplate=n.translationObjects=n.translationObject=n.translationObjectLabel=void 0;var i=t("underscore"),o=t("./"),s=t("../index"),a=t("./index"),u=t("../i18n/i18n"),f=t("lodash"),c=t("crypto"),l,h=(0,t("@steedos/cachers").getCacher)("lru.translations.objects");function d(e){var t;return c.createHash("md5").update(e).digest("hex")}var p=function(e,t){return"".concat(e,"_").concat(t.name,"_").concat(d(JSON.stringify(t)))},g=t("clone"),b=".",m="base",v="core",y="translation",_="object",w="field",k="listview",j="action",x=function(e,t){var n={lng:t,ns:y,keySeparator:!1};if((0,s.exists)(e,n))return(0,s._t)(e,n)},S=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},D=function(e){switch(e){case"object":return o.SteedosTranslationPrefixKeys.Object;case"field":return o.SteedosTranslationPrefixKeys.Field;case"listview":return o.SteedosTranslationPrefixKeys.Listview;case"action":return o.SteedosTranslationPrefixKeys.Action;default:return"CustomLabels"}},E=function(e){var t;return[D(),e].join(".")},A=function(e){var t;return[D("object"),e,"label"].join(".")},C=function(e){var t;return[D("object"),e,"description"].join(".")},M=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"label"].join(".")},O=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"help"].join(".")},T=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"description"].join(".")},B=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_"),r;return[D("field"),e,"group",n].join(".")},I=function(e,t,n){var r;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"options",n].join(".")},R=function(e,t){var n;return[D("action"),e,t].join(".")},F=function(e,t){var n;return[D("listview"),e,t].join(".")},P=function(e,t,n){var r,i=[A(t)],o=u.fallbackKeys.getObjectLabelKey(t);return o&&i.push(o),x(i,e)||n||""};n.translationObjectLabel=P;var N=function(e,t,n){var r=C(t);return x(r,e)||n||""},L=function(e,t,n,r,i,o){var s,a=[M(t,n)],f=u.fallbackKeys.getObjectFieldLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=L(e,l,n,r,i))}return c||r||""},z=function(e,t,n,r,i,o){var s,a=[O(t,n)],f=u.fallbackKeys.getObjectFieldInlineHelpTextLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=z(e,l,n,r,i))}return c||r||""},U=function(e,t,n,r,i,o){var s=T(t,n),a,u=x([s],e);if(1!=o&&!u){var f=S(i);f&&"base"!=t&&"core"!=t&&(u=U(e,f,n,r,i))}return u||r||""},q=function(e,t,n,r,i,o){var s,a=[B(t,n)],f=u.fallbackKeys.getObjectFieldGroupKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=q(e,l,n,r,i))}return c||r||""},$=function(e,t,n,r,i,o,s){var a,f=[I(t,n,r)],c=u.fallbackKeys.getObjectFieldOptionsLabelKey(t,n,r);c&&f.push(c);var l=x(f,e);if(1!=s&&!l){var h=S(o);h&&"base"!=t&&"core"!=t&&(l=$(e,h,n,r,i,o))}return l||i||""},W=function(e,t,n,r,i,o){var s,a=[R(t,n)],f=u.fallbackKeys.getObjectActionLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=W(e,l,n,r,i))}return c||r||""},H=function(e,t,n,r,i,o){var s,a=[F(t,n)],f=u.fallbackKeys.getObjectListviewLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=H(e,l,n,r,i))}return c||r||""},Y=function(e,t,r,o,s){void 0===s&&(s=!1);var u=p(e,r),c=h.get(u);if(c)return Object.assign(r,(0,f.cloneDeep)(c));o&&(0,a.convertObject)(r),r.label=(0,n.translationObjectLabel)(e,t,r.label),r.description=N(e,t,r.description),i.each(r.fields,(function(n,o){if(n.label=L(e,t,o,n.label,r.datasource,s),n.inlineHelpText=z(e,t,o,n.inlineHelpText,r.datasource,s),n.description=U(e,t,o,n.description,r.datasource,s),n.group&&(n.group=q(e,t,n.group,n.group,r.datasource,s)),n.options){var a=[];i.each(n.options,(function(n){if(i.has(n,"value")){var u=$(e,t,o,n.value,n.label,r.datasource,s);a.push(i.extend({},n,{label:u}))}else a.push(n)})),n.options=a}})),i.each(r.actions,(function(n,i){n.label=W(e,t,i,n.label,r.datasource,s)})),i.each(r.list_views,(function(n,i){n.label=H(e,t,i,n.label,r.datasource,s)})),h.set(u,(0,f.cloneDeep)(r))};n.translationObject=Y;var V=function(e,t){i.each(t,(function(t,r){(0,n.translationObject)(e,r,t)}))};n.translationObjects=V;var K=function(e,t,r){var o=g(r);(0,a.convertObject)(o);var s={};return s[A(t)]=(0,n.translationObjectLabel)(e,t,o.label),s[C(t)]=N(e,t,o.description),i.each(o.fields,(function(n,r){s[M(t,r)]=L(e,t,r,n.label),n.inlineHelpText&&(s[O(t,r)]=z(e,t,r,n.inlineHelpText,o.datasource)),n.description&&(s[T(t,r)]=U(e,t,r,n.description,o.datasource)),n.group&&(s[B(t,n.group)]=q(e,t,n.group,n.group,o.datasource)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[I(t,r,n.value)]=$(e,t,r,n.value,n.label))}))})),i.each(o.actions,(function(n,r){s[R(t,r)]=W(e,t,r,n.label)})),i.each(o.list_views,(function(n,r){s[F(t,r)]=H(e,t,r,n.label)})),s};function G(e,t){var n=g(e);(0,a.convertObject)(n);var r={},o=n.name;return o||console.error("Error: Invalid objectTranslation:"+t),r[A(o)]=n.label,r[C(o)]=n.description,i.each(n.fields,(function(e,t){r[M(o,t)]=e.label,e.help&&(r[O(o,t)]=e.help),e.description&&(r[T(o,t)]=e.description),e.options&&i.each(e.options,(function(e){i.has(e,"value")&&(r[I(o,t,e.value)]=e.label)}))})),i.each(n.groups,(function(e,t){r[B(o,t)]=e})),i.each(n.actions,(function(e,t){r[R(o,t)]=e.label})),i.each(n.listviews,(function(e,t){r[F(o,t)]=e.label})),i.each(n.CustomLabels,(function(e,t){r[E(t)]=e})),r}n.getObjectTranslationTemplate=K;var X=function(e){i.each(e,(function(e){var t=G(e.data,e.__filename);(0,s.addResourceBundle)(e.lng,y,t,!0,!0)}))};n.addObjectsTranslation=X},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addTranslations=n.convertTranslation=n.convertTranslationData=n.getAppTranslationTemplate=n.translationApps=n.translationMenus=n.translationApp=n.translationTabLabel=n.translationTabGroup=void 0;var r=t("../index"),i=t("underscore"),o=t("./"),s=t("../i18n/i18n.app"),a=t("clone"),u="translation",f=".",c="app",l="menu",h="tab",d=function(e){switch(e){case"app":return o.SteedosTranslationPrefixKeys.Application;case"tab":return o.SteedosTranslationPrefixKeys.Tab;default:return"CustomLabels"}},p=function(e){var t;return[d(),e].join(".")},g=function(e,t){var n={lng:t,ns:u,keySeparator:!1};if((0,r.exists)(e,n))return(0,r._t)(e,n)},b=function(e){var t;return[d("app"),e,"name"].join(".")},m=function(e){var t;return[d("app"),e,"description"].join(".")},v=function(e,t){var n,r;return[d("app"),e,"groups",t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_")].join(".")},y=function(e){var t;return[d("menu"),"menu_".concat(e)].join(".")},_=function(e){var t;return[d("tab"),e].join(".")},w=function(e,t,n){var r,i=[b(t)],o=s.appFallbackKeys.getAppLabelKey(t);return o&&i.push(o),g(i,e)||n||""},k=function(e,t,n){var r,i=[m(t)],o=s.appFallbackKeys.getAppDescriptionKey(t);return o&&i.push(o),g(i,e)||n||""},j=function(e,t,n,r){var i,o=[v(t,n)],a=s.appFallbackKeys.getAppGroupKey(t,n);return a&&o.push(a),g(o,e)||r||""};n.translationTabGroup=j;var x=function(e,t,n){var r,i=[y(t)],o=s.appFallbackKeys.getMenuLabelKey(t);return o&&i.push(o),g(i,e)||n||""},S=function(e,t,n){var r,i=[_(t)],o=s.appFallbackKeys.getTabKey(t);return o&&i.push(o),g(i,e)||n||""};n.translationTabLabel=S;var D=function(e,t,r){r.label=w(e,t,r.label||r.name),r.description=k(e,t,r.description),i.each(r.tab_groups,(function(i,o){r.tab_groups[o].id=i.id||i.group_name,r.tab_groups[o].group_name=(0,n.translationTabGroup)(e,t,i.group_name,i.group_name)})),(0,n.translationMenus)(e,r.admin_menus)};n.translationApp=D;var E=function(e,t){i.each(t,(function(t){var n=x(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationMenus=E;var A=function(e,t){i.each(t,(function(t,r){(0,n.translationApp)(e,r,t)}))};n.translationApps=A;var C=function(e,t,n){var r=a(n),o={};return o[b(t)]=w(e,t,r.label||r.name),o[m(t)]=k(e,t,r.description),i.each(r.admin_menus,(function(t){o[y(t._id)]=x(e,t._id,t.label||t.name)})),o};n.getAppTranslationTemplate=C;var M=function(e,t,n){i.isArray(n)?i.each(n,(function(e){M(e,"",e)})):n&&i.each(i.keys(n),(function(r){var o=t?"".concat(t,".").concat(r):r,s=n[r];"object"==typeof s?i.isArray(s)?i.each(s,(function(e){M(e,o,s)})):M(e,o,s):e[o]=s}))};function O(e){for(var t in e)"object"==typeof e[t]&&M(e,t,e[t]);return e}n.convertTranslationData=O;var T=function(e){var t=a(e),n={};return i.each(t.CustomApplications,(function(e,t){n[b(t)]=e.name,n[m(t)]=e.description,i.each(e.groups,(function(e,r){n[v(t,r)]=e}))})),i.each(t.CustomTabs,(function(e,t){n[_(t)]=e})),i.each(t.CustomLabels,(function(e,t){var r;if("simpleschema"!=t&&i.isObject(e)){var o=O(((r={})[t]=e,r));i.each(o,(function(e,t){i.isObject(e)||(n[p(t)]=e)}))}else n[p(t)]=e})),n};n.convertTranslation=T;var B=function(e){i.each(e,(function(e){var t=(0,n.convertTranslation)(e.data);(0,r.addResourceBundle)(e.lng,u,t,!0,!0)}))};n.addTranslations=B},templates:{"objectTranslation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getObjectMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]="help"===e?t.inlineHelpText||"":t[e]||""})),n}function a(e){return s(["label","description"],e)}function u(e){switch(e.type){case"select":return s(["label","help","options","description"],e);default:return s(["label","help","description"],e)}}function f(e){return s(["label"],e)}function c(e){return s(["label"],e)}function l(e){var t={};return r.each(e,(function(e,n){t[n]=u(e)})),t}function h(e){var t={};return r.each(e,(function(e,n){t[n]=c(e)})),t}function d(e){var t={};return r.each(e,(function(e,n){t[n]=f(e)})),t}function p(e,t){var n={};return r.each(e,(function(e,r){if(e.group){var i=e.group.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");n[i]=t[r].group}})),n}var g=function(e,t,n,s){void 0===s&&(s=!1);var u=o(n);1!=s&&(0,i.translationObject)(e,t,u,!0,s);var f=Object.assign({},a(u));f=Object.assign({},f,{fields:l(u.fields)});var c=p(n.fields,u.fields);r.isEmpty(c)||(f=Object.assign({},f,{groups:c}));var g=d(u.list_views);r.isEmpty(g)||(f=Object.assign({},f,{listviews:g}));var b=h(u.actions);return r.isEmpty(b)||(f=Object.assign({},f,{actions:b})),Object.assign({name:t},f)};n.getObjectMetadataTranslationTemplate=g},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getAppMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]=t[e]||""})),n}function a(e){var t={groups:{}};return e?(r.each(e,(function(e){var n=e.group_name.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t.groups[n]=e.group_name})),t):{}}var u=function(e){return Object.assign({},s(["name","description"],e),a(e.tab_groups))},f=function(e){var t={};return r.each(e,(function(e,n){t[n]=n})),t},c=function(e){var t={};return r.each(e,(function(e){var n=e.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t[n]=e})),t},l=function(e,t,n){var r,s=o(n);(0,i.translationApp)(e,t,s);var a={},l;return s.tab_items?a=f(s.tab_items):s.tabs&&(a=c(s.tabs)),Object.assign({},{CustomApplications:(r={},r[t]=u(s),r)},{CustomTabs:a})};n.getAppMetadataTranslationTemplate=l}}}},node_modules:{i18next:{"package.json":function e(t,n,e){e.exports={name:"i18next",version:"19.9.2",module:"./dist/esm/i18next.js",main:"./dist/cjs/i18next.js"}},dist:{esm:{"i18next.js":function e(t,n,e){let r,i,o,s,a,u,f,c;e.link("@babel/runtime/helpers/esm/typeof",{default(e){r=e}},0),e.link("@babel/runtime/helpers/esm/objectSpread",{default(e){i=e}},1),e.link("@babel/runtime/helpers/esm/classCallCheck",{default(e){o=e}},2),e.link("@babel/runtime/helpers/esm/createClass",{default(e){s=e}},3),e.link("@babel/runtime/helpers/esm/possibleConstructorReturn",{default(e){a=e}},4),e.link("@babel/runtime/helpers/esm/getPrototypeOf",{default(e){u=e}},5),e.link("@babel/runtime/helpers/esm/assertThisInitialized",{default(e){f=e}},6),e.link("@babel/runtime/helpers/esm/inherits",{default(e){c=e}},7);var l={type:"logger",log:function e(t){this.output("log",t)},warn:function e(t){this.output("warn",t)},error:function e(t){this.output("error",t)},output:function e(t,n){console&&console[t]&&console[t].apply(console,n)}},h,d=new(function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.init(t,n)}return s(e,[{key:"init",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=n.prefix||"i18next:",this.logger=t||l,this.options=n,this.debug=n.debug}},{key:"setDebug",value:function e(t){this.debug=t}},{key:"log",value:function e(){for(var t=arguments.length,n=new Array(t),r=0;r1?n-1:0),i=1;i-1?e.replace(/###/g,"."):e}function i(){return!e||"string"==typeof e}for(var o="string"!=typeof t?[].concat(t):t.split(".");o.length>1;){if(i())return{};var s=r(o.shift());!e[s]&&n&&(e[s]=new n),e=Object.prototype.hasOwnProperty.call(e,s)?e[s]:{}}return i()?{}:{obj:e,k:r(o.shift())}}function y(e,t,n){var r=v(e,t,Object),i,o;r.obj[r.k]=n}function _(e,t,n,r){var i=v(e,t,Object),o=i.obj,s=i.k;o[s]=o[s]||[],r&&(o[s]=o[s].concat(n)),r||o[s].push(n)}function w(e,t){var n=v(e,t),r=n.obj,i=n.k;if(r)return r[i]}function k(e,t,n){var r=w(e,n);return void 0!==r?r:w(t,n)}function j(e,t,n){for(var r in t)"__proto__"!==r&&"constructor"!==r&&(r in e?"string"==typeof e[r]||e[r]instanceof String||"string"==typeof t[r]||t[r]instanceof String?n&&(e[r]=t[r]):j(e[r],t[r],n):e[r]=t[r]);return e}function x(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var S={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};function D(e){return"string"==typeof e?e.replace(/[&<>"'\/]/g,(function(e){return S[e]})):e}var E="undefined"!=typeof window&&window.navigator&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,A=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),n.data=e||{},n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n}return c(t,e),s(t,[{key:"addNamespaces",value:function e(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function e(t){var n=this.options.ns.indexOf(t);n>-1&&this.options.ns.splice(n,1)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==i.keySeparator?i.keySeparator:this.options.keySeparator,s=[t,n];return r&&"string"!=typeof r&&(s=s.concat(r)),r&&"string"==typeof r&&(s=s.concat(o?r.split(o):r)),t.indexOf(".")>-1&&(s=t.split(".")),w(this.data,s)}},{key:"addResource",value:function e(t,n,r,i){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},s=this.options.keySeparator;void 0===s&&(s=".");var a=[t,n];r&&(a=a.concat(s?r.split(s):r)),t.indexOf(".")>-1&&(i=n,n=(a=t.split("."))[1]),this.addNamespaces(n),y(this.data,a,i),o.silent||this.emit("added",t,n,r,i)}},{key:"addResources",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in r)"string"!=typeof r[o]&&"[object Array]"!==Object.prototype.toString.apply(r[o])||this.addResource(t,n,o,r[o],{silent:!0});i.silent||this.emit("added",t,n,r)}},{key:"addResourceBundle",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},u=[t,n];t.indexOf(".")>-1&&(o=r,r=n,n=(u=t.split("."))[1]),this.addNamespaces(n);var f=w(this.data,u)||{};o?j(f,r,s):f=i({},f,r),y(this.data,u,f),a.silent||this.emit("added",t,n,r)}},{key:"removeResourceBundle",value:function e(t,n){this.hasResourceBundle(t,n)&&delete this.data[t][n],this.removeNamespaces(n),this.emit("removed",t,n)}},{key:"hasResourceBundle",value:function e(t,n){return void 0!==this.getResource(t,n)}},{key:"getResourceBundle",value:function e(t,n){return n||(n=this.options.defaultNS),"v1"===this.options.compatibilityAPI?i({},{},this.getResource(t,n)):this.getResource(t,n)}},{key:"getDataByLanguage",value:function e(t){return this.data[t]}},{key:"toJSON",value:function e(){return this.data}}]),t}(p),C={processors:{},addPostProcessor:function e(t){this.processors[t.name]=t},handle:function e(t,n,r,i,o){var s=this;return t.forEach((function(e){s.processors[e]&&(n=s.processors[e].process(n,r,i,o))})),n}},M={},O=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),m(["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],e,f(n)),n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n.logger=d.create("translator"),n}return c(t,e),s(t,[{key:"changeLanguage",value:function e(t){t&&(this.language=t)}},{key:"exists",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}},r=this.resolve(t,n);return r&&void 0!==r.res}},{key:"extractFromKey",value:function e(t,n){var r=void 0!==n.nsSeparator?n.nsSeparator:this.options.nsSeparator;void 0===r&&(r=":");var i=void 0!==n.keySeparator?n.keySeparator:this.options.keySeparator,o=n.ns||this.options.defaultNS;if(r&&t.indexOf(r)>-1){var s=t.match(this.interpolator.nestingRegexp);if(s&&s.length>0)return{key:t,namespaces:o};var a=t.split(r);(r!==i||r===i&&this.options.ns.indexOf(a[0])>-1)&&(o=a.shift()),t=a.join(i)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function e(n,o,s){var a=this;if("object"!==r(o)&&this.options.overloadTranslationOptionHandler&&(o=this.options.overloadTranslationOptionHandler(arguments)),o||(o={}),null==n)return"";Array.isArray(n)||(n=[String(n)]);var u=void 0!==o.keySeparator?o.keySeparator:this.options.keySeparator,f=this.extractFromKey(n[n.length-1],o),c=f.key,l=f.namespaces,h=l[l.length-1],d=o.lng||this.language,p=o.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(d&&"cimode"===d.toLowerCase()){if(p){var g=o.nsSeparator||this.options.nsSeparator;return h+g+c}return c}var b=this.resolve(n,o),m=b&&b.res,v=b&&b.usedKey||c,y=b&&b.exactUsedKey||c,_=Object.prototype.toString.apply(m),w=["[object Number]","[object Function]","[object RegExp]"],k=void 0!==o.joinArrays?o.joinArrays:this.options.joinArrays,j=!this.i18nFormat||this.i18nFormat.handleAsObject,x="string"!=typeof m&&"boolean"!=typeof m&&"number"!=typeof m;if(j&&m&&x&&w.indexOf(_)<0&&("string"!=typeof k||"[object Array]"!==_)){if(!o.returnObjects&&!this.options.returnObjects)return this.logger.warn("accessing an object - but returnObjects options is not enabled!"),this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,m,o):"key '".concat(c," (").concat(this.language,")' returned an object instead of string.");if(u){var S="[object Array]"===_,D=S?[]:{},E=S?y:v;for(var A in m)if(Object.prototype.hasOwnProperty.call(m,A)){var C="".concat(E).concat(u).concat(A);D[A]=this.translate(C,i({},o,{joinArrays:!1,ns:l})),D[A]===C&&(D[A]=m[A])}m=D}}else if(j&&"string"==typeof k&&"[object Array]"===_)(m=m.join(k))&&(m=this.extendTranslation(m,n,o,s));else{var M=!1,O=!1,T=void 0!==o.count&&"string"!=typeof o.count,B=t.hasDefaultValue(o),I=T?this.pluralResolver.getSuffix(d,o.count):"",R=o["defaultValue".concat(I)]||o.defaultValue;!this.isValidLookup(m)&&B&&(M=!0,m=R),this.isValidLookup(m)||(O=!0,m=c);var F=B&&R!==m&&this.options.updateMissing;if(O||M||F){if(this.logger.log(F?"updateKey":"missingKey",d,h,c,F?R:m),u){var P=this.resolve(c,i({},o,{keySeparator:!1}));P&&P.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var N=[],L=this.languageUtils.getFallbackCodes(this.options.fallbackLng,o.lng||this.language);if("fallback"===this.options.saveMissingTo&&L&&L[0])for(var z=0;z1&&void 0!==arguments[1]?arguments[1]:{},i,o,s,a,u;return"string"==typeof t&&(t=[t]),t.forEach((function(e){if(!n.isValidLookup(i)){var t=n.extractFromKey(e,r),f=t.key;o=f;var c=t.namespaces;n.options.fallbackNS&&(c=c.concat(n.options.fallbackNS));var l=void 0!==r.count&&"string"!=typeof r.count,h=void 0!==r.context&&"string"==typeof r.context&&""!==r.context,d=r.lngs?r.lngs:n.languageUtils.toResolveHierarchy(r.lng||n.language,r.fallbackLng);c.forEach((function(e){n.isValidLookup(i)||(u=e,!M["".concat(d[0],"-").concat(e)]&&n.utils&&n.utils.hasLoadedNamespace&&!n.utils.hasLoadedNamespace(u)&&(M["".concat(d[0],"-").concat(e)]=!0,n.logger.warn('key "'.concat(o,'" for languages "').concat(d.join(", "),'" won\'t get resolved as namespace "').concat(u,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),d.forEach((function(t){if(!n.isValidLookup(i)){a=t;var o=f,u=[o],c,d;if(n.i18nFormat&&n.i18nFormat.addLookupKeys)n.i18nFormat.addLookupKeys(u,f,t,e,r);else l&&(c=n.pluralResolver.getSuffix(t,r.count)),l&&h&&u.push(o+c),h&&u.push(o+="".concat(n.options.contextSeparator).concat(r.context)),l&&u.push(o+=c);for(;d=u.pop();)n.isValidLookup(i)||(s=d,i=n.getResource(t,e,d,r))}})))}))}})),{res:i,usedKey:o,exactUsedKey:s,usedLng:a,usedNS:u}}},{key:"isValidLookup",value:function e(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,n,r,i):this.resourceStore.getResource(t,n,r,i)}}],[{key:"hasDefaultValue",value:function e(t){var n="defaultValue";for(var r in t)if(Object.prototype.hasOwnProperty.call(t,r)&&n===r.substring(0,n.length)&&void 0!==t[r])return!0;return!1}}]),t}(p);function T(e){return e.charAt(0).toUpperCase()+e.slice(1)}var B=function(){function e(t){o(this,e),this.options=t,this.whitelist=this.options.supportedLngs||!1,this.supportedLngs=this.options.supportedLngs||!1,this.logger=d.create("languageUtils")}return s(e,[{key:"getScriptPartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return null;var n=t.split("-");return 2===n.length?null:(n.pop(),"x"===n[n.length-1].toLowerCase()?null:this.formatLanguageCode(n.join("-")))}},{key:"getLanguagePartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return t;var n=t.split("-");return this.formatLanguageCode(n[0])}},{key:"formatLanguageCode",value:function e(t){if("string"==typeof t&&t.indexOf("-")>-1){var n=["hans","hant","latn","cyrl","cans","mong","arab"],r=t.split("-");return this.options.lowerCaseLng?r=r.map((function(e){return e.toLowerCase()})):2===r.length?(r[0]=r[0].toLowerCase(),r[1]=r[1].toUpperCase(),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase()))):3===r.length&&(r[0]=r[0].toLowerCase(),2===r[1].length&&(r[1]=r[1].toUpperCase()),"sgn"!==r[0]&&2===r[2].length&&(r[2]=r[2].toUpperCase()),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase())),n.indexOf(r[2].toLowerCase())>-1&&(r[2]=T(r[2].toLowerCase()))),r.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isWhitelisted",value:function e(t){return this.logger.deprecate("languageUtils.isWhitelisted",'function "isWhitelisted" will be renamed to "isSupportedCode" in the next major - please make sure to rename it\'s usage asap.'),this.isSupportedCode(t)}},{key:"isSupportedCode",value:function e(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function e(t){var n=this,r;return t?(t.forEach((function(e){if(!r){var t=n.formatLanguageCode(e);n.options.supportedLngs&&!n.isSupportedCode(t)||(r=t)}})),!r&&this.options.supportedLngs&&t.forEach((function(e){if(!r){var t=n.getLanguagePartFromCode(e);if(n.isSupportedCode(t))return r=t;r=n.options.supportedLngs.find((function(e){if(0===e.indexOf(t))return e}))}})),r||(r=this.getFallbackCodes(this.options.fallbackLng)[0]),r):null}},{key:"getFallbackCodes",value:function e(t,n){if(!t)return[];if("function"==typeof t&&(t=t(n)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!n)return t.default||[];var r=t[n];return r||(r=t[this.getScriptPartFromCode(n)]),r||(r=t[this.formatLanguageCode(n)]),r||(r=t[this.getLanguagePartFromCode(n)]),r||(r=t.default),r||[]}},{key:"toResolveHierarchy",value:function e(t,n){var r=this,i=this.getFallbackCodes(n||this.options.fallbackLng||[],t),o=[],s=function e(t){t&&(r.isSupportedCode(t)?o.push(t):r.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&s(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&s(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&s(this.getLanguagePartFromCode(t))):"string"==typeof t&&s(this.formatLanguageCode(t)),i.forEach((function(e){o.indexOf(e)<0&&s(r.formatLanguageCode(e))})),o}}]),e}(),I=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","kk","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],R={1:function e(t){return Number(t>1)},2:function e(t){return Number(1!=t)},3:function e(t){return 0},4:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function e(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function e(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function e(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function e(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function e(t){return Number(t>=2)},10:function e(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function e(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function e(t){return Number(t%10!=1||t%100==11)},13:function e(t){return Number(0!==t)},14:function e(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function e(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function e(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function e(t){return Number(0==t?0:1==t?1:2)},19:function e(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function e(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function e(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function e(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}};function F(){var e={};return I.forEach((function(t){t.lngs.forEach((function(n){e[n]={numbers:t.nr,plurals:R[t.fc]}}))})),e}var P=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.languageUtils=t,this.options=n,this.logger=d.create("pluralResolver"),this.rules=F()}return s(e,[{key:"addRule",value:function e(t,n){this.rules[t]=n}},{key:"getRule",value:function e(t){return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function e(t){var n=this.getRule(t);return n&&n.numbers.length>1}},{key:"getPluralFormsOfKey",value:function e(t,n){return this.getSuffixes(t).map((function(e){return n+e}))}},{key:"getSuffixes",value:function e(t){var n=this,r=this.getRule(t);return r?r.numbers.map((function(e){return n.getSuffix(t,e)})):[]}},{key:"getSuffix",value:function e(t,n){var r=this,i=this.getRule(t);if(i){var o=i.noAbs?i.plurals(n):i.plurals(Math.abs(n)),s=i.numbers[o];this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]&&(2===s?s="plural":1===s&&(s=""));var a=function e(){return r.options.prepend&&s.toString()?r.options.prepend+s.toString():s.toString()};return"v1"===this.options.compatibilityJSON?1===s?"":"number"==typeof s?"_plural_".concat(s.toString()):a():"v2"===this.options.compatibilityJSON?a():this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]?a():this.options.prepend&&o.toString()?this.options.prepend+o.toString():o.toString()}return this.logger.warn("no plural rule found for: ".concat(t)),""}}]),e}(),N=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};o(this,e),this.logger=d.create("interpolator"),this.options=t,this.format=t.interpolation&&t.interpolation.format||function(e){return e},this.init(t)}return s(e,[{key:"init",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var n=t.interpolation;this.escape=void 0!==n.escape?n.escape:D,this.escapeValue=void 0===n.escapeValue||n.escapeValue,this.useRawValueToEscape=void 0!==n.useRawValueToEscape&&n.useRawValueToEscape,this.prefix=n.prefix?x(n.prefix):n.prefixEscaped||"{{",this.suffix=n.suffix?x(n.suffix):n.suffixEscaped||"}}",this.formatSeparator=n.formatSeparator?n.formatSeparator:n.formatSeparator||",",this.unescapePrefix=n.unescapeSuffix?"":n.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":n.unescapeSuffix||"",this.nestingPrefix=n.nestingPrefix?x(n.nestingPrefix):n.nestingPrefixEscaped||x("$t("),this.nestingSuffix=n.nestingSuffix?x(n.nestingSuffix):n.nestingSuffixEscaped||x(")"),this.nestingOptionsSeparator=n.nestingOptionsSeparator?n.nestingOptionsSeparator:n.nestingOptionsSeparator||",",this.maxReplaces=n.maxReplaces?n.maxReplaces:1e3,this.alwaysFormat=void 0!==n.alwaysFormat&&n.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function e(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function e(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var n="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(n,"g");var r="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(r,"g")}},{key:"interpolate",value:function e(t,n,r,i){var o=this,s,a,u,f=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function c(e){return e.replace(/\$/g,"$$$$")}var l=function e(t){if(t.indexOf(o.formatSeparator)<0){var s=k(n,f,t);return o.alwaysFormat?o.format(s,void 0,r):s}var a=t.split(o.formatSeparator),u=a.shift().trim(),c=a.join(o.formatSeparator).trim();return o.format(k(n,f,u),c,r,i)};this.resetRegExp();var h=i&&i.missingInterpolationHandler||this.options.missingInterpolationHandler,d=i&&i.interpolation&&i.interpolation.skipOnVariables||this.options.interpolation.skipOnVariables,p;return[{regex:this.regexpUnescape,safeValue:function e(t){return c(t)}},{regex:this.regexp,safeValue:function e(t){return o.escapeValue?c(o.escape(t)):c(t)}}].forEach((function(e){for(u=0;s=e.regex.exec(t);){if(void 0===(a=l(s[1].trim())))if("function"==typeof h){var n=h(t,s,i);a="string"==typeof n?n:""}else{if(d){a=s[0];continue}o.logger.warn("missed to pass in variable ".concat(s[1]," for interpolating ").concat(t)),a=""}else"string"==typeof a||o.useRawValueToEscape||(a=b(a));if(t=t.replace(s[0],e.safeValue(a)),e.regex.lastIndex=0,++u>=o.maxReplaces)break}})),t}},{key:"nest",value:function e(t,n){var r=this,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},s,a,u=i({},o);function f(e,t){var n=this.nestingOptionsSeparator;if(e.indexOf(n)<0)return e;var r=e.split(new RegExp("".concat(n,"[ ]*{"))),o="{".concat(r[1]);e=r[0],o=(o=this.interpolate(o,u)).replace(/'/g,'"');try{u=JSON.parse(o),t&&(u=i({},t,u))}catch(s){return this.logger.warn("failed parsing options string in nesting for key ".concat(e),s),"".concat(e).concat(n).concat(o)}return delete u.defaultValue,e}for(u.applyPostProcessor=!1,delete u.defaultValue;s=this.nestingRegexp.exec(t);){var c=[],l=!1;if(s[0].includes(this.formatSeparator)&&!/{.*}/.test(s[1])){var h=s[1].split(this.formatSeparator).map((function(e){return e.trim()}));s[1]=h.shift(),c=h,l=!0}if((a=n(f.call(this,s[1].trim(),u),u))&&s[0]===t&&"string"!=typeof a)return a;"string"!=typeof a&&(a=b(a)),a||(this.logger.warn("missed to resolve ".concat(s[1]," for nesting ").concat(t)),a=""),l&&(a=c.reduce((function(e,t){return r.format(e,t,o.lng,o)}),a.trim())),t=t.replace(s[0],a),this.regexp.lastIndex=0}return t}}]),e}();function L(e,t){for(var n=e.indexOf(t);-1!==n;)e.splice(n,1),n=e.indexOf(t)}var z=function(e){function t(e,n,r){var i,s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return o(this,t),i=a(this,u(t).call(this)),E&&p.call(f(i)),i.backend=e,i.store=n,i.services=r,i.languageUtils=r.languageUtils,i.options=s,i.logger=d.create("backendConnector"),i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(r,s.backend,s),i}return c(t,e),s(t,[{key:"queueLoad",value:function e(t,n,r,i){var o=this,s=[],a=[],u=[],f=[];return t.forEach((function(e){var t=!0;n.forEach((function(n){var i="".concat(e,"|").concat(n);!r.reload&&o.store.hasResourceBundle(e,n)?o.state[i]=2:o.state[i]<0||(1===o.state[i]?a.indexOf(i)<0&&a.push(i):(o.state[i]=1,t=!1,a.indexOf(i)<0&&a.push(i),s.indexOf(i)<0&&s.push(i),f.indexOf(n)<0&&f.push(n)))})),t||u.push(e)})),(s.length||a.length)&&this.queue.push({pending:a,loaded:{},errors:[],callback:i}),{toLoad:s,pending:a,toLoadLanguages:u,toLoadNamespaces:f}}},{key:"loaded",value:function e(t,n,r){var i=t.split("|"),o=i[0],s=i[1];n&&this.emit("failedLoading",o,s,n),r&&this.store.addResourceBundle(o,s,r),this.state[t]=n?-1:2;var e={};this.queue.forEach((function(r){_(r.loaded,[o],s),L(r.pending,t),n&&r.errors.push(n),0!==r.pending.length||r.done||(Object.keys(r.loaded).forEach((function(t){e[t]||(e[t]=[]),r.loaded[t].length&&r.loaded[t].forEach((function(n){e[t].indexOf(n)<0&&e[t].push(n)}))})),r.done=!0,r.errors.length?r.callback(r.errors):r.callback())})),this.emit("loaded",e),this.queue=this.queue.filter((function(e){return!e.done}))}},{key:"read",value:function e(t,n,r){var i=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:350,a=arguments.length>5?arguments[5]:void 0;return t.length?this.backend[r](t,n,(function(e,u){e&&u&&o<5?setTimeout((function(){i.read.call(i,t,n,r,o+1,2*s,a)}),s):a(e,u)})):a(null,{})}},{key:"prepareLoading",value:function e(t,n){var r=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof n&&(n=[n]);var s=this.queueLoad(t,n,i,o);if(!s.toLoad.length)return s.pending.length||o(),null;s.toLoad.forEach((function(e){r.loadOne(e)}))}},{key:"load",value:function e(t,n,r){this.prepareLoading(t,n,{},r)}},{key:"reload",value:function e(t,n,r){this.prepareLoading(t,n,{reload:!0},r)}},{key:"loadOne",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=t.split("|"),o=i[0],s=i[1];this.read(o,s,"read",void 0,void 0,(function(e,i){e&&n.logger.warn("".concat(r,"loading namespace ").concat(s," for language ").concat(o," failed"),e),!e&&i&&n.logger.log("".concat(r,"loaded namespace ").concat(s," for language ").concat(o),i),n.loaded(t,e,i)}))}},{key:"saveMissing",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(n)?this.logger.warn('did not save key "'.concat(r,'" as the namespace "').concat(n,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=r&&""!==r&&(this.backend&&this.backend.create&&this.backend.create(t,n,r,o,null,i({},a,{isUpdate:s})),t&&t[0]&&this.store.addResource(t[0],n,r,o))}}]),t}(p);function U(){return{debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,whitelist:!1,nonExplicitWhitelist:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function e(t){var n={};if("object"===r(t[1])&&(n=t[1]),"string"==typeof t[1]&&(n.defaultValue=t[1]),"string"==typeof t[2]&&(n.tDescription=t[2]),"object"===r(t[2])||"object"===r(t[3])){var i=t[3]||t[2];Object.keys(i).forEach((function(e){n[e]=i[e]}))}return n},interpolation:{escapeValue:!0,format:function e(t,n,r,i){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!1}}}function q(e){return"string"==typeof e.ns&&(e.ns=[e.ns]),"string"==typeof e.fallbackLng&&(e.fallbackLng=[e.fallbackLng]),"string"==typeof e.fallbackNS&&(e.fallbackNS=[e.fallbackNS]),e.whitelist&&(e.whitelist&&e.whitelist.indexOf("cimode")<0&&(e.whitelist=e.whitelist.concat(["cimode"])),e.supportedLngs=e.whitelist),e.nonExplicitWhitelist&&(e.nonExplicitSupportedLngs=e.nonExplicitWhitelist),e.supportedLngs&&e.supportedLngs.indexOf("cimode")<0&&(e.supportedLngs=e.supportedLngs.concat(["cimode"])),e}function $(){}var W,H=new(function(e){function t(){var e,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;if(o(this,t),e=a(this,u(t).call(this)),E&&p.call(f(e)),e.options=q(n),e.services={},e.logger=d,e.modules={external:[]},r&&!e.isInitialized&&!n.isClone){if(!e.options.initImmediate)return e.init(n,r),a(e,f(e));setTimeout((function(){e.init(n,r)}),0)}return e}return c(t,e),s(t,[{key:"init",value:function e(){var t=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;function o(e){return e?"function"==typeof e?new e:e:null}if("function"==typeof n&&(r=n,n={}),n.whitelist&&!n.supportedLngs&&this.logger.deprecate("whitelist",'option "whitelist" will be renamed to "supportedLngs" in the next major - please make sure to rename this option asap.'),n.nonExplicitWhitelist&&!n.nonExplicitSupportedLngs&&this.logger.deprecate("whitelist",'options "nonExplicitWhitelist" will be renamed to "nonExplicitSupportedLngs" in the next major - please make sure to rename this option asap.'),this.options=i({},U(),this.options,q(n)),this.format=this.options.interpolation.format,r||(r=$),!this.options.isClone){this.modules.logger?d.init(o(this.modules.logger),this.options):d.init(null,this.options);var s=new B(this.options);this.store=new A(this.options.resources,this.options);var a=this.services;a.logger=d,a.resourceStore=this.store,a.languageUtils=s,a.pluralResolver=new P(s,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),a.interpolator=new N(this.options),a.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},a.backendConnector=new z(o(this.modules.backend),a.resourceStore,a,this.options),a.backendConnector.on("*",(function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),i=1;i1?n-1:0),i=1;i0&&"dev"!==u[0]&&(this.options.lng=u[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined");var f=["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"];f.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments)}}));var c=["addResource","addResources","addResourceBundle","removeResourceBundle"];c.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments),t}}));var l=g(),h=function e(){var n=function e(n,i){t.isInitialized&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),l.resolve(i),r(n,i)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return n(null,t.t.bind(t));t.changeLanguage(t.options.lng,n)};return this.options.resources||!this.options.initImmediate?h():setTimeout(h,0),l}},{key:"loadResources",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,i=r,o="string"==typeof t?t:this.language;if("function"==typeof t&&(i=t),!this.options.resources||this.options.partialBundledLanguages){if(o&&"cimode"===o.toLowerCase())return i();var s=[],a=function e(t){var r;t&&n.services.languageUtils.toResolveHierarchy(t).forEach((function(e){s.indexOf(e)<0&&s.push(e)}))};if(o)a(o);else{var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.forEach((function(e){return a(e)}))}this.options.preload&&this.options.preload.forEach((function(e){return a(e)})),this.services.backendConnector.load(s,this.options.ns,i)}else i(null)}},{key:"reloadResources",value:function e(t,n,r){var i=g();return t||(t=this.languages),n||(n=this.options.ns),r||(r=$),this.services.backendConnector.reload(t,n,(function(e){i.resolve(),r(e)})),i}},{key:"use",value:function e(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&C.addPostProcessor(t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"changeLanguage",value:function e(t,n){var r=this;this.isLanguageChangingTo=t;var i=g();this.emit("languageChanging",t);var o=function e(t,o){o?(r.language=o,r.languages=r.services.languageUtils.toResolveHierarchy(o),r.translator.changeLanguage(o),r.isLanguageChangingTo=void 0,r.emit("languageChanged",o),r.logger.log("languageChanged",o)):r.isLanguageChangingTo=void 0,i.resolve((function(){return r.t.apply(r,arguments)})),n&&n(t,(function(){return r.t.apply(r,arguments)}))},s=function e(t){var n="string"==typeof t?t:r.services.languageUtils.getBestMatchFromCodes(t);n&&(r.language||(r.language=n,r.languages=r.services.languageUtils.toResolveHierarchy(n)),r.translator.language||r.translator.changeLanguage(n),r.services.languageDetector&&r.services.languageDetector.cacheUserLanguage(n)),r.loadResources(n,(function(e){o(e,n)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(s):s(t):s(this.services.languageDetector.detect()),i}},{key:"getFixedT",value:function e(t,n){var o=this,s=function e(t,n){var s;if("object"!==r(n)){for(var a=arguments.length,u=new Array(a>2?a-2:0),f=2;f1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var i=this.languages[0],o=!!this.options&&this.options.fallbackLng,s=this.languages[this.languages.length-1];if("cimode"===i.toLowerCase())return!0;var a=function e(t,r){var i=n.services.backendConnector.state["".concat(t,"|").concat(r)];return-1===i||2===i};if(r.precheck){var u=r.precheck(this,a);if(void 0!==u)return u}return!!this.hasResourceBundle(i,t)||(!this.services.backendConnector.backend||!(!a(i,t)||o&&!a(s,t)))}},{key:"loadNamespaces",value:function e(t,n){var r=this,i=g();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(e){r.options.ns.indexOf(e)<0&&r.options.ns.push(e)})),this.loadResources((function(e){i.resolve(),n&&n(e)})),i):(n&&n(),Promise.resolve())}},{key:"loadLanguages",value:function e(t,n){var r=g();"string"==typeof t&&(t=[t]);var i=this.options.preload||[],o=t.filter((function(e){return i.indexOf(e)<0}));return o.length?(this.options.preload=i.concat(o),this.loadResources((function(e){r.resolve(),n&&n(e)})),r):(n&&n(),Promise.resolve())}},{key:"dir",value:function e(t){return t||(t=this.languages&&this.languages.length>0?this.languages[0]:this.language),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>=0?"rtl":"ltr":"rtl";var n}},{key:"createInstance",value:function e(){var n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;return new t(n,r)}},{key:"cloneInstance",value:function e(){var n=this,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,s=i({},this.options,r,{isClone:!0}),a=new t(s),u=["store","services","language"];return u.forEach((function(e){a[e]=n[e]})),a.services=i({},this.services),a.services.utils={hasLoadedNamespace:a.hasLoadedNamespace.bind(a)},a.translator=new O(a.services,a.options),a.translator.on("*",(function(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;rr,root:()=>i,ArrayProto:()=>o,ObjProto:()=>s,SymbolProto:()=>a,push:()=>u,slice:()=>f,toString:()=>c,hasOwnProperty:()=>l,supportsArrayBuffer:()=>h,supportsDataView:()=>d,nativeIsArray:()=>p,nativeKeys:()=>g,nativeCreate:()=>b,nativeIsView:()=>m,_isNaN:()=>v,_isFinite:()=>y,hasEnumBug:()=>_,nonEnumerableProps:()=>w,MAX_ARRAY_INDEX:()=>k});var r="1.13.4",i="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},o=Array.prototype,s=Object.prototype,a="undefined"!=typeof Symbol?Symbol.prototype:null,u=o.push,f=o.slice,c=s.toString,l=s.hasOwnProperty,h="undefined"!=typeof ArrayBuffer,d="undefined"!=typeof DataView,p=Array.isArray,g=Object.keys,b=Object.create,m=h&&ArrayBuffer.isView,v=isNaN,y=isFinite,_=!{toString:null}.propertyIsEnumerable("toString"),w=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],k=Math.pow(2,53)-1},"restArguments.js":function e(t,n,e){function r(e,t){return t=null==t?e.length-1:+t,function(){for(var n=Math.max(arguments.length-t,0),r=Array(n),i=0;ir})},"isObject.js":function e(t,n,e){function r(e){var t=typeof e;return"function"===t||"object"===t&&!!e}e.export({default:()=>r})},"isNull.js":function e(t,n,e){function r(e){return null===e}e.export({default:()=>r})},"isUndefined.js":function e(t,n,e){function r(e){return void 0===e}e.export({default:()=>r})},"isBoolean.js":function e(t,n,e){let r;function i(e){return!0===e||!1===e||"[object Boolean]"===r.call(e)}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isElement.js":function e(t,n,e){function r(e){return!(!e||1!==e.nodeType)}e.export({default:()=>r})},"isString.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("String"))},"_tagTester.js":function e(t,n,e){let r;function i(e){var t="[object "+e+"]";return function(e){return r.call(e)===t}}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isNumber.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Number"))},"isDate.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Date"))},"isRegExp.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("RegExp"))},"isError.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Error"))},"isSymbol.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Symbol"))},"isArrayBuffer.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("ArrayBuffer"))},"isDataView.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isArrayBuffer.js",{default(e){o=e}},2),e.link("./_stringTagBug.js",{hasStringTagBug(e){s=e}},3);var a=r("DataView");function u(e){return null!=e&&i(e.getInt8)&&o(e.buffer)}e.exportDefault(s?u:a)},"isFunction.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_setup.js",{root(e){i=e}},1);var o=r("Function"),s=i.document&&i.document.childNodes;"function"!=typeof/./&&"object"!=typeof Int8Array&&"function"!=typeof s&&(o=function(e){return"function"==typeof e||!1}),e.exportDefault(o)},"_stringTagBug.js":function e(t,n,e){let r,i;e.export({hasStringTagBug:()=>o,isIE11:()=>s}),e.link("./_setup.js",{supportsDataView(e){r=e}},0),e.link("./_hasObjectTag.js",{default(e){i=e}},1);var o=r&&i(new DataView(new ArrayBuffer(8))),s="undefined"!=typeof Map&&i(new Map)},"_hasObjectTag.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Object"))},"isArray.js":function e(t,n,e){let r,i;e.link("./_setup.js",{nativeIsArray(e){r=e}},0),e.link("./_tagTester.js",{default(e){i=e}},1),e.exportDefault(r||i("Array"))},"isArguments.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1);var o=r("Arguments");!function(){o(arguments)||(o=function(e){return i(e,"callee")})}(),e.exportDefault(o)},"_has.js":function e(t,n,e){let r;function i(e,t){return null!=e&&r.call(e,t)}e.export({default:()=>i}),e.link("./_setup.js",{hasOwnProperty(e){r=e}},0)},"isFinite.js":function e(t,n,e){let r,i;function o(e){return!i(e)&&r(e)&&!isNaN(parseFloat(e))}e.export({default:()=>o}),e.link("./_setup.js",{_isFinite(e){r=e}},0),e.link("./isSymbol.js",{default(e){i=e}},1)},"isNaN.js":function e(t,n,e){let r,i;function o(e){return i(e)&&r(e)}e.export({default:()=>o}),e.link("./_setup.js",{_isNaN(e){r=e}},0),e.link("./isNumber.js",{default(e){i=e}},1)},"isTypedArray.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./_setup.js",{supportsArrayBuffer(e){r=e},nativeIsView(e){i=e},toString(e){o=e}},0),e.link("./isDataView.js",{default(e){s=e}},1),e.link("./constant.js",{default(e){a=e}},2),e.link("./_isBufferLike.js",{default(e){u=e}},3);var f=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;function c(e){return i?i(e)&&!s(e):u(e)&&f.test(o.call(e))}e.exportDefault(r?c:a(!1))},"constant.js":function e(t,n,e){function r(e){return function(){return e}}e.export({default:()=>r})},"_isBufferLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getByteLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createSizePropertyCheck.js":function e(t,n,e){let r;function i(e){return function(t){var n=e(t);return"number"==typeof n&&n>=0&&n<=r}}e.export({default:()=>i}),e.link("./_setup.js",{MAX_ARRAY_INDEX(e){r=e}},0)},"_getByteLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("byteLength"))},"_shallowProperty.js":function e(t,n,e){function r(e){return function(t){return null==t?void 0:t[e]}}e.export({default:()=>r})},"isEmpty.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(null==e)return!0;var t=r(e);return"number"==typeof t&&(i(e)||o(e)||s(e))?0===t:0===r(a(e))}e.export({default:()=>u}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3),e.link("./keys.js",{default(e){a=e}},4)},"_getLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("length"))},"keys.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(!r(e))return[];if(i)return i(e);var t=[];for(var n in e)s(e,n)&&t.push(n);return o&&a(e,t),t}e.export({default:()=>u}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeKeys(e){i=e},hasEnumBug(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2),e.link("./_collectNonEnumProps.js",{default(e){a=e}},3)},"_collectNonEnumProps.js":function e(t,n,e){let r,i,o,s;function a(e){for(var t={},n=e.length,r=0;ru}),e.link("./_setup.js",{nonEnumerableProps(e){r=e},ObjProto(e){i=e}},0),e.link("./isFunction.js",{default(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2)},"isMatch.js":function e(t,n,e){let r;function i(e,t){var n=r(t),i=n.length;if(null==e)return!i;for(var o=Object(e),s=0;si}),e.link("./keys.js",{default(e){r=e}},0)},"isEqual.js":function e(t,n,e){let r,i,o,s,a,u,f,c,l,h,d;e.export({default:()=>m}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_setup.js",{toString(e){i=e},SymbolProto(e){o=e}},1),e.link("./_getByteLength.js",{default(e){s=e}},2),e.link("./isTypedArray.js",{default(e){a=e}},3),e.link("./isFunction.js",{default(e){u=e}},4),e.link("./_stringTagBug.js",{hasStringTagBug(e){f=e}},5),e.link("./isDataView.js",{default(e){c=e}},6),e.link("./keys.js",{default(e){l=e}},7),e.link("./_has.js",{default(e){h=e}},8),e.link("./_toBufferView.js",{default(e){d=e}},9);var p="[object DataView]";function g(e,t,n,r){if(e===t)return 0!==e||1/e==1/t;if(null==e||null==t)return!1;if(e!=e)return t!=t;var i=typeof e;return("function"===i||"object"===i||"object"==typeof t)&&b(e,t,n,r)}function b(e,t,n,m){e instanceof r&&(e=e._wrapped),t instanceof r&&(t=t._wrapped);var v=i.call(e);if(v!==i.call(t))return!1;if(f&&"[object Object]"==v&&c(e)){if(!c(t))return!1;v=p}switch(v){case"[object RegExp]":case"[object String]":return""+e==""+t;case"[object Number]":return+e!=+e?+t!=+t:0==+e?1/+e==1/t:+e==+t;case"[object Date]":case"[object Boolean]":return+e==+t;case"[object Symbol]":return o.valueOf.call(e)===o.valueOf.call(t);case"[object ArrayBuffer]":case p:return b(d(e),d(t),n,m)}var y="[object Array]"===v;if(!y&&a(e)){var _;if(s(e)!==s(t))return!1;if(e.buffer===t.buffer&&e.byteOffset===t.byteOffset)return!0;y=!0}if(!y){if("object"!=typeof e||"object"!=typeof t)return!1;var w=e.constructor,k=t.constructor;if(w!==k&&!(u(w)&&w instanceof w&&u(k)&&k instanceof k)&&"constructor"in e&&"constructor"in t)return!1}m=m||[];for(var j=(n=n||[]).length;j--;)if(n[j]===e)return m[j]===t;if(n.push(e),m.push(t),y){if((j=e.length)!==t.length)return!1;for(;j--;)if(!g(e[j],t[j],n,m))return!1}else{var x=l(e),S;if(j=x.length,l(t).length!==j)return!1;for(;j--;)if(S=x[j],!h(t,S)||!g(e[S],t[S],n,m))return!1}return n.pop(),m.pop(),!0}function m(e,t){return g(e,t)}},"underscore.js":function e(t,n,e){let r;function i(e){return e instanceof i?e:this instanceof i?void(this._wrapped=e):new i(e)}e.export({default:()=>i}),e.link("./_setup.js",{VERSION(e){r=e}},0),i.VERSION=r,i.prototype.value=function(){return this._wrapped},i.prototype.valueOf=i.prototype.toJSON=i.prototype.value,i.prototype.toString=function(){return String(this._wrapped)}},"_toBufferView.js":function e(t,n,e){let r;function i(e){return new Uint8Array(e.buffer||e,e.byteOffset||0,r(e))}e.export({default:()=>i}),e.link("./_getByteLength.js",{default(e){r=e}},0)},"isMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},mapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Map"))},"_methodFingerprint.js":function e(t,n,e){let r,i,o;function s(e){var t=r(e);return function(n){if(null==n)return!1;var s=o(n);if(r(s))return!1;for(var u=0;us,mapMethods:()=>l,weakMapMethods:()=>h,setMethods:()=>d}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./allKeys.js",{default(e){o=e}},2);var a="forEach",u="has",f=["clear","delete"],c=["get","has","set"],l=f.concat(a,c),h=f.concat(c),d=["add"].concat(f,a,"has")},"allKeys.js":function e(t,n,e){let r,i,o;function s(e){if(!r(e))return[];var t=[];for(var n in e)t.push(n);return i&&o(e,t),t}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{hasEnumBug(e){i=e}},1),e.link("./_collectNonEnumProps.js",{default(e){o=e}},2)},"isWeakMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},weakMapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("WeakMap"))},"isSet.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},setMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Set"))},"isWeakSet.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("WeakSet"))},"values.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"pairs.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"invert.js":function e(t,n,e){let r;function i(e){for(var t={},n=r(e),i=0,o=n.length;ii}),e.link("./keys.js",{default(e){r=e}},0)},"functions.js":function e(t,n,e){let r;function i(e){var t=[];for(var n in e)r(e[n])&&t.push(n);return t.sort()}e.export({default:()=>i}),e.link("./isFunction.js",{default(e){r=e}},0)},"extend.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createAssigner.js":function e(t,n,e){function r(e,t){return function(n){var r=arguments.length;if(t&&(n=Object(n)),r<2||null==n)return n;for(var i=1;ir})},"extendOwn.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"defaults.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i,!0))},"create.js":function e(t,n,e){let r,i;function o(e,t){var n=r(e);return t&&i(n,t),n}e.export({default:()=>o}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./extendOwn.js",{default(e){i=e}},1)},"_baseCreate.js":function e(t,n,e){let r,i;function o(){return function(){}}function s(e){if(!r(e))return{};if(i)return i(e);var t=function(){};t.prototype=e;var n=new t;return t.prototype=null,n}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeCreate(e){i=e}},1)},"clone.js":function e(t,n,e){let r,i,o;function s(e){return r(e)?i(e)?e.slice():o({},e):e}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./extend.js",{default(e){o=e}},2)},"tap.js":function e(t,n,e){function r(e,t){return t(e),e}e.export({default:()=>r})},"get.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=i(e,r(t));return o(s)?n:s}e.export({default:()=>s}),e.link("./_toPath.js",{default(e){r=e}},0),e.link("./_deepGet.js",{default(e){i=e}},1),e.link("./isUndefined.js",{default(e){o=e}},2)},"_toPath.js":function e(t,n,e){let r;function i(e){return r.toPath(e)}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./toPath.js")},"toPath.js":function e(t,n,e){let r,i;function o(e){return i(e)?e:[e]}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),r.toPath=o},"_deepGet.js":function e(t,n,e){function r(e,t){for(var n=t.length,r=0;rr})},"has.js":function e(t,n,e){let r,i;function o(e,t){for(var n=(t=i(t)).length,o=0;oo}),e.link("./_has.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"mapObject.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s=o.length,a={},u=0;uo}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"_cb.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r.iteratee!==o?r.iteratee(e,t):i(e,t,n)}e.export({default:()=>s}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),e.link("./iteratee.js",{default(e){o=e}},2)},"_baseIteratee.js":function e(t,n,e){let r,i,o,s,a,u,f;function c(e,t,n){return null==e?r:i(e)?f(e,t,n):o(e)&&!s(e)?a(e):u(e)}e.export({default:()=>c}),e.link("./identity.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isObject.js",{default(e){o=e}},2),e.link("./isArray.js",{default(e){s=e}},3),e.link("./matcher.js",{default(e){a=e}},4),e.link("./property.js",{default(e){u=e}},5),e.link("./_optimizeCb.js",{default(e){f=e}},6)},"identity.js":function e(t,n,e){function r(e){return e}e.export({default:()=>r})},"matcher.js":function e(t,n,e){let r,i;function o(e){return e=r({},e),function(t){return i(t,e)}}e.export({default:()=>o}),e.link("./extendOwn.js",{default(e){r=e}},0),e.link("./isMatch.js",{default(e){i=e}},1)},"property.js":function e(t,n,e){let r,i;function o(e){return e=i(e),function(t){return r(t,e)}}e.export({default:()=>o}),e.link("./_deepGet.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"_optimizeCb.js":function e(t,n,e){function r(e,t,n){if(void 0===t)return e;switch(null==n?3:n){case 1:return function(n){return e.call(t,n)};case 3:return function(n,r,i){return e.call(t,n,r,i)};case 4:return function(n,r,i,o){return e.call(t,n,r,i,o)}}return function(){return e.apply(t,arguments)}}e.export({default:()=>r})},"iteratee.js":function e(t,n,e){let r,i;function o(e,t){return i(e,t,1/0)}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),r.iteratee=o},"noop.js":function e(t,n,e){function r(){}e.export({default:()=>r})},"propertyOf.js":function e(t,n,e){let r,i;function o(e){return null==e?r:function(t){return i(e,t)}}e.export({default:()=>o}),e.link("./noop.js",{default(e){r=e}},0),e.link("./get.js",{default(e){i=e}},1)},"times.js":function e(t,n,e){let r;function i(e,t,n){var i=Array(Math.max(0,e));t=r(t,n,1);for(var o=0;oi}),e.link("./_optimizeCb.js",{default(e){r=e}},0)},"random.js":function e(t,n,e){function r(e,t){return null==t&&(t=e,e=0),e+Math.floor(Math.random()*(t-e+1))}e.export({default:()=>r})},"now.js":function e(t,n,e){e.exportDefault(Date.now||function(){return(new Date).getTime()})},"escape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createEscaper.js":function e(t,n,e){let r;function i(e){var t=function(t){return e[t]},n="(?:"+r(e).join("|")+")",i=RegExp(n),o=RegExp(n,"g");return function(e){return e=null==e?"":""+e,i.test(e)?e.replace(o,t):e}}e.export({default:()=>i}),e.link("./keys.js",{default(e){r=e}},0)},"_escapeMap.js":function e(t,n,e){e.exportDefault({"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"})},"unescape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_unescapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_unescapeMap.js":function e(t,n,e){let r,i;e.link("./invert.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"templateSettings.js":function e(t,n,e){let r;e.link("./underscore.js",{default(e){r=e}},0),e.exportDefault(r.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g})},"template.js":function e(t,n,e){let r,i;e.export({default:()=>c}),e.link("./defaults.js",{default(e){r=e}},0),e.link("./underscore.js",{default(e){i=e}},1),e.link("./templateSettings.js");var o=/(.)^/,s={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},a=/\\|'|\r|\n|\u2028|\u2029/g;function u(e){return"\\"+s[e]}var f=/^\s*(\w|\$)+\s*$/;function c(e,t,n){!t&&n&&(t=n),t=r({},t,i.templateSettings);var s=RegExp([(t.escape||o).source,(t.interpolate||o).source,(t.evaluate||o).source].join("|")+"|$","g"),c=0,l="__p+='";e.replace(s,(function(t,n,r,i,o){return l+=e.slice(c,o).replace(a,u),c=o+t.length,n?l+="'+\n((__t=("+n+"))==null?'':_.escape(__t))+\n'":r?l+="'+\n((__t=("+r+"))==null?'':__t)+\n'":i&&(l+="';\n"+i+"\n__p+='"),t})),l+="';\n";var h=t.variable,d;if(h){if(!f.test(h))throw new Error("variable is not a bare identifier: "+h)}else l="with(obj||{}){\n"+l+"}\n",h="obj";l="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+l+"return __p;\n";try{d=new Function(h,"_",l)}catch(g){throw g.source=l,g}var p=function(e){return d.call(this,e,i)};return p.source="function("+h+"){\n"+l+"}",p}},"result.js":function e(t,n,e){let r,i;function o(e,t,n){var o=(t=i(t)).length;if(!o)return r(n)?n.call(e):n;for(var s=0;so}),e.link("./isFunction.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"uniqueId.js":function e(t,n,e){e.export({default:()=>i});var r=0;function i(e){var t=++r+"";return e?e+t:t}},"chain.js":function e(t,n,e){let r;function i(e){var t=r(e);return t._chain=!0,t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"partial.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_executeBound.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2);var s=r((function(e,t){var n=s.placeholder,r=function(){for(var o=0,s=t.length,a=Array(s),u=0;uo}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./isObject.js",{default(e){i=e}},1)},"bind.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_executeBound.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t,n){if(!i(e))throw new TypeError("Bind must be called on a function");var s=r((function(r){return o(e,s,t,this,n.concat(r))}));return s})))},"bindAll.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./bind.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t){var n=(t=i(t,!1,!1)).length;if(n<1)throw new Error("bindAll must be passed function names");for(;n--;){var r=t[n];e[r]=o(e[r],e)}return e})))},"_flatten.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,u){if(u=u||[],t||0===t){if(t<=0)return u.concat(e)}else t=1/0;for(var f=u.length,c=0,l=r(e);c1)a(h,t-1,n,u),f=u.length;else for(var d=0,p=h.length;da}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./isArray.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3)},"_isArrayLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"memoize.js":function e(t,n,e){let r;function i(e,t){var n=function(i){var o=n.cache,s=""+(t?t.apply(this,arguments):i);return r(o,s)||(o[s]=e.apply(this,arguments)),o[s]};return n.cache={},n}e.export({default:()=>i}),e.link("./_has.js",{default(e){r=e}},0)},"delay.js":function e(t,n,e){let r;e.link("./restArguments.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){return setTimeout((function(){return e.apply(null,n)}),t)})))},"defer.js":function e(t,n,e){let r,i,o;e.link("./partial.js",{default(e){r=e}},0),e.link("./delay.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2),e.exportDefault(r(i,o,1))},"throttle.js":function e(t,n,e){let r;function i(e,t,n){var i,o,s,a,u=0;n||(n={});var f=function(){u=!1===n.leading?0:r(),i=null,a=e.apply(o,s),i||(o=s=null)},c=function(){var c=r();u||!1!==n.leading||(u=c);var l=t-(c-u);return o=this,s=arguments,l<=0||l>t?(i&&(clearTimeout(i),i=null),u=c,a=e.apply(o,s),i||(o=s=null)):i||!1===n.trailing||(i=setTimeout(f,l)),a};return c.cancel=function(){clearTimeout(i),u=0,i=o=s=null},c}e.export({default:()=>i}),e.link("./now.js",{default(e){r=e}},0)},"debounce.js":function e(t,n,e){let r,i;function o(e,t,n){var o,s,a,u,f,c=function(){var r=i()-s;t>r?o=setTimeout(c,t-r):(o=null,n||(u=e.apply(f,a)),o||(a=f=null))},l=r((function(r){return f=this,a=r,s=i(),o||(o=setTimeout(c,t),n&&(u=e.apply(f,a))),u}));return l.cancel=function(){clearTimeout(o),o=a=f=null},l}e.export({default:()=>o}),e.link("./restArguments.js",{default(e){r=e}},0),e.link("./now.js",{default(e){i=e}},1)},"wrap.js":function e(t,n,e){let r;function i(e,t){return r(t,e)}e.export({default:()=>i}),e.link("./partial.js",{default(e){r=e}},0)},"negate.js":function e(t,n,e){function r(e){return function(){return!e.apply(this,arguments)}}e.export({default:()=>r})},"compose.js":function e(t,n,e){function r(){var e=arguments,t=e.length-1;return function(){for(var n=t,r=e[t].apply(this,arguments);n--;)r=e[n].call(this,r);return r}}e.export({default:()=>r})},"after.js":function e(t,n,e){function r(e,t){return function(){if(--e<1)return t.apply(this,arguments)}}e.export({default:()=>r})},"before.js":function e(t,n,e){function r(e,t){var n;return function(){return--e>0&&(n=t.apply(this,arguments)),e<=1&&(t=null),n}}e.export({default:()=>r})},"once.js":function e(t,n,e){let r,i;e.link("./partial.js",{default(e){r=e}},0),e.link("./before.js",{default(e){i=e}},1),e.exportDefault(r(i,2))},"findKey.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s,a=0,u=o.length;ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"findIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createPredicateIndexFinder.js":function e(t,n,e){let r,i;function o(e){return function(t,n,o){n=r(n,o);for(var s=i(t),a=e>0?0:s-1;a>=0&&ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"findLastIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"sortedIndex.js":function e(t,n,e){let r,i;function o(e,t,n,o){for(var s=(n=r(n,o,1))(t),a=0,u=i(e);ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"indexOf.js":function e(t,n,e){let r,i,o;e.link("./sortedIndex.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./_createIndexFinder.js",{default(e){o=e}},2),e.exportDefault(o(1,i,r))},"_createIndexFinder.js":function e(t,n,e){let r,i,o;function s(e,t,n){return function(s,a,u){var f=0,c=r(s);if("number"==typeof u)e>0?f=u>=0?u:Math.max(u+c,f):c=u>=0?Math.min(u+1,c):u+c+1;else if(n&&u&&c)return s[u=n(s,a)]===a?u:-1;if(a!=a)return(u=t(i.call(s,f,c),o))>=0?u+f:-1;for(u=e>0?f:c-1;u>=0&&us}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isNaN.js",{default(e){o=e}},2)},"lastIndexOf.js":function e(t,n,e){let r,i;e.link("./findLastIndex.js",{default(e){r=e}},0),e.link("./_createIndexFinder.js",{default(e){i=e}},1),e.exportDefault(i(-1,r))},"find.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a=(r(e)?i:o)(e,t,n);if(void 0!==a&&-1!==a)return e[a]}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./findKey.js",{default(e){o=e}},2)},"findWhere.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./find.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"each.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a;if(t=r(t,n),i(e))for(s=0,a=e.length;ss}),e.link("./_optimizeCb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"map.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=Array(a),f=0;fs}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"reduce.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createReduce.js":function e(t,n,e){let r,i,o;function s(e){var t=function(t,n,o,s){var a=!r(t)&&i(t),u=(a||t).length,f=e>0?0:u-1;for(s||(o=t[a?a[f]:f],f+=e);f>=0&&f=3;return t(e,o(n,i,4),r,s)}}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2)},"reduceRight.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"filter.js":function e(t,n,e){let r,i;function o(e,t,n){var o=[];return t=r(t,n),i(e,(function(e,n,r){t(e,n,r)&&o.push(e)})),o}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"reject.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r(e,i(o(t)),n)}e.export({default:()=>s}),e.link("./filter.js",{default(e){r=e}},0),e.link("./negate.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2)},"every.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"some.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"contains.js":function e(t,n,e){let r,i,o;function s(e,t,n,s){return r(e)||(e=i(e)),("number"!=typeof n||s)&&(n=0),o(e,t,n)>=0}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./indexOf.js",{default(e){o=e}},2)},"invoke.js":function e(t,n,e){let r,i,o,s,a;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2),e.link("./_deepGet.js",{default(e){s=e}},3),e.link("./_toPath.js",{default(e){a=e}},4),e.exportDefault(r((function(e,t,n){var r,u;return i(t)?u=t:(t=a(t),r=t.slice(0,-1),t=t[t.length-1]),o(e,(function(e){var i=u;if(!i){if(r&&r.length&&(e=s(e,r)),null==e)return;i=e[t]}return null==i?i:i.apply(e,n)}))})))},"pluck.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./map.js",{default(e){r=e}},0),e.link("./property.js",{default(e){i=e}},1)},"where.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./filter.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"max.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=-1/0,u=-1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la&&(a=f);else t=o(t,n),s(e,(function(e,n,r){((c=t(e,n,r))>u||c===-1/0&&a===-1/0)&&(a=e,u=c)}));return a}e.export({default:()=>a}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"min.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=1/0,u=1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"shuffle.js":function e(t,n,e){let r;function i(e){return r(e,1/0)}e.export({default:()=>i}),e.link("./sample.js",{default(e){r=e}},0)},"sample.js":function e(t,n,e){let r,i,o,s,a;function u(e,t,n){if(null==t||n)return r(e)||(e=i(e)),e[s(e.length-1)];var u=a(e),f=o(u);t=Math.max(Math.min(t,f),0);for(var c=f-1,l=0;lu}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./random.js",{default(e){s=e}},3),e.link("./toArray.js",{default(e){a=e}},4)},"toArray.js":function e(t,n,e){let r,i,o,s,a,u,f;e.export({default:()=>l}),e.link("./isArray.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./_isArrayLike.js",{default(e){s=e}},3),e.link("./map.js",{default(e){a=e}},4),e.link("./identity.js",{default(e){u=e}},5),e.link("./values.js",{default(e){f=e}},6);var c=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;function l(e){return e?r(e)?i.call(e):o(e)?e.match(c):s(e)?a(e,u):f(e):[]}},"sortBy.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=0;return t=r(t,n),i(o(e,(function(e,n,r){return{value:e,index:s++,criteria:t(e,n,r)}})).sort((function(e,t){var n=e.criteria,r=t.criteria;if(n!==r){if(n>r||void 0===n)return 1;if(ns}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./pluck.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2)},"groupBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n].push(t):e[n]=[t]})))},"_group.js":function e(t,n,e){let r,i;function o(e,t){return function(n,o,s){var a=t?[[],[]]:{};return o=r(o,s),i(n,(function(t,r){var i=o(t,r,n);e(a,t,i)})),a}}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"indexBy.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n]=t})))},"countBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n]++:e[n]=1})))},"partition.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n?0:1].push(t)}),!0))},"size.js":function e(t,n,e){let r,i;function o(e){return null==e?0:r(e)?e.length:i(e).length}e.export({default:()=>o}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"pick.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2),e.link("./allKeys.js",{default(e){s=e}},3),e.link("./_keyInObj.js",{default(e){a=e}},4),e.link("./_flatten.js",{default(e){u=e}},5),e.exportDefault(r((function(e,t){var n={},r=t[0];if(null==e)return n;i(r)?(t.length>1&&(r=o(r,t[1])),t=s(e)):(r=a,t=u(t,!1,!1),e=Object(e));for(var f=0,c=t.length;fr})},"omit.js":function e(t,n,e){let r,i,o,s,a,u,f;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./negate.js",{default(e){o=e}},2),e.link("./map.js",{default(e){s=e}},3),e.link("./_flatten.js",{default(e){a=e}},4),e.link("./contains.js",{default(e){u=e}},5),e.link("./pick.js",{default(e){f=e}},6),e.exportDefault(r((function(e,t){var n=t[0],r;return i(n)?(n=o(n),t.length>1&&(r=t[1])):(t=s(a(t,!1,!1),String),n=function(e,n){return!u(t,n)}),f(e,n,r)})))},"first.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[0]:r(e,e.length-t)}e.export({default:()=>i}),e.link("./initial.js",{default(e){r=e}},0)},"initial.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,0,Math.max(0,e.length-(null==t||n?1:t)))}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"last.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[e.length-1]:r(e,Math.max(0,e.length-t))}e.export({default:()=>i}),e.link("./rest.js",{default(e){r=e}},0)},"rest.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,null==t||n?1:t)}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"compact.js":function e(t,n,e){let r;function i(e){return r(e,Boolean)}e.export({default:()=>i}),e.link("./filter.js",{default(e){r=e}},0)},"flatten.js":function e(t,n,e){let r;function i(e,t){return r(e,t,!1)}e.export({default:()=>i}),e.link("./_flatten.js",{default(e){r=e}},0)},"without.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./difference.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t){return i(e,t)})))},"difference.js":function e(t,n,e){let r,i,o,s;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./filter.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3),e.exportDefault(r((function(e,t){return t=i(t,!0,!0),o(e,(function(e){return!s(t,e)}))})))},"uniq.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,a){r(t)||(a=n,n=t,t=!1),null!=n&&(n=i(n,a));for(var u=[],f=[],c=0,l=o(e);ca}),e.link("./isBoolean.js",{default(e){r=e}},0),e.link("./_cb.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3)},"union.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./uniq.js",{default(e){i=e}},1),e.link("./_flatten.js",{default(e){o=e}},2),e.exportDefault(r((function(e){return i(o(e,!0,!0))})))},"intersection.js":function e(t,n,e){let r,i;function o(e){for(var t=[],n=arguments.length,o=0,s=r(e);oo}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./contains.js",{default(e){i=e}},1)},"unzip.js":function e(t,n,e){let r,i,o;function s(e){for(var t=e&&r(e,i).length||0,n=Array(t),s=0;ss}),e.link("./max.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.link("./pluck.js",{default(e){o=e}},2)},"zip.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./unzip.js",{default(e){i=e}},1),e.exportDefault(r(i))},"object.js":function e(t,n,e){let r;function i(e,t){for(var n={},i=0,o=r(e);ii}),e.link("./_getLength.js",{default(e){r=e}},0)},"range.js":function e(t,n,e){function r(e,t,n){null==t&&(t=e||0,e=0),n||(n=tr})},"chunk.js":function e(t,n,e){let r;function i(e,t){if(null==t||t<1)return[];for(var n=[],i=0,o=e.length;ii}),e.link("./_setup.js",{slice(e){r=e}},0)},"mixin.js":function e(t,n,e){let r,i,o,s,a;function u(e){return i(o(e),(function(t){var n=r[t]=e[t];r.prototype[t]=function(){var e=[this._wrapped];return s.apply(e,arguments),a(this,n.apply(r,e))}})),r}e.export({default:()=>u}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./functions.js",{default(e){o=e}},2),e.link("./_setup.js",{push(e){s=e}},3),e.link("./_chainResult.js",{default(e){a=e}},4)},"_chainResult.js":function e(t,n,e){let r;function i(e,t){return e._chain?r(t).chain():t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"underscore-array-methods.js":function e(t,n,e){let r,i,o,s;e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./_setup.js",{ArrayProto(e){o=e}},2),e.link("./_chainResult.js",{default(e){s=e}},3),i(["pop","push","reverse","shift","sort","splice","unshift"],(function(e){var t=o[e];r.prototype[e]=function(){var n=this._wrapped;return null!=n&&(t.apply(n,arguments),"shift"!==e&&"splice"!==e||0!==n.length||delete n[0]),s(this,n)}})),i(["concat","join","slice"],(function(e){var t=o[e];r.prototype[e]=function(){var e=this._wrapped;return null!=e&&(e=t.apply(e,arguments)),s(this,e)}})),e.exportDefault(r)}}}}},cachers:{"package.json":function e(t,n,e){e.exports={name:"@steedos/cachers",version:"2.7.4-beta.1",main:"lib/index.js"}},lib:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getCacherNames=n.clearCacher=n.getCacher=void 0;var r={},i=t("./memory"),o=t("./memory-lru"),s=function(e,t){return r[e]||(e.startsWith("lru.")?r[e]=new o.MemoryLRUCacher(t):r[e]=new i.MemoryCacher),r[e]};n.getCacher=s;var a=function(e){r[e]&&r[e].clear()};n.clearCacher=a;var u=function(){return Object.keys(r)};n.getCacherNames=u},"memory.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryCacher=void 0;var r=t("lodash"),i=function(){function e(){this.cache={}}return e.prototype.get=function(e){return this.cache[e]},e.prototype.delete=function(e){delete this.cache[e]},e.prototype.set=function(e,t){this.cache[e]=t},e.prototype.clear=function(){this.cache={}},e.prototype.keys=function(){return(0,r.keys)(this.cache)},e.prototype.values=function(){return(0,r.values)(this.cache)},e}();n.MemoryCacher=i},"memory-lru.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryLRUCacher=void 0;var r=t("lodash"),i=t("lru-cache"),o={max:5e3,ttl:null,keygen:null,maxParamsLength:null},s=function(){function e(e){this.opts=(0,r.defaultsDeep)(e,o),this.cache=new i({max:this.opts.max,maxAge:this.opts.ttl?1e3*this.opts.ttl:null,updateAgeOnGet:!!this.opts.ttl})}return e.prototype.get=function(e){return this.cache.get(e)},e.prototype.set=function(e,t,n){return this.cache.set(e,t,n)},e.prototype.delete=function(e){return this.cache.delete(e)},e.prototype.clear=function(){return this.cache.clear()},e.prototype.keys=function(){return this.cache.keys()},e.prototype.values=function(){return this.cache.values()},e}();n.MemoryLRUCacher=s}},node_modules:{"lru-cache":{"package.json":function e(t,n,e){e.exports={name:"lru-cache",version:"7.14.1",main:"index.js"}},"index.js":function e(t,n,e){const r="object"==typeof performance&&performance&&"function"==typeof performance.now?performance:Date,i="function"==typeof AbortController,o=i?AbortController:class e{constructor(){this.signal=new u}abort(){this.signal.dispatchEvent("abort")}},s="function"==typeof AbortSignal,a="function"==typeof o.AbortSignal,u=s?AbortSignal:a?o.AbortController:class e{constructor(){this.aborted=!1,this._listeners=[]}dispatchEvent(e){if("abort"===e){this.aborted=!0;const t={type:e,target:this};this.onabort(t),this._listeners.forEach(e=>e(t),this)}}onabort(){}addEventListener(e,t){"abort"===e&&this._listeners.push(t)}removeEventListener(e,t){"abort"===e&&(this._listeners=this._listeners.filter(e=>e!==t))}},f=new Set,c=(e,t)=>{const n=`LRU_CACHE_OPTION_${e}`;p(n)&&g(n,`${e} option`,`options.${t}`,_)},l=(e,t)=>{const n=`LRU_CACHE_METHOD_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} method`,`cache.${t}()`,i)}},h=(e,t)=>{const n=`LRU_CACHE_PROPERTY_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} property`,`cache.${t}`,i)}},d=(...e)=>{"object"==typeof process&&process&&"function"==typeof process.emitWarning?process.emitWarning(...e):console.error(...e)},p=e=>!f.has(e),g=(e,t,n,r)=>{f.add(e);const i=`The ${t} is deprecated. Please use ${n} instead.`;d(i,"DeprecationWarning",e,r)},b=e=>e&&e===Math.floor(e)&&e>0&&isFinite(e),m=e=>b(e)?e<=Math.pow(2,8)?Uint8Array:e<=Math.pow(2,16)?Uint16Array:e<=Math.pow(2,32)?Uint32Array:e<=Number.MAX_SAFE_INTEGER?v:null:null;class v extends Array{constructor(e){super(e),this.fill(0)}}class y{constructor(e){if(0===e)return[];const t=m(e);this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}}class _{constructor(e={}){const{max:t=0,ttl:n,ttlResolution:r=1,ttlAutopurge:i,updateAgeOnGet:o,updateAgeOnHas:s,allowStale:a,dispose:u,disposeAfter:l,noDisposeOnSet:h,noUpdateTTL:g,maxSize:v=0,maxEntrySize:w=0,sizeCalculation:k,fetchMethod:j,fetchContext:x,noDeleteOnFetchRejection:S,noDeleteOnStaleGet:D}=e,{length:E,maxAge:A,stale:C}=e instanceof _?{}:e;if(0!==t&&!b(t))throw new TypeError("max option must be a nonnegative integer");const M=t?m(t):Array;if(!M)throw new Error("invalid max value: "+t);if(this.max=t,this.maxSize=v,this.maxEntrySize=w||this.maxSize,this.sizeCalculation=k||E,this.sizeCalculation){if(!this.maxSize&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if("function"!=typeof this.sizeCalculation)throw new TypeError("sizeCalculation set to non-function")}if(this.fetchMethod=j||null,this.fetchMethod&&"function"!=typeof this.fetchMethod)throw new TypeError("fetchMethod must be a function if specified");if(this.fetchContext=x,!this.fetchMethod&&void 0!==x)throw new TypeError("cannot set fetchContext without fetchMethod");if(this.keyMap=new Map,this.keyList=new Array(t).fill(null),this.valList=new Array(t).fill(null),this.next=new M(t),this.prev=new M(t),this.head=0,this.tail=0,this.free=new y(t),this.initialFill=1,this.size=0,"function"==typeof u&&(this.dispose=u),"function"==typeof l?(this.disposeAfter=l,this.disposed=[]):(this.disposeAfter=null,this.disposed=null),this.noDisposeOnSet=!!h,this.noUpdateTTL=!!g,this.noDeleteOnFetchRejection=!!S,0!==this.maxEntrySize){if(0!==this.maxSize&&!b(this.maxSize))throw new TypeError("maxSize must be a positive integer if specified");if(!b(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.initializeSizeTracking()}if(this.allowStale=!!a||!!C,this.noDeleteOnStaleGet=!!D,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!s,this.ttlResolution=b(r)||0===r?r:1,this.ttlAutopurge=!!i,this.ttl=n||A||0,this.ttl){if(!b(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.initializeTTLTracking()}if(0===this.max&&0===this.ttl&&0===this.maxSize)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.max&&!this.maxSize){const e="LRU_CACHE_UNBOUNDED";if(p(e)){f.add(e);const t="TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";d(t,"UnboundedCacheWarning",e,_)}}C&&c("stale","allowStale"),A&&c("maxAge","ttl"),E&&c("length","sizeCalculation")}getRemainingTTL(e){return this.has(e,{updateAgeOnHas:!1})?1/0:0}initializeTTLTracking(){this.ttls=new v(this.max),this.starts=new v(this.max),this.setItemTTL=(e,t,n=r.now())=>{if(this.starts[e]=0!==t?n:0,this.ttls[e]=t,0!==t&&this.ttlAutopurge){const n=setTimeout(()=>{this.isStale(e)&&this.delete(this.keyList[e])},t+1);n.unref&&n.unref()}},this.updateItemAge=e=>{this.starts[e]=0!==this.ttls[e]?r.now():0};let e=0;const t=()=>{const t=r.now();if(this.ttlResolution>0){e=t;const n=setTimeout(()=>e=0,this.ttlResolution);n.unref&&n.unref()}return t};this.getRemainingTTL=n=>{const r=this.keyMap.get(n);return void 0===r?0:0===this.ttls[r]||0===this.starts[r]?1/0:this.starts[r]+this.ttls[r]-(e||t())},this.isStale=n=>0!==this.ttls[n]&&0!==this.starts[n]&&(e||t())-this.starts[n]>this.ttls[n]}updateItemAge(e){}setItemTTL(e,t,n){}isStale(e){return!1}initializeSizeTracking(){this.calculatedSize=0,this.sizes=new v(this.max),this.removeItemSize=e=>{this.calculatedSize-=this.sizes[e],this.sizes[e]=0},this.requireSize=(e,t,n,r)=>{if(this.isBackgroundFetch(t))return 0;if(!b(n)){if(!r)throw new TypeError("invalid size value (must be positive integer)");if("function"!=typeof r)throw new TypeError("sizeCalculation must be a function");if(n=r(t,e),!b(n))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}return n},this.addItemSize=(e,t)=>{if(this.sizes[e]=t,this.maxSize){const t=this.maxSize-this.sizes[e];for(;this.calculatedSize>t;)this.evict(!0)}this.calculatedSize+=this.sizes[e]}}removeItemSize(e){}addItemSize(e,t){}requireSize(e,t,n,r){if(n||r)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache")}*indexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.tail;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.head);)t=this.prev[t]}*rindexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.head;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.tail);)t=this.next[t]}isValidIndex(e){return this.keyMap.get(this.keyList[e])===e}*entries(){for(const e of this.indexes())yield[this.keyList[e],this.valList[e]]}*rentries(){for(const e of this.rindexes())yield[this.keyList[e],this.valList[e]]}*keys(){for(const e of this.indexes())yield this.keyList[e]}*rkeys(){for(const e of this.rindexes())yield this.keyList[e]}*values(){for(const e of this.indexes())yield this.valList[e]}*rvalues(){for(const e of this.rindexes())yield this.valList[e]}[Symbol.iterator](){return this.entries()}find(e,t={}){for(const n of this.indexes())if(e(this.valList[n],this.keyList[n],this))return this.get(this.keyList[n],t)}forEach(e,t=this){for(const n of this.indexes())e.call(t,this.valList[n],this.keyList[n],this)}rforEach(e,t=this){for(const n of this.rindexes())e.call(t,this.valList[n],this.keyList[n],this)}get prune(){return l("prune","purgeStale"),this.purgeStale}purgeStale(){let e=!1;for(const t of this.rindexes({allowStale:!0}))this.isStale(t)&&(this.delete(this.keyList[t]),e=!0);return e}dump(){const e=[];for(const t of this.indexes({allowStale:!0})){const n=this.keyList[t],i=this.valList[t],o=this.isBackgroundFetch(i)?i.__staleWhileFetching:i,s={value:o};if(this.ttls){s.ttl=this.ttls[t];const e=r.now()-this.starts[t];s.start=Math.floor(Date.now()-e)}this.sizes&&(s.size=this.sizes[t]),e.unshift([n,s])}return e}load(e){this.clear();for(const[t,n]of e){if(n.start){const e=Date.now()-n.start;n.start=r.now()-e}this.set(t,n.value,n)}}dispose(e,t,n){}set(e,t,{ttl:n=this.ttl,start:r,noDisposeOnSet:i=this.noDisposeOnSet,size:o=0,sizeCalculation:s=this.sizeCalculation,noUpdateTTL:a=this.noUpdateTTL}={}){if(o=this.requireSize(e,t,o,s),this.maxEntrySize&&o>this.maxEntrySize)return this.delete(e),this;let u=0===this.size?void 0:this.keyMap.get(e);if(void 0===u)u=this.newIndex(),this.keyList[u]=e,this.valList[u]=t,this.keyMap.set(e,u),this.next[this.tail]=u,this.prev[u]=this.tail,this.tail=u,this.size++,this.addItemSize(u,o),a=!1;else{const n=this.valList[u];t!==n&&(this.isBackgroundFetch(n)?n.__abortController.abort():i||(this.dispose(n,e,"set"),this.disposeAfter&&this.disposed.push([n,e,"set"])),this.removeItemSize(u),this.valList[u]=t,this.addItemSize(u,o)),this.moveToTail(u)}if(0===n||0!==this.ttl||this.ttls||this.initializeTTLTracking(),a||this.setItemTTL(u,n,r),this.disposeAfter)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return this}newIndex(){return 0===this.size?this.tail:this.size===this.max&&0!==this.max?this.evict(!1):0!==this.free.length?this.free.pop():this.initialFill++}pop(){if(this.size){const e=this.valList[this.head];return this.evict(!0),e}}evict(e){const t=this.head,n=this.keyList[t],r=this.valList[t];return this.isBackgroundFetch(r)?r.__abortController.abort():(this.dispose(r,n,"evict"),this.disposeAfter&&this.disposed.push([r,n,"evict"])),this.removeItemSize(t),e&&(this.keyList[t]=null,this.valList[t]=null,this.free.push(t)),this.head=this.next[t],this.keyMap.delete(n),this.size--,t}has(e,{updateAgeOnHas:t=this.updateAgeOnHas}={}){const n=this.keyMap.get(e);return void 0!==n&&!this.isStale(n)&&(t&&this.updateItemAge(n),!0)}peek(e,{allowStale:t=this.allowStale}={}){const n=this.keyMap.get(e);if(void 0!==n&&(t||!this.isStale(n))){const e=this.valList[n];return this.isBackgroundFetch(e)?e.__staleWhileFetching:e}}backgroundFetch(e,t,n,r){const i=void 0===t?void 0:this.valList[t];if(this.isBackgroundFetch(i))return i;const s=new o,a={signal:s.signal,options:n,context:r},u=t=>(s.signal.aborted||this.set(e,t,a.options),t),f=r=>{if(this.valList[t]===l){const r=!n.noDeleteOnFetchRejection||void 0===l.__staleWhileFetching;r?this.delete(e):this.valList[t]=l.__staleWhileFetching}if(l.__returned===l)throw r},c=t=>t(this.fetchMethod(e,i,a)),l=new Promise(c).then(u,f);return l.__abortController=s,l.__staleWhileFetching=i,l.__returned=null,void 0===t?(this.set(e,l,a.options),t=this.keyMap.get(e)):this.valList[t]=l,l}isBackgroundFetch(e){return e&&"object"==typeof e&&"function"==typeof e.then&&Object.prototype.hasOwnProperty.call(e,"__staleWhileFetching")&&Object.prototype.hasOwnProperty.call(e,"__returned")&&(e.__returned===e||null===e.__returned)}async fetch(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet,ttl:i=this.ttl,noDisposeOnSet:o=this.noDisposeOnSet,size:s=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:u=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,fetchContext:c=this.fetchContext,forceRefresh:l=!1}={}){if(!this.fetchMethod)return this.get(e,{allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r});const h={allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r,ttl:i,noDisposeOnSet:o,size:s,sizeCalculation:a,noUpdateTTL:u,noDeleteOnFetchRejection:f};let d=this.keyMap.get(e);if(void 0===d){const t=this.backgroundFetch(e,d,h,c);return t.__returned=t}{const r=this.valList[d];if(this.isBackgroundFetch(r))return t&&void 0!==r.__staleWhileFetching?r.__staleWhileFetching:r.__returned=r;if(!l&&!this.isStale(d))return this.moveToTail(d),n&&this.updateItemAge(d),r;const i=this.backgroundFetch(e,d,h,c);return t&&void 0!==i.__staleWhileFetching?i.__staleWhileFetching:i.__returned=i}}get(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet}={}){const i=this.keyMap.get(e);if(void 0!==i){const o=this.valList[i],s=this.isBackgroundFetch(o);if(this.isStale(i))return s?t?o.__staleWhileFetching:void 0:(r||this.delete(e),t?o:void 0);if(s)return;return this.moveToTail(i),n&&this.updateItemAge(i),o}}connect(e,t){this.prev[t]=e,this.next[e]=t}moveToTail(e){e!==this.tail&&(e===this.head?this.head=this.next[e]:this.connect(this.prev[e],this.next[e]),this.connect(this.tail,e),this.tail=e)}get del(){return l("del","delete"),this.delete}delete(e){let t=!1;if(0!==this.size){const n=this.keyMap.get(e);if(void 0!==n)if(t=!0,1===this.size)this.clear();else{this.removeItemSize(n);const t=this.valList[n];this.isBackgroundFetch(t)?t.__abortController.abort():(this.dispose(t,e,"delete"),this.disposeAfter&&this.disposed.push([t,e,"delete"])),this.keyMap.delete(e),this.keyList[n]=null,this.valList[n]=null,n===this.tail?this.tail=this.prev[n]:n===this.head?this.head=this.next[n]:(this.next[this.prev[n]]=this.next[n],this.prev[this.next[n]]=this.prev[n]),this.size--,this.free.push(n)}}if(this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return t}clear(){for(const e of this.rindexes({allowStale:!0})){const t=this.valList[e];if(this.isBackgroundFetch(t))t.__abortController.abort();else{const n=this.keyList[e];this.dispose(t,n,"delete"),this.disposeAfter&&this.disposed.push([t,n,"delete"])}}if(this.keyMap.clear(),this.valList.fill(null),this.keyList.fill(null),this.ttls&&(this.ttls.fill(0),this.starts.fill(0)),this.sizes&&this.sizes.fill(0),this.head=0,this.tail=0,this.initialFill=1,this.free.length=0,this.calculatedSize=0,this.size=0,this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift())}get reset(){return l("reset","clear"),this.clear}get length(){return h("length","size"),this.size}static get AbortController(){return o}static get AbortSignal(){return u}}e.exports=_}}}},"form-builder":{"package.json":function e(t,n,e){e.exports={name:"@steedos/form-builder",version:"3.6.2-patch.5",private:!1,publishConfig:{access:"public"},main:"dist/form-builder.min.js",homepage:"https://formbuilder.online/",repository:{url:"https://github.com/kevinchappell/formBuilder.git",type:"git"},files:["dist/**/*","docs/**/*","src/**/*"],author:"Kevin Chappell ",contributors:[],bugs:"https://github.com/kevinchappell/formBuilder/issues",description:"A jQuery plugin for drag and drop form building",keywords:["jquery-plugin","forms","drag and drop","form builder","form create"],license:"MIT",ignore:["**/*","node_modules","test"],config:{files:{test:["test/**/*.spec.js"],pluginsDir:"src/js/control_plugins/",fonts:"src/fonts",sass:"src/sass",formBuilder:{js:"src/js/form-builder.js",sass:["src/sass/form-builder.scss"]},formRender:{js:"src/js/form-render.js",sass:["src/sass/form-render.scss"]},site:["demo/assets/sass/site.scss"]},fontServer:"http://fontello.com",fontelloToken:"09d648f01d6c57cb9f9b8cc55043e0c0"},babel:{presets:[["@babel/preset-env",{targets:{browsers:["> 1%"]},loose:!0}]],comments:!1,plugins:["@babel/plugin-proposal-object-rest-spread","@babel/plugin-proposal-class-properties"]},scripts:{"build:analyze":"webpack --mode production -p --progress --config tools/webpack.config --analyze","build:plugins":"webpack --mode production -p --display-entrypoints --progress --config tools/webpack.plugins.config","build:vendor":"babel-node tools/build-vendor",build:"webpack --mode production -p --progress --config tools/webpack.config","build:all":"npm-run-all build:plugins build:vendor build copy",copy:"cp -a dist/* demo/assets/js/ && cp CONTRIBUTING.md docs/contributing.md && cp LICENSE docs/license.md && npm run copy:lang","copy:lang":"babel-node tools/copy-language-files","deploy:all":"npm-run-all deploy:demo deploy:site","deploy:demo":"node tools/deploy-demo.js","deploy:site":"node tools/deploy-site.js",docs:"mkdocs build",font:"babel-node tools/icon-font",lint:"eslint ./src --ext .js || true","semantic-release":"semantic-release","start:devServer":"webpack-dev-server --mode development --config tools/webpack.config",prestart:"npm-run-all -p build:vendor copy:lang",start:"npm run start:devServer",test:"npm run-script build"},dependencies:{jquery:">=3.4.1","jquery-ui-sortable":"*"},devDependencies:{"@babel/cli":"^7.10.5","@babel/core":"^7.11.4","@babel/node":"^7.10.5","@babel/plugin-proposal-class-properties":"^7.10.4","@babel/plugin-proposal-object-rest-spread":"^7.11.0","@babel/plugin-syntax-object-rest-spread":"^7.8.3","@babel/plugin-transform-destructuring":"^7.10.4","@babel/preset-env":"^7.11.0","@semantic-release/changelog":"^5.0.1","@semantic-release/git":"^9.0.0","@semantic-release/npm":"^7.0.5",autoprefixer:"^9.8.6","babel-eslint":"^10.1.0","babel-loader":"^8.1.0","clean-webpack-plugin":"^3.0.0",clui:"^0.3.6","compression-webpack-plugin":"^5.0.1","concat-files":"^0.1.1","cross-env":"^7.0.2","css-loader":"^4.2.1",eslint:"^7.7.0","eslint-loader":"^4.0.2","formbuilder-languages":"latest","fs-extra":"^9.0.1","html-webpack-harddisk-plugin":"^1.0.2","html-webpack-plugin":"^4.3.0",inquirer:"^7.3.3",mi18n:"^0.4.8","node-sass":"6.0.1","npm-run-all":"^4.1.5",opener:"^1.5.1","postcss-loader":"^3.0.0","replace-in-file":"^6.1.0",request:"^2.88.2","sass-loader":"10.5.2","semantic-release":"^17.1.1",semver:"^7.3.2","style-loader":"^1.2.1",unzipper:"^0.10.11",webpack:"^4.44.1","webpack-bundle-analyzer":"^3.8.0","webpack-cli":"^3.3.12","webpack-dev-server":"^3.11.0","wrapper-webpack-plugin":"^2.1.0"},prettier:{singleQuote:!0,trailingComma:"all",printWidth:120,semi:!1,arrowParens:"avoid",spaceAfterFunction:!1},engines:{},release:{branch:"master",verifyConditions:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"],prepare:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"]},browserslist:["> 1%"]}},dist:{"form-builder.min.js":[]}}},tslib:{"package.json":function e(t,n,e){e.exports={name:"tslib",version:"2.3.1",module:"tslib.es6.js",main:"tslib.js"}},"tslib.es6.js":function e(t,n,e){e.export({__extends:()=>i,__assign:()=>o,__rest:()=>s,__decorate:()=>a,__param:()=>u,__metadata:()=>f,__awaiter:()=>c,__generator:()=>l,__createBinding:()=>h,__exportStar:()=>d,__values:()=>p,__read:()=>g,__spread:()=>b,__spreadArrays:()=>m,__spreadArray:()=>v,__await:()=>y,__asyncGenerator:()=>_,__asyncDelegator:()=>w,__asyncValues:()=>k,__makeTemplateObject:()=>j,__importStar:()=>S,__importDefault:()=>D,__classPrivateFieldGet:()=>E,__classPrivateFieldSet:()=>A}); +if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(jQuery),function(e){"use strict";function t(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var n in t)if(void 0!==e.style[n])return{end:t[n]};return!1}e.fn.emulateTransitionEnd=function(t){var n=!1,r=this,i;return e(this).one("bsTransitionEnd",(function(){n=!0})),setTimeout((function(){n||e(r).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=t(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(jQuery),function(e){"use strict";var t='[data-dismiss="alert"]',n=function(n){e(n).on("click",t,this.close)};function r(t){return this.each((function(){var r=e(this),i=r.data("bs.alert");i||r.data("bs.alert",i=new n(this)),"string"==typeof t&&i[t].call(r)}))}n.VERSION="3.4.1",n.TRANSITION_DURATION=150,n.prototype.close=function(t){var r=e(this),i=r.attr("data-target");i||(i=(i=r.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=e(document).find(i);function s(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=r.closest(".alert")),o.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),e.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",s).emulateTransitionEnd(n.TRANSITION_DURATION):s())};var i=e.fn.alert;e.fn.alert=r,e.fn.alert.Constructor=n,e.fn.alert.noConflict=function(){return e.fn.alert=i,this},e(document).on("click.bs.alert.data-api",t,n.prototype.close)}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.isLoading=!1};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.button"),o="object"==typeof n&&n;i||r.data("bs.button",i=new t(this,o)),"toggle"==n?i.toggle():n&&i.setState(n)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var n="disabled",r=this.$element,i=r.is("input")?"val":"html",o=r.data();t+="Text",null==o.resetText&&r.data("resetText",r[i]()),setTimeout(e.proxy((function(){r[i](null==o[t]?this.options[t]:o[t]),"loadingText"==t?(this.isLoading=!0,r.addClass(n).attr(n,n).prop(n,!0)):this.isLoading&&(this.isLoading=!1,r.removeClass(n).removeAttr(n).prop(n,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var n=this.$element.find("input");"radio"==n.prop("type")?(n.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==n.prop("type")&&(n.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),n.prop("checked",this.$element.hasClass("active")),e&&n.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var r=e.fn.button;e.fn.button=n,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=r,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var r=e(t.target).closest(".btn");n.call(r,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),r.is("input,button")?r.trigger("focus"):r.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(jQuery),function(e){"use strict";var t=function(t,n){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=n,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.carousel"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n),s="string"==typeof n?n:o.slide;i||r.data("bs.carousel",i=new t(this,o)),"number"==typeof n?i.to(n):s?i[s]():o.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var n=this.getItemIndex(t),r;if(("prev"==e&&0===n||"next"==e&&n==this.$items.length-1)&&!this.options.wrap)return t;var i,o=(n+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(o)},t.prototype.to=function(e){var t=this,n=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):n==e?this.pause().cycle():this.slide(e>n?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(n,r){var i=this.$element.find(".item.active"),o=r||this.getItemForDirection(n,i),s=this.interval,a="next"==n?"left":"right",u=this;if(o.hasClass("active"))return this.sliding=!1;var f=o[0],c=e.Event("slide.bs.carousel",{relatedTarget:f,direction:a});if(this.$element.trigger(c),!c.isDefaultPrevented()){if(this.sliding=!0,s&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var l=e(this.$indicators.children()[this.getItemIndex(o)]);l&&l.addClass("active")}var h=e.Event("slid.bs.carousel",{relatedTarget:f,direction:a});return e.support.transition&&this.$element.hasClass("slide")?(o.addClass(n),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(a),o.addClass(a),i.one("bsTransitionEnd",(function(){o.removeClass([n,a].join(" ")).addClass("active"),i.removeClass(["active",a].join(" ")),u.sliding=!1,setTimeout((function(){u.$element.trigger(h)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(h)),s&&this.cycle(),this}};var r=e.fn.carousel;e.fn.carousel=n,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=r,this};var i=function(t){var r=e(this),i=r.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=r.attr("data-target")||i,s=e(document).find(o);if(s.hasClass("carousel")){var a=e.extend({},s.data(),r.data()),u=r.attr("data-slide-to");u&&(a.interval=!1),n.call(s,a),u&&s.data("bs.carousel").to(u),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);n.call(t,t.data())}))}))}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.$trigger=e('[data-toggle="collapse"][href="#'+n.id+'"],[data-toggle="collapse"][data-target="#'+n.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var n,r=t.attr("data-target")||(n=t.attr("href"))&&n.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(r)}function r(n){return this.each((function(){var r=e(this),i=r.data("bs.collapse"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n);!i&&o.toggle&&/show|hide/.test(n)&&(o.toggle=!1),i||r.data("bs.collapse",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){var e;return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var n,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(n=i.data("bs.collapse"))&&n.transitioning)){var o=e.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){i&&i.length&&(r.call(i,"hide"),n||i.data("bs.collapse",null));var s=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[s](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var a=function(){this.$element.removeClass("collapsing").addClass("collapse in")[s](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return a.call(this);var u=e.camelCase(["scroll",s].join("-"));this.$element.one("bsTransitionEnd",e.proxy(a,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[s](this.$element[0][u])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var n=e.Event("hide.bs.collapse");if(this.$element.trigger(n),!n.isDefaultPrevented()){var r=this.dimension();this.$element[r](this.$element[r]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[r](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,r){var i=e(r);this.addAriaAndCollapsedClass(n(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var n=e.hasClass("in");e.attr("aria-expanded",n),t.toggleClass("collapsed",!n).attr("aria-expanded",n)};var i=e.fn.collapse;e.fn.collapse=r,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var o=n(i),s,a=o.data("bs.collapse")?"toggle":i.data();r.call(o,a)}))}(jQuery),function(e){"use strict";var t=".dropdown-backdrop",n='[data-toggle="dropdown"]',r=function(t){e(t).on("click.bs.dropdown",this.toggle)};function i(t){var n=t.attr("data-target");n||(n=(n=t.attr("href"))&&/#[A-Za-z]/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,""));var r="#"!==n?e(document).find(n):null;return r&&r.length?r:t.parent()}function o(r){r&&3===r.which||(e(t).remove(),e(n).each((function(){var t=e(this),n=i(t),o={relatedTarget:this};n.hasClass("open")&&(r&&"click"==r.type&&/input|textarea/i.test(r.target.tagName)&&e.contains(n[0],r.target)||(n.trigger(r=e.Event("hide.bs.dropdown",o)),r.isDefaultPrevented()||(t.attr("aria-expanded","false"),n.removeClass("open").trigger(e.Event("hidden.bs.dropdown",o)))))})))}function s(t){return this.each((function(){var n=e(this),i=n.data("bs.dropdown");i||n.data("bs.dropdown",i=new r(this)),"string"==typeof t&&i[t].call(n)}))}r.VERSION="3.4.1",r.prototype.toggle=function(t){var n=e(this);if(!n.is(".disabled, :disabled")){var r=i(n),s=r.hasClass("open");if(o(),!s){"ontouchstart"in document.documentElement&&!r.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",o);var a={relatedTarget:this};if(r.trigger(t=e.Event("show.bs.dropdown",a)),t.isDefaultPrevented())return;n.trigger("focus").attr("aria-expanded","true"),r.toggleClass("open").trigger(e.Event("shown.bs.dropdown",a))}return!1}},r.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var r=e(this);if(t.preventDefault(),t.stopPropagation(),!r.is(".disabled, :disabled")){var o=i(r),s=o.hasClass("open");if(!s&&27!=t.which||s&&27==t.which)return 27==t.which&&o.find(n).trigger("focus"),r.trigger("click");var a=" li:not(.disabled):visible a",u=o.find(".dropdown-menu"+a);if(u.length){var f=u.index(t.target);38==t.which&&f>0&&f--,40==t.which&&fdocument.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},f.prototype.init=function(t,n,r){if(this.enabled=!0,this.type=t,this.$element=e(n),this.options=this.getOptions(r),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),o=i.length;o--;){var s=i[o];if("click"==s)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=s){var a="hover"==s?"mouseenter":"focusin",u="hover"==s?"mouseleave":"focusout";this.$element.on(a+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(u+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},f.prototype.getDefaults=function(){return f.DEFAULTS},f.prototype.getOptions=function(n){var r=this.$element.data();for(var i in r)r.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete r[i];return(n=e.extend({},this.getDefaults(),r,n)).delay&&"number"==typeof n.delay&&(n.delay={show:n.delay,hide:n.delay}),n.sanitize&&(n.template=u(n.template,n.whiteList,n.sanitizeFn)),n},f.prototype.getDelegateOptions=function(){var t={},n=this.getDefaults();return this._options&&e.each(this._options,(function(e,r){n[e]!=r&&(t[e]=r)})),t},f.prototype.enter=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusin"==t.type?"focus":"hover"]=!0),n.tip().hasClass("in")||"in"==n.hoverState)n.hoverState="in";else{if(clearTimeout(n.timeout),n.hoverState="in",!n.options.delay||!n.options.delay.show)return n.show();n.timeout=setTimeout((function(){"in"==n.hoverState&&n.show()}),n.options.delay.show)}},f.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},f.prototype.leave=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusout"==t.type?"focus":"hover"]=!1),!n.isInStateTrue()){if(clearTimeout(n.timeout),n.hoverState="out",!n.options.delay||!n.options.delay.hide)return n.hide();n.timeout=setTimeout((function(){"out"==n.hoverState&&n.hide()}),n.options.delay.hide)}},f.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var n=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!n)return;var r=this,i=this.tip(),o=this.getUID(this.type);this.setContent(),i.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&i.addClass("fade");var s="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,a=/\s?auto?\s?/i,u=a.test(s);u&&(s=s.replace(a,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(s).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var c=this.getPosition(),l=i[0].offsetWidth,h=i[0].offsetHeight;if(u){var d=s,p=this.getPosition(this.$viewport);s="bottom"==s&&c.bottom+h>p.bottom?"top":"top"==s&&c.top-hp.width?"left":"left"==s&&c.left-ls.top+s.height&&(i.top=s.top+s.height-u)}else{var f=t.left-o,c=t.left+o+n;fs.right&&(i.left=s.left+s.width-c)}return i},f.prototype.getTitle=function(){var e,t=this.$element,n=this.options;return e=t.attr("data-original-title")||("function"==typeof n.title?n.title.call(t[0]):n.title)},f.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},f.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},f.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},f.prototype.enable=function(){this.enabled=!0},f.prototype.disable=function(){this.enabled=!1},f.prototype.toggleEnabled=function(){this.enabled=!this.enabled},f.prototype.toggle=function(t){var n=this;t&&((n=e(t.currentTarget).data("bs."+this.type))||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n))),t?(n.inState.click=!n.inState.click,n.isInStateTrue()?n.enter(n):n.leave(n)):n.tip().hasClass("in")?n.leave(n):n.enter(n)},f.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},f.prototype.sanitizeHtml=function(e){return u(e,this.options.whiteList,this.options.sanitizeFn)};var l=e.fn.tooltip;e.fn.tooltip=c,e.fn.tooltip.Constructor=f,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=l,this}}(jQuery),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");function n(n){return this.each((function(){var r=e(this),i=r.data("bs.popover"),o="object"==typeof n&&n;!i&&/destroy|hide/.test(n)||(i||r.data("bs.popover",i=new t(this,o)),"string"==typeof n&&i[n]())}))}t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:''}),t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype),t.prototype.constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),n=this.getContent();if(this.options.html){var r=typeof n;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===r&&(n=this.sanitizeHtml(n))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===r?"html":"append"](n)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(n);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var r=e.fn.popover;e.fn.popover=n,e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=r,this}}(jQuery),function(e){"use strict";function t(n,r){this.$body=e(document.body),this.$scrollElement=e(n).is(document.body)?e(window):e(n),this.options=e.extend({},t.DEFAULTS,r),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function n(n){return this.each((function(){var r=e(this),i=r.data("bs.scrollspy"),o="object"==typeof n&&n;i||r.data("bs.scrollspy",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,n="offset",r=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(n="position",r=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),o=/^#./.test(i)&&e(i);return o&&o.length&&o.is(":visible")&&[[o[n]().top+r,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.getScrollHeight(),n=this.options.offset+t-this.$scrollElement.height(),r=this.offsets,i=this.targets,o=this.activeTarget,s;if(this.scrollHeight!=t&&this.refresh(),e>=n)return o!=(s=i[i.length-1])&&this.activate(s);if(o&&e=r[s]&&(void 0===r[s+1]||e .active"),s=i&&e.support.transition&&(o.length&&o.hasClass("fade")||!!r.find("> .fade").length);function a(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),n.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),s?(n[0].offsetWidth,n.addClass("in")):n.removeClass("fade"),n.parent(".dropdown-menu").length&&n.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&s?o.one("bsTransitionEnd",a).emulateTransitionEnd(t.TRANSITION_DURATION):a(),o.removeClass("in")};var r=e.fn.tab;e.fn.tab=n,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=r,this};var i=function(t){t.preventDefault(),n.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(e){"use strict";var t=function(n,r){this.options=e.extend({},t.DEFAULTS,r);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(n),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.affix"),o="object"==typeof n&&n;i||r.data("bs.affix",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,n,r){var i=this.$target.scrollTop(),o=this.$element.offset(),s=this.$target.height();if(null!=n&&"top"==this.affixed)return i=e-r&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),n=this.$element.offset();return this.pinnedOffset=n.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var n=this.$element.height(),r=this.options.offset,i=r.top,o=r.bottom,s=Math.max(e(document).height(),e(document.body).height());"object"!=typeof r&&(o=i=r),"function"==typeof i&&(i=r.top(this.$element)),"function"==typeof o&&(o=r.bottom(this.$element));var a=this.getState(s,n,i,o);if(this.affixed!=a){null!=this.unpin&&this.$element.css("top","");var u="affix"+(a?"-"+a:""),f=e.Event(u+".bs.affix");if(this.$element.trigger(f),f.isDefaultPrevented())return;this.affixed=a,this.unpin="bottom"==a?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(u).trigger(u.replace("affix","affixed")+".bs.affix")}"bottom"==a&&this.$element.offset({top:s-n-o})}};var r=e.fn.affix;e.fn.affix=n,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=r,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),r=t.data();r.offset=r.offset||{},null!=r.offsetBottom&&(r.offset.bottom=r.offsetBottom),null!=r.offsetTop&&(r.offset.top=r.offsetTop),n.call(t,r)}))}))}(jQuery)}}}},fibers:{"package.json":function e(t,n,e){e.exports={name:"fibers",version:"5.0.3",main:"fibers"}},"fibers.js":function e(t,n,e,r,i){if(process.fiberLib)e.exports=process.fiberLib;else{var o=t("fs"),s=t("path"),a=t("detect-libc");Math.random();var u=s.join(i,"bin",process.platform+"-"+process.arch+"-"+process.versions.modules+("linux"===process.platform?"-"+a.family:""),"fibers");try{process.fiberLib=e.exports=t(u).Fiber}catch(c){throw console.error("## There is an issue with `node-fibers` ##\n`"+u+".node` is missing.\n\nTry running this to fix the issue: "+process.execPath+" "+i.replace(" ","\\ ")+"/build"),console.error(c.stack||c.message||c),new Error("Missing binary. See message above.")}f(e.exports)}function f(e){try{var t=process.binding("async_wrap"),n;if(t.asyncIdStackSize instanceof Function)n=t.asyncIdStackSize;else{if(void 0===t.constants.kStackLength)throw new Error("Couldn't figure out how to get async stack size");l=t.constants.kStackLength,n=function(){return t.async_hook_fields[l]}}var r=t.popAsyncContext||t.popAsyncIds,i=t.pushAsyncContext||t.pushAsyncIds,o,s;if(!r||!i)throw new Error("Push/pop do not exist");o=void 0===t.constants.kExecutionAsyncId?t.constants.kCurrentAsyncId:t.constants.kExecutionAsyncId,s=void 0===t.constants.kTriggerAsyncId?t.constants.kCurrentTriggerId:t.constants.kTriggerAsyncId;var a=t.async_id_fields||t.async_uid_fields;function u(){for(var e=n(),t=new Array(e);e>0;--e){var i=a[o];t[e-1]={asyncId:i,triggerId:a[s]},r(i)}return t}function f(e){for(var t=0;t0)i.changeLanguage(e,r);else if(0!=a[u]){a[u]=0;var f=new XMLHttpRequest;f.overrideMimeType("application/json"),f.open("GET",u,!1),f.send(null),200===f.status?a[u]=1:a[u]=-1,n.addResourceBundle(e,s,JSON.parse(f.response)||{}),i.changeLanguage(e,r)}};n.changeLanguage=p;var g=function(e,t,n){return i.format(e,t,n)};n.format=g;var b=function(){return i.languages};n.getLanguages=b;var m=function(e,t){return i.loadLanguages(e,t)};n.loadLanguages=m;var v=function(e,t){return i.loadNamespaces(e,t)};n.loadNamespaces=v;var y=function(e,t){return i.on(e,t)};n.on=y;var _=function(e,t){return i.off(e,t)};n.off=_,r.__exportStar(t("./i18n/i18n"),n),r.__exportStar(t("./i18n/i18n.app"),n),r.__exportStar(t("./translations"),n)},i18n:{"i18n.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.fallbackKeys=n.getObjectI18nTemplate=n.translationI18nObjects=n.addObjectsI18n=n.translationI18nObject=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="_",a="base",u="core",f="translation",c=function(e,t){var n={lng:t,ns:f};if((0,r.exists)(e,n))return(0,r._t)(e,n)},l=function(e){return"".concat(e,"__object")},h=function(e,t){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t)},d=function(e,t){var n=h(e,t);return"".concat(n).concat("_","inlineHelpText")},p=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","group").concat("_").concat(n)},g=function(e,t,n){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t).concat("_","options").concat("_").concat(n)},b=function(e,t){return"".concat(e).concat("_","action").concat("_").concat(t)},m=function(e,t){return"".concat(e).concat("_","listview").concat("_").concat(t)},v=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},y=function(e,t,n){var r=l(t);return c(r,e)||n||""},_=function(e,t,n,r,i){var o=h(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=_(e,a,n,r,i))}return s||r||""},w=function(e,t,n,r,i){var o=d(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=w(e,a,n,r,i))}return s||r||""},k=function(e,t,n,r){var i=p(t,n);return c(i,e)||r||""},j=function(e,t,n,r,i,o){var s=g(t,n,r),a=c(s,e);if(!a){var u=v(o);u&&"base"!=t&&"core"!=t&&(a=j(e,u,n,r,i,o))}return a||i||""},x=function(e,t,n,r,i){var o=b(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=x(e,a,n,r,i))}return s||r||""},S=function(e,t,n,r,i){var o=m(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=S(e,a,n,r,i))}return s||r||""},D=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},E=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;return e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(D(e))}))):n.push(D(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},A=function(e,t,n){n.label=y(e,t,n.label),i.each(n.fields,(function(r,o){if(r.label=_(e,t,o,r.label,n.datasource),r.inlineHelpText&&(r.inlineHelpText=w(e,t,o,r.inlineHelpText,n.datasource)),r.group&&(r.group=k(e,t,r.group,r.group)),r.options){var s=[];i.each(r.options,(function(r){if(i.has(r,"value")){var a=j(e,t,o,r.value,r.label,n.datasource);s.push(i.extend({},r,{label:a}))}else s.push(r)})),r.options=s}})),i.each(n.actions,(function(r,i){r.label=x(e,t,i,r.label,n.datasource)})),i.each(n.list_views,(function(r,i){r.label=S(e,t,i,r.label,n.datasource)}))};n.translationI18nObject=A;var C=function(e){i.each(e,(function(e){(0,r.addResourceBundle)(e.lng,f,e.data,!0,!0)}))};n.addObjectsI18n=C;var M=function(e,t){i.each(t,(function(t,r){(0,n.translationI18nObject)(e,r,t)}))};n.translationI18nObjects=M;var O=function(e,t,n){var r=o(n);E(r);var s={};return s[l(t)]=y(e,t,r.label),i.each(r.fields,(function(n,o){s[h(t,o)]=_(e,t,o,n.label),n.inlineHelpText&&(s[d(t,o)]=w(e,t,o,n.inlineHelpText,r.datasource)),n.group&&(s[p(t,n.group)]=k(e,t,n.group,n.group)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[g(t,o,n.value)]=j(e,t,o,n.value,n.label))}))})),i.each(r.actions,(function(n,r){s[b(t,r)]=x(e,t,r,n.label)})),i.each(r.list_views,(function(n,r){s[m(t,r)]=S(e,t,r,n.label)})),s};n.getObjectI18nTemplate=O,n.fallbackKeys={getObjectLabelKey:l,getObjectFieldLabelKey:h,getObjectFieldInlineHelpTextLabelKey:d,getObjectFieldGroupKey:p,getObjectFieldOptionsLabelKey:g,getObjectActionLabelKey:b,getObjectListviewLabelKey:m}},"i18n.app.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.appFallbackKeys=n.getAppI18nTemplate=n.translationI18nApps=n.translationI18nMenus=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="translation",a="_",u=function(e,t){var n={lng:t,ns:s};if((0,r.exists)(e,n))return(0,r._t)(e,n)},f=function(e){return"app".concat("_").concat(e).concat("_","name")},c=function(e){return"app".concat("_").concat(e).concat("_","description")},l=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","tab_group").concat("_").concat(n)},h=function(e){return"menu".concat("_").concat(e)},d=function(e){return"tab".concat("_").concat(e)},p=function(e,t,n){var r=f(t);return u(r,e)||n||""},g=function(e,t,n){var r=c(t);return u(r,e)||n||""},b=function(e,t,n){var r=h(t);return u(r,e)||n||""},m=function(e,t,r){r.label=p(e,t,r.label||r.name),r.description=g(e,t,r.description),(0,n.translationI18nMenus)(e,r.admin_menus)},v=function(e,t){i.each(t,(function(t){var n=b(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationI18nMenus=v;var y=function(e,t){i.each(t,(function(t,n){m(e,n,t)}))};n.translationI18nApps=y;var _=function(e,t,n){var r=o(n),s={};return s[f(t)]=p(e,t,r.label||r.name),s[c(t)]=g(e,t,r.description),i.each(r.admin_menus,(function(t){s[h(t._id)]=b(e,t._id,t.label||t.name)})),s};n.getAppI18nTemplate=_,n.appFallbackKeys={getAppLabelKey:f,getAppDescriptionKey:c,getAppGroupKey:l,getMenuLabelKey:h,getTabKey:d}}},translations:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.SteedosTranslationPrefixKeys=n.convertObject=void 0;var r=t("tslib"),i=t("underscore");r.__exportStar(t("./objectTranslation"),n),r.__exportStar(t("./translation"),n),r.__exportStar(t("./templates/objectTranslation"),n),r.__exportStar(t("./templates/translation"),n);var o=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},s=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(o(e))}))):n.push(o(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else if(e.options&&i.isArray(e.options))try{i.forEach(e.options,(function(e){i.isString(e)?n.push(o(e)):n.push(e)})),e.options=n}catch(r){console.error("Creator.convertFieldsOptions",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},a;n.convertObject=s,function(e){e.Object="CustomObject",e.Field="CustomField",e.Action="CustomAction",e.Listview="CustomListview",e.Permission="CustomPermission",e.ValidationRule="CustomValidationRule",e.Application="CustomApplication",e.Tab="CustomTabs",e.Permissionset="CustomPermissionset",e.Profile="CustomProfile",e.Report="CustomReport",e.Workflow="Workflow",e.Layout="Layout",e.Client="Client",e.Server="Server",e.Function="Function",e.Router="Router",e.Trigger="Trigger"}(a=n.SteedosTranslationPrefixKeys||(n.SteedosTranslationPrefixKeys={}))},"objectTranslation.js":function e(t,n,e,r){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addObjectsTranslation=n.getObjectTranslationTemplate=n.translationObjects=n.translationObject=n.translationObjectLabel=void 0;var i=t("underscore"),o=t("./"),s=t("../index"),a=t("./index"),u=t("../i18n/i18n"),f=t("lodash"),c=t("crypto"),l,h=(0,t("@steedos/cachers").getCacher)("lru.translations.objects");function d(e){var t;return c.createHash("md5").update(e).digest("hex")}var p=function(e,t){return"".concat(e,"_").concat(t.name,"_").concat(d(JSON.stringify(t)))},g=t("clone"),b=".",m="base",v="core",y="translation",_="object",w="field",k="listview",j="action",x=function(e,t){var n={lng:t,ns:y,keySeparator:!1};if((0,s.exists)(e,n))return(0,s._t)(e,n)},S=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},D=function(e){switch(e){case"object":return o.SteedosTranslationPrefixKeys.Object;case"field":return o.SteedosTranslationPrefixKeys.Field;case"listview":return o.SteedosTranslationPrefixKeys.Listview;case"action":return o.SteedosTranslationPrefixKeys.Action;default:return"CustomLabels"}},E=function(e){var t;return[D(),e].join(".")},A=function(e){var t;return[D("object"),e,"label"].join(".")},C=function(e){var t;return[D("object"),e,"description"].join(".")},M=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"label"].join(".")},O=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"help"].join(".")},T=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"description"].join(".")},B=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_"),r;return[D("field"),e,"group",n].join(".")},I=function(e,t,n){var r;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"options",n].join(".")},R=function(e,t){var n;return[D("action"),e,t].join(".")},F=function(e,t){var n;return[D("listview"),e,t].join(".")},P=function(e,t,n){var r,i=[A(t)],o=u.fallbackKeys.getObjectLabelKey(t);return o&&i.push(o),x(i,e)||n||""};n.translationObjectLabel=P;var N=function(e,t,n){var r=C(t);return x(r,e)||n||""},L=function(e,t,n,r,i,o){var s,a=[M(t,n)],f=u.fallbackKeys.getObjectFieldLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=L(e,l,n,r,i))}return c||r||""},z=function(e,t,n,r,i,o){var s,a=[O(t,n)],f=u.fallbackKeys.getObjectFieldInlineHelpTextLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=z(e,l,n,r,i))}return c||r||""},U=function(e,t,n,r,i,o){var s=T(t,n),a,u=x([s],e);if(1!=o&&!u){var f=S(i);f&&"base"!=t&&"core"!=t&&(u=U(e,f,n,r,i))}return u||r||""},q=function(e,t,n,r,i,o){var s,a=[B(t,n)],f=u.fallbackKeys.getObjectFieldGroupKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=q(e,l,n,r,i))}return c||r||""},$=function(e,t,n,r,i,o,s){var a,f=[I(t,n,r)],c=u.fallbackKeys.getObjectFieldOptionsLabelKey(t,n,r);c&&f.push(c);var l=x(f,e);if(1!=s&&!l){var h=S(o);h&&"base"!=t&&"core"!=t&&(l=$(e,h,n,r,i,o))}return l||i||""},W=function(e,t,n,r,i,o){var s,a=[R(t,n)],f=u.fallbackKeys.getObjectActionLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=W(e,l,n,r,i))}return c||r||""},H=function(e,t,n,r,i,o){var s,a=[F(t,n)],f=u.fallbackKeys.getObjectListviewLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=H(e,l,n,r,i))}return c||r||""},Y=function(e,t,r,o,s){void 0===s&&(s=!1);var u=p(e,r),c=h.get(u);if(c)return Object.assign(r,(0,f.cloneDeep)(c));o&&(0,a.convertObject)(r),r.label=(0,n.translationObjectLabel)(e,t,r.label),r.description=N(e,t,r.description),i.each(r.fields,(function(n,o){if(n.label=L(e,t,o,n.label,r.datasource,s),n.inlineHelpText=z(e,t,o,n.inlineHelpText,r.datasource,s),n.description=U(e,t,o,n.description,r.datasource,s),n.group&&(n.group=q(e,t,n.group,n.group,r.datasource,s)),n.options){var a=[];i.each(n.options,(function(n){if(i.has(n,"value")){var u=$(e,t,o,n.value,n.label,r.datasource,s);a.push(i.extend({},n,{label:u}))}else a.push(n)})),n.options=a}})),i.each(r.actions,(function(n,i){n.label=W(e,t,i,n.label,r.datasource,s)})),i.each(r.list_views,(function(n,i){n.label=H(e,t,i,n.label,r.datasource,s)})),h.set(u,(0,f.cloneDeep)(r))};n.translationObject=Y;var V=function(e,t){i.each(t,(function(t,r){(0,n.translationObject)(e,r,t)}))};n.translationObjects=V;var K=function(e,t,r){var o=g(r);(0,a.convertObject)(o);var s={};return s[A(t)]=(0,n.translationObjectLabel)(e,t,o.label),s[C(t)]=N(e,t,o.description),i.each(o.fields,(function(n,r){s[M(t,r)]=L(e,t,r,n.label),n.inlineHelpText&&(s[O(t,r)]=z(e,t,r,n.inlineHelpText,o.datasource)),n.description&&(s[T(t,r)]=U(e,t,r,n.description,o.datasource)),n.group&&(s[B(t,n.group)]=q(e,t,n.group,n.group,o.datasource)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[I(t,r,n.value)]=$(e,t,r,n.value,n.label))}))})),i.each(o.actions,(function(n,r){s[R(t,r)]=W(e,t,r,n.label)})),i.each(o.list_views,(function(n,r){s[F(t,r)]=H(e,t,r,n.label)})),s};function G(e,t){var n=g(e);(0,a.convertObject)(n);var r={},o=n.name;return o||console.error("Error: Invalid objectTranslation:"+t),r[A(o)]=n.label,r[C(o)]=n.description,i.each(n.fields,(function(e,t){r[M(o,t)]=e.label,e.help&&(r[O(o,t)]=e.help),e.description&&(r[T(o,t)]=e.description),e.options&&i.each(e.options,(function(e){i.has(e,"value")&&(r[I(o,t,e.value)]=e.label)}))})),i.each(n.groups,(function(e,t){r[B(o,t)]=e})),i.each(n.actions,(function(e,t){r[R(o,t)]=e.label})),i.each(n.listviews,(function(e,t){r[F(o,t)]=e.label})),i.each(n.CustomLabels,(function(e,t){r[E(t)]=e})),r}n.getObjectTranslationTemplate=K;var X=function(e){i.each(e,(function(e){var t=G(e.data,e.__filename);(0,s.addResourceBundle)(e.lng,y,t,!0,!0)}))};n.addObjectsTranslation=X},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addTranslations=n.convertTranslation=n.convertTranslationData=n.getAppTranslationTemplate=n.translationApps=n.translationMenus=n.translationApp=n.translationTabLabel=n.translationTabGroup=void 0;var r=t("../index"),i=t("underscore"),o=t("./"),s=t("../i18n/i18n.app"),a=t("clone"),u="translation",f=".",c="app",l="menu",h="tab",d=function(e){switch(e){case"app":return o.SteedosTranslationPrefixKeys.Application;case"tab":return o.SteedosTranslationPrefixKeys.Tab;default:return"CustomLabels"}},p=function(e){var t;return[d(),e].join(".")},g=function(e,t){var n={lng:t,ns:u,keySeparator:!1};if((0,r.exists)(e,n))return(0,r._t)(e,n)},b=function(e){var t;return[d("app"),e,"name"].join(".")},m=function(e){var t;return[d("app"),e,"description"].join(".")},v=function(e,t){var n,r;return[d("app"),e,"groups",t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_")].join(".")},y=function(e){var t;return[d("menu"),"menu_".concat(e)].join(".")},_=function(e){var t;return[d("tab"),e].join(".")},w=function(e,t,n){var r,i=[b(t)],o=s.appFallbackKeys.getAppLabelKey(t);return o&&i.push(o),g(i,e)||n||""},k=function(e,t,n){var r,i=[m(t)],o=s.appFallbackKeys.getAppDescriptionKey(t);return o&&i.push(o),g(i,e)||n||""},j=function(e,t,n,r){var i,o=[v(t,n)],a=s.appFallbackKeys.getAppGroupKey(t,n);return a&&o.push(a),g(o,e)||r||""};n.translationTabGroup=j;var x=function(e,t,n){var r,i=[y(t)],o=s.appFallbackKeys.getMenuLabelKey(t);return o&&i.push(o),g(i,e)||n||""},S=function(e,t,n){var r,i=[_(t)],o=s.appFallbackKeys.getTabKey(t);return o&&i.push(o),g(i,e)||n||""};n.translationTabLabel=S;var D=function(e,t,r){r.label=w(e,t,r.label||r.name),r.description=k(e,t,r.description),i.each(r.tab_groups,(function(i,o){r.tab_groups[o].id=i.id||i.group_name,r.tab_groups[o].group_name=(0,n.translationTabGroup)(e,t,i.group_name,i.group_name)})),(0,n.translationMenus)(e,r.admin_menus)};n.translationApp=D;var E=function(e,t){i.each(t,(function(t){var n=x(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationMenus=E;var A=function(e,t){i.each(t,(function(t,r){(0,n.translationApp)(e,r,t)}))};n.translationApps=A;var C=function(e,t,n){var r=a(n),o={};return o[b(t)]=w(e,t,r.label||r.name),o[m(t)]=k(e,t,r.description),i.each(r.admin_menus,(function(t){o[y(t._id)]=x(e,t._id,t.label||t.name)})),o};n.getAppTranslationTemplate=C;var M=function(e,t,n){i.isArray(n)?i.each(n,(function(e){M(e,"",e)})):n&&i.each(i.keys(n),(function(r){var o=t?"".concat(t,".").concat(r):r,s=n[r];"object"==typeof s?i.isArray(s)?i.each(s,(function(e){M(e,o,s)})):M(e,o,s):e[o]=s}))};function O(e){for(var t in e)"object"==typeof e[t]&&M(e,t,e[t]);return e}n.convertTranslationData=O;var T=function(e){var t=a(e),n={};return i.each(t.CustomApplications,(function(e,t){n[b(t)]=e.name,n[m(t)]=e.description,i.each(e.groups,(function(e,r){n[v(t,r)]=e}))})),i.each(t.CustomTabs,(function(e,t){n[_(t)]=e})),i.each(t.CustomLabels,(function(e,t){var r;if("simpleschema"!=t&&i.isObject(e)){var o=O(((r={})[t]=e,r));i.each(o,(function(e,t){i.isObject(e)||(n[p(t)]=e)}))}else n[p(t)]=e})),n};n.convertTranslation=T;var B=function(e){i.each(e,(function(e){var t=(0,n.convertTranslation)(e.data);(0,r.addResourceBundle)(e.lng,u,t,!0,!0)}))};n.addTranslations=B},templates:{"objectTranslation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getObjectMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]="help"===e?t.inlineHelpText||"":t[e]||""})),n}function a(e){return s(["label","description"],e)}function u(e){switch(e.type){case"select":return s(["label","help","options","description"],e);default:return s(["label","help","description"],e)}}function f(e){return s(["label"],e)}function c(e){return s(["label"],e)}function l(e){var t={};return r.each(e,(function(e,n){t[n]=u(e)})),t}function h(e){var t={};return r.each(e,(function(e,n){t[n]=c(e)})),t}function d(e){var t={};return r.each(e,(function(e,n){t[n]=f(e)})),t}function p(e,t){var n={};return r.each(e,(function(e,r){if(e.group){var i=e.group.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");n[i]=t[r].group}})),n}var g=function(e,t,n,s){void 0===s&&(s=!1);var u=o(n);1!=s&&(0,i.translationObject)(e,t,u,!0,s);var f=Object.assign({},a(u));f=Object.assign({},f,{fields:l(u.fields)});var c=p(n.fields,u.fields);r.isEmpty(c)||(f=Object.assign({},f,{groups:c}));var g=d(u.list_views);r.isEmpty(g)||(f=Object.assign({},f,{listviews:g}));var b=h(u.actions);return r.isEmpty(b)||(f=Object.assign({},f,{actions:b})),Object.assign({name:t},f)};n.getObjectMetadataTranslationTemplate=g},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getAppMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]=t[e]||""})),n}function a(e){var t={groups:{}};return e?(r.each(e,(function(e){var n=e.group_name.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t.groups[n]=e.group_name})),t):{}}var u=function(e){return Object.assign({},s(["name","description"],e),a(e.tab_groups))},f=function(e){var t={};return r.each(e,(function(e,n){t[n]=n})),t},c=function(e){var t={};return r.each(e,(function(e){var n=e.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t[n]=e})),t},l=function(e,t,n){var r,s=o(n);(0,i.translationApp)(e,t,s);var a={},l;return s.tab_items?a=f(s.tab_items):s.tabs&&(a=c(s.tabs)),Object.assign({},{CustomApplications:(r={},r[t]=u(s),r)},{CustomTabs:a})};n.getAppMetadataTranslationTemplate=l}}}},node_modules:{i18next:{"package.json":function e(t,n,e){e.exports={name:"i18next",version:"19.9.2",module:"./dist/esm/i18next.js",main:"./dist/cjs/i18next.js"}},dist:{esm:{"i18next.js":function e(t,n,e){let r,i,o,s,a,u,f,c;e.link("@babel/runtime/helpers/esm/typeof",{default(e){r=e}},0),e.link("@babel/runtime/helpers/esm/objectSpread",{default(e){i=e}},1),e.link("@babel/runtime/helpers/esm/classCallCheck",{default(e){o=e}},2),e.link("@babel/runtime/helpers/esm/createClass",{default(e){s=e}},3),e.link("@babel/runtime/helpers/esm/possibleConstructorReturn",{default(e){a=e}},4),e.link("@babel/runtime/helpers/esm/getPrototypeOf",{default(e){u=e}},5),e.link("@babel/runtime/helpers/esm/assertThisInitialized",{default(e){f=e}},6),e.link("@babel/runtime/helpers/esm/inherits",{default(e){c=e}},7);var l={type:"logger",log:function e(t){this.output("log",t)},warn:function e(t){this.output("warn",t)},error:function e(t){this.output("error",t)},output:function e(t,n){console&&console[t]&&console[t].apply(console,n)}},h,d=new(function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.init(t,n)}return s(e,[{key:"init",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=n.prefix||"i18next:",this.logger=t||l,this.options=n,this.debug=n.debug}},{key:"setDebug",value:function e(t){this.debug=t}},{key:"log",value:function e(){for(var t=arguments.length,n=new Array(t),r=0;r1?n-1:0),i=1;i-1?e.replace(/###/g,"."):e}function i(){return!e||"string"==typeof e}for(var o="string"!=typeof t?[].concat(t):t.split(".");o.length>1;){if(i())return{};var s=r(o.shift());!e[s]&&n&&(e[s]=new n),e=Object.prototype.hasOwnProperty.call(e,s)?e[s]:{}}return i()?{}:{obj:e,k:r(o.shift())}}function y(e,t,n){var r=v(e,t,Object),i,o;r.obj[r.k]=n}function _(e,t,n,r){var i=v(e,t,Object),o=i.obj,s=i.k;o[s]=o[s]||[],r&&(o[s]=o[s].concat(n)),r||o[s].push(n)}function w(e,t){var n=v(e,t),r=n.obj,i=n.k;if(r)return r[i]}function k(e,t,n){var r=w(e,n);return void 0!==r?r:w(t,n)}function j(e,t,n){for(var r in t)"__proto__"!==r&&"constructor"!==r&&(r in e?"string"==typeof e[r]||e[r]instanceof String||"string"==typeof t[r]||t[r]instanceof String?n&&(e[r]=t[r]):j(e[r],t[r],n):e[r]=t[r]);return e}function x(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var S={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};function D(e){return"string"==typeof e?e.replace(/[&<>"'\/]/g,(function(e){return S[e]})):e}var E="undefined"!=typeof window&&window.navigator&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,A=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),n.data=e||{},n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n}return c(t,e),s(t,[{key:"addNamespaces",value:function e(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function e(t){var n=this.options.ns.indexOf(t);n>-1&&this.options.ns.splice(n,1)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==i.keySeparator?i.keySeparator:this.options.keySeparator,s=[t,n];return r&&"string"!=typeof r&&(s=s.concat(r)),r&&"string"==typeof r&&(s=s.concat(o?r.split(o):r)),t.indexOf(".")>-1&&(s=t.split(".")),w(this.data,s)}},{key:"addResource",value:function e(t,n,r,i){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},s=this.options.keySeparator;void 0===s&&(s=".");var a=[t,n];r&&(a=a.concat(s?r.split(s):r)),t.indexOf(".")>-1&&(i=n,n=(a=t.split("."))[1]),this.addNamespaces(n),y(this.data,a,i),o.silent||this.emit("added",t,n,r,i)}},{key:"addResources",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in r)"string"!=typeof r[o]&&"[object Array]"!==Object.prototype.toString.apply(r[o])||this.addResource(t,n,o,r[o],{silent:!0});i.silent||this.emit("added",t,n,r)}},{key:"addResourceBundle",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},u=[t,n];t.indexOf(".")>-1&&(o=r,r=n,n=(u=t.split("."))[1]),this.addNamespaces(n);var f=w(this.data,u)||{};o?j(f,r,s):f=i({},f,r),y(this.data,u,f),a.silent||this.emit("added",t,n,r)}},{key:"removeResourceBundle",value:function e(t,n){this.hasResourceBundle(t,n)&&delete this.data[t][n],this.removeNamespaces(n),this.emit("removed",t,n)}},{key:"hasResourceBundle",value:function e(t,n){return void 0!==this.getResource(t,n)}},{key:"getResourceBundle",value:function e(t,n){return n||(n=this.options.defaultNS),"v1"===this.options.compatibilityAPI?i({},{},this.getResource(t,n)):this.getResource(t,n)}},{key:"getDataByLanguage",value:function e(t){return this.data[t]}},{key:"toJSON",value:function e(){return this.data}}]),t}(p),C={processors:{},addPostProcessor:function e(t){this.processors[t.name]=t},handle:function e(t,n,r,i,o){var s=this;return t.forEach((function(e){s.processors[e]&&(n=s.processors[e].process(n,r,i,o))})),n}},M={},O=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),m(["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],e,f(n)),n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n.logger=d.create("translator"),n}return c(t,e),s(t,[{key:"changeLanguage",value:function e(t){t&&(this.language=t)}},{key:"exists",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}},r=this.resolve(t,n);return r&&void 0!==r.res}},{key:"extractFromKey",value:function e(t,n){var r=void 0!==n.nsSeparator?n.nsSeparator:this.options.nsSeparator;void 0===r&&(r=":");var i=void 0!==n.keySeparator?n.keySeparator:this.options.keySeparator,o=n.ns||this.options.defaultNS;if(r&&t.indexOf(r)>-1){var s=t.match(this.interpolator.nestingRegexp);if(s&&s.length>0)return{key:t,namespaces:o};var a=t.split(r);(r!==i||r===i&&this.options.ns.indexOf(a[0])>-1)&&(o=a.shift()),t=a.join(i)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function e(n,o,s){var a=this;if("object"!==r(o)&&this.options.overloadTranslationOptionHandler&&(o=this.options.overloadTranslationOptionHandler(arguments)),o||(o={}),null==n)return"";Array.isArray(n)||(n=[String(n)]);var u=void 0!==o.keySeparator?o.keySeparator:this.options.keySeparator,f=this.extractFromKey(n[n.length-1],o),c=f.key,l=f.namespaces,h=l[l.length-1],d=o.lng||this.language,p=o.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(d&&"cimode"===d.toLowerCase()){if(p){var g=o.nsSeparator||this.options.nsSeparator;return h+g+c}return c}var b=this.resolve(n,o),m=b&&b.res,v=b&&b.usedKey||c,y=b&&b.exactUsedKey||c,_=Object.prototype.toString.apply(m),w=["[object Number]","[object Function]","[object RegExp]"],k=void 0!==o.joinArrays?o.joinArrays:this.options.joinArrays,j=!this.i18nFormat||this.i18nFormat.handleAsObject,x="string"!=typeof m&&"boolean"!=typeof m&&"number"!=typeof m;if(j&&m&&x&&w.indexOf(_)<0&&("string"!=typeof k||"[object Array]"!==_)){if(!o.returnObjects&&!this.options.returnObjects)return this.logger.warn("accessing an object - but returnObjects options is not enabled!"),this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,m,o):"key '".concat(c," (").concat(this.language,")' returned an object instead of string.");if(u){var S="[object Array]"===_,D=S?[]:{},E=S?y:v;for(var A in m)if(Object.prototype.hasOwnProperty.call(m,A)){var C="".concat(E).concat(u).concat(A);D[A]=this.translate(C,i({},o,{joinArrays:!1,ns:l})),D[A]===C&&(D[A]=m[A])}m=D}}else if(j&&"string"==typeof k&&"[object Array]"===_)(m=m.join(k))&&(m=this.extendTranslation(m,n,o,s));else{var M=!1,O=!1,T=void 0!==o.count&&"string"!=typeof o.count,B=t.hasDefaultValue(o),I=T?this.pluralResolver.getSuffix(d,o.count):"",R=o["defaultValue".concat(I)]||o.defaultValue;!this.isValidLookup(m)&&B&&(M=!0,m=R),this.isValidLookup(m)||(O=!0,m=c);var F=B&&R!==m&&this.options.updateMissing;if(O||M||F){if(this.logger.log(F?"updateKey":"missingKey",d,h,c,F?R:m),u){var P=this.resolve(c,i({},o,{keySeparator:!1}));P&&P.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var N=[],L=this.languageUtils.getFallbackCodes(this.options.fallbackLng,o.lng||this.language);if("fallback"===this.options.saveMissingTo&&L&&L[0])for(var z=0;z1&&void 0!==arguments[1]?arguments[1]:{},i,o,s,a,u;return"string"==typeof t&&(t=[t]),t.forEach((function(e){if(!n.isValidLookup(i)){var t=n.extractFromKey(e,r),f=t.key;o=f;var c=t.namespaces;n.options.fallbackNS&&(c=c.concat(n.options.fallbackNS));var l=void 0!==r.count&&"string"!=typeof r.count,h=void 0!==r.context&&"string"==typeof r.context&&""!==r.context,d=r.lngs?r.lngs:n.languageUtils.toResolveHierarchy(r.lng||n.language,r.fallbackLng);c.forEach((function(e){n.isValidLookup(i)||(u=e,!M["".concat(d[0],"-").concat(e)]&&n.utils&&n.utils.hasLoadedNamespace&&!n.utils.hasLoadedNamespace(u)&&(M["".concat(d[0],"-").concat(e)]=!0,n.logger.warn('key "'.concat(o,'" for languages "').concat(d.join(", "),'" won\'t get resolved as namespace "').concat(u,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),d.forEach((function(t){if(!n.isValidLookup(i)){a=t;var o=f,u=[o],c,d;if(n.i18nFormat&&n.i18nFormat.addLookupKeys)n.i18nFormat.addLookupKeys(u,f,t,e,r);else l&&(c=n.pluralResolver.getSuffix(t,r.count)),l&&h&&u.push(o+c),h&&u.push(o+="".concat(n.options.contextSeparator).concat(r.context)),l&&u.push(o+=c);for(;d=u.pop();)n.isValidLookup(i)||(s=d,i=n.getResource(t,e,d,r))}})))}))}})),{res:i,usedKey:o,exactUsedKey:s,usedLng:a,usedNS:u}}},{key:"isValidLookup",value:function e(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,n,r,i):this.resourceStore.getResource(t,n,r,i)}}],[{key:"hasDefaultValue",value:function e(t){var n="defaultValue";for(var r in t)if(Object.prototype.hasOwnProperty.call(t,r)&&n===r.substring(0,n.length)&&void 0!==t[r])return!0;return!1}}]),t}(p);function T(e){return e.charAt(0).toUpperCase()+e.slice(1)}var B=function(){function e(t){o(this,e),this.options=t,this.whitelist=this.options.supportedLngs||!1,this.supportedLngs=this.options.supportedLngs||!1,this.logger=d.create("languageUtils")}return s(e,[{key:"getScriptPartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return null;var n=t.split("-");return 2===n.length?null:(n.pop(),"x"===n[n.length-1].toLowerCase()?null:this.formatLanguageCode(n.join("-")))}},{key:"getLanguagePartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return t;var n=t.split("-");return this.formatLanguageCode(n[0])}},{key:"formatLanguageCode",value:function e(t){if("string"==typeof t&&t.indexOf("-")>-1){var n=["hans","hant","latn","cyrl","cans","mong","arab"],r=t.split("-");return this.options.lowerCaseLng?r=r.map((function(e){return e.toLowerCase()})):2===r.length?(r[0]=r[0].toLowerCase(),r[1]=r[1].toUpperCase(),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase()))):3===r.length&&(r[0]=r[0].toLowerCase(),2===r[1].length&&(r[1]=r[1].toUpperCase()),"sgn"!==r[0]&&2===r[2].length&&(r[2]=r[2].toUpperCase()),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase())),n.indexOf(r[2].toLowerCase())>-1&&(r[2]=T(r[2].toLowerCase()))),r.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isWhitelisted",value:function e(t){return this.logger.deprecate("languageUtils.isWhitelisted",'function "isWhitelisted" will be renamed to "isSupportedCode" in the next major - please make sure to rename it\'s usage asap.'),this.isSupportedCode(t)}},{key:"isSupportedCode",value:function e(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function e(t){var n=this,r;return t?(t.forEach((function(e){if(!r){var t=n.formatLanguageCode(e);n.options.supportedLngs&&!n.isSupportedCode(t)||(r=t)}})),!r&&this.options.supportedLngs&&t.forEach((function(e){if(!r){var t=n.getLanguagePartFromCode(e);if(n.isSupportedCode(t))return r=t;r=n.options.supportedLngs.find((function(e){if(0===e.indexOf(t))return e}))}})),r||(r=this.getFallbackCodes(this.options.fallbackLng)[0]),r):null}},{key:"getFallbackCodes",value:function e(t,n){if(!t)return[];if("function"==typeof t&&(t=t(n)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!n)return t.default||[];var r=t[n];return r||(r=t[this.getScriptPartFromCode(n)]),r||(r=t[this.formatLanguageCode(n)]),r||(r=t[this.getLanguagePartFromCode(n)]),r||(r=t.default),r||[]}},{key:"toResolveHierarchy",value:function e(t,n){var r=this,i=this.getFallbackCodes(n||this.options.fallbackLng||[],t),o=[],s=function e(t){t&&(r.isSupportedCode(t)?o.push(t):r.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&s(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&s(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&s(this.getLanguagePartFromCode(t))):"string"==typeof t&&s(this.formatLanguageCode(t)),i.forEach((function(e){o.indexOf(e)<0&&s(r.formatLanguageCode(e))})),o}}]),e}(),I=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","kk","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],R={1:function e(t){return Number(t>1)},2:function e(t){return Number(1!=t)},3:function e(t){return 0},4:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function e(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function e(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function e(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function e(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function e(t){return Number(t>=2)},10:function e(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function e(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function e(t){return Number(t%10!=1||t%100==11)},13:function e(t){return Number(0!==t)},14:function e(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function e(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function e(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function e(t){return Number(0==t?0:1==t?1:2)},19:function e(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function e(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function e(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function e(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}};function F(){var e={};return I.forEach((function(t){t.lngs.forEach((function(n){e[n]={numbers:t.nr,plurals:R[t.fc]}}))})),e}var P=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.languageUtils=t,this.options=n,this.logger=d.create("pluralResolver"),this.rules=F()}return s(e,[{key:"addRule",value:function e(t,n){this.rules[t]=n}},{key:"getRule",value:function e(t){return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function e(t){var n=this.getRule(t);return n&&n.numbers.length>1}},{key:"getPluralFormsOfKey",value:function e(t,n){return this.getSuffixes(t).map((function(e){return n+e}))}},{key:"getSuffixes",value:function e(t){var n=this,r=this.getRule(t);return r?r.numbers.map((function(e){return n.getSuffix(t,e)})):[]}},{key:"getSuffix",value:function e(t,n){var r=this,i=this.getRule(t);if(i){var o=i.noAbs?i.plurals(n):i.plurals(Math.abs(n)),s=i.numbers[o];this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]&&(2===s?s="plural":1===s&&(s=""));var a=function e(){return r.options.prepend&&s.toString()?r.options.prepend+s.toString():s.toString()};return"v1"===this.options.compatibilityJSON?1===s?"":"number"==typeof s?"_plural_".concat(s.toString()):a():"v2"===this.options.compatibilityJSON?a():this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]?a():this.options.prepend&&o.toString()?this.options.prepend+o.toString():o.toString()}return this.logger.warn("no plural rule found for: ".concat(t)),""}}]),e}(),N=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};o(this,e),this.logger=d.create("interpolator"),this.options=t,this.format=t.interpolation&&t.interpolation.format||function(e){return e},this.init(t)}return s(e,[{key:"init",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var n=t.interpolation;this.escape=void 0!==n.escape?n.escape:D,this.escapeValue=void 0===n.escapeValue||n.escapeValue,this.useRawValueToEscape=void 0!==n.useRawValueToEscape&&n.useRawValueToEscape,this.prefix=n.prefix?x(n.prefix):n.prefixEscaped||"{{",this.suffix=n.suffix?x(n.suffix):n.suffixEscaped||"}}",this.formatSeparator=n.formatSeparator?n.formatSeparator:n.formatSeparator||",",this.unescapePrefix=n.unescapeSuffix?"":n.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":n.unescapeSuffix||"",this.nestingPrefix=n.nestingPrefix?x(n.nestingPrefix):n.nestingPrefixEscaped||x("$t("),this.nestingSuffix=n.nestingSuffix?x(n.nestingSuffix):n.nestingSuffixEscaped||x(")"),this.nestingOptionsSeparator=n.nestingOptionsSeparator?n.nestingOptionsSeparator:n.nestingOptionsSeparator||",",this.maxReplaces=n.maxReplaces?n.maxReplaces:1e3,this.alwaysFormat=void 0!==n.alwaysFormat&&n.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function e(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function e(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var n="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(n,"g");var r="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(r,"g")}},{key:"interpolate",value:function e(t,n,r,i){var o=this,s,a,u,f=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function c(e){return e.replace(/\$/g,"$$$$")}var l=function e(t){if(t.indexOf(o.formatSeparator)<0){var s=k(n,f,t);return o.alwaysFormat?o.format(s,void 0,r):s}var a=t.split(o.formatSeparator),u=a.shift().trim(),c=a.join(o.formatSeparator).trim();return o.format(k(n,f,u),c,r,i)};this.resetRegExp();var h=i&&i.missingInterpolationHandler||this.options.missingInterpolationHandler,d=i&&i.interpolation&&i.interpolation.skipOnVariables||this.options.interpolation.skipOnVariables,p;return[{regex:this.regexpUnescape,safeValue:function e(t){return c(t)}},{regex:this.regexp,safeValue:function e(t){return o.escapeValue?c(o.escape(t)):c(t)}}].forEach((function(e){for(u=0;s=e.regex.exec(t);){if(void 0===(a=l(s[1].trim())))if("function"==typeof h){var n=h(t,s,i);a="string"==typeof n?n:""}else{if(d){a=s[0];continue}o.logger.warn("missed to pass in variable ".concat(s[1]," for interpolating ").concat(t)),a=""}else"string"==typeof a||o.useRawValueToEscape||(a=b(a));if(t=t.replace(s[0],e.safeValue(a)),e.regex.lastIndex=0,++u>=o.maxReplaces)break}})),t}},{key:"nest",value:function e(t,n){var r=this,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},s,a,u=i({},o);function f(e,t){var n=this.nestingOptionsSeparator;if(e.indexOf(n)<0)return e;var r=e.split(new RegExp("".concat(n,"[ ]*{"))),o="{".concat(r[1]);e=r[0],o=(o=this.interpolate(o,u)).replace(/'/g,'"');try{u=JSON.parse(o),t&&(u=i({},t,u))}catch(s){return this.logger.warn("failed parsing options string in nesting for key ".concat(e),s),"".concat(e).concat(n).concat(o)}return delete u.defaultValue,e}for(u.applyPostProcessor=!1,delete u.defaultValue;s=this.nestingRegexp.exec(t);){var c=[],l=!1;if(s[0].includes(this.formatSeparator)&&!/{.*}/.test(s[1])){var h=s[1].split(this.formatSeparator).map((function(e){return e.trim()}));s[1]=h.shift(),c=h,l=!0}if((a=n(f.call(this,s[1].trim(),u),u))&&s[0]===t&&"string"!=typeof a)return a;"string"!=typeof a&&(a=b(a)),a||(this.logger.warn("missed to resolve ".concat(s[1]," for nesting ").concat(t)),a=""),l&&(a=c.reduce((function(e,t){return r.format(e,t,o.lng,o)}),a.trim())),t=t.replace(s[0],a),this.regexp.lastIndex=0}return t}}]),e}();function L(e,t){for(var n=e.indexOf(t);-1!==n;)e.splice(n,1),n=e.indexOf(t)}var z=function(e){function t(e,n,r){var i,s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return o(this,t),i=a(this,u(t).call(this)),E&&p.call(f(i)),i.backend=e,i.store=n,i.services=r,i.languageUtils=r.languageUtils,i.options=s,i.logger=d.create("backendConnector"),i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(r,s.backend,s),i}return c(t,e),s(t,[{key:"queueLoad",value:function e(t,n,r,i){var o=this,s=[],a=[],u=[],f=[];return t.forEach((function(e){var t=!0;n.forEach((function(n){var i="".concat(e,"|").concat(n);!r.reload&&o.store.hasResourceBundle(e,n)?o.state[i]=2:o.state[i]<0||(1===o.state[i]?a.indexOf(i)<0&&a.push(i):(o.state[i]=1,t=!1,a.indexOf(i)<0&&a.push(i),s.indexOf(i)<0&&s.push(i),f.indexOf(n)<0&&f.push(n)))})),t||u.push(e)})),(s.length||a.length)&&this.queue.push({pending:a,loaded:{},errors:[],callback:i}),{toLoad:s,pending:a,toLoadLanguages:u,toLoadNamespaces:f}}},{key:"loaded",value:function e(t,n,r){var i=t.split("|"),o=i[0],s=i[1];n&&this.emit("failedLoading",o,s,n),r&&this.store.addResourceBundle(o,s,r),this.state[t]=n?-1:2;var e={};this.queue.forEach((function(r){_(r.loaded,[o],s),L(r.pending,t),n&&r.errors.push(n),0!==r.pending.length||r.done||(Object.keys(r.loaded).forEach((function(t){e[t]||(e[t]=[]),r.loaded[t].length&&r.loaded[t].forEach((function(n){e[t].indexOf(n)<0&&e[t].push(n)}))})),r.done=!0,r.errors.length?r.callback(r.errors):r.callback())})),this.emit("loaded",e),this.queue=this.queue.filter((function(e){return!e.done}))}},{key:"read",value:function e(t,n,r){var i=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:350,a=arguments.length>5?arguments[5]:void 0;return t.length?this.backend[r](t,n,(function(e,u){e&&u&&o<5?setTimeout((function(){i.read.call(i,t,n,r,o+1,2*s,a)}),s):a(e,u)})):a(null,{})}},{key:"prepareLoading",value:function e(t,n){var r=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof n&&(n=[n]);var s=this.queueLoad(t,n,i,o);if(!s.toLoad.length)return s.pending.length||o(),null;s.toLoad.forEach((function(e){r.loadOne(e)}))}},{key:"load",value:function e(t,n,r){this.prepareLoading(t,n,{},r)}},{key:"reload",value:function e(t,n,r){this.prepareLoading(t,n,{reload:!0},r)}},{key:"loadOne",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=t.split("|"),o=i[0],s=i[1];this.read(o,s,"read",void 0,void 0,(function(e,i){e&&n.logger.warn("".concat(r,"loading namespace ").concat(s," for language ").concat(o," failed"),e),!e&&i&&n.logger.log("".concat(r,"loaded namespace ").concat(s," for language ").concat(o),i),n.loaded(t,e,i)}))}},{key:"saveMissing",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(n)?this.logger.warn('did not save key "'.concat(r,'" as the namespace "').concat(n,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=r&&""!==r&&(this.backend&&this.backend.create&&this.backend.create(t,n,r,o,null,i({},a,{isUpdate:s})),t&&t[0]&&this.store.addResource(t[0],n,r,o))}}]),t}(p);function U(){return{debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,whitelist:!1,nonExplicitWhitelist:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function e(t){var n={};if("object"===r(t[1])&&(n=t[1]),"string"==typeof t[1]&&(n.defaultValue=t[1]),"string"==typeof t[2]&&(n.tDescription=t[2]),"object"===r(t[2])||"object"===r(t[3])){var i=t[3]||t[2];Object.keys(i).forEach((function(e){n[e]=i[e]}))}return n},interpolation:{escapeValue:!0,format:function e(t,n,r,i){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!1}}}function q(e){return"string"==typeof e.ns&&(e.ns=[e.ns]),"string"==typeof e.fallbackLng&&(e.fallbackLng=[e.fallbackLng]),"string"==typeof e.fallbackNS&&(e.fallbackNS=[e.fallbackNS]),e.whitelist&&(e.whitelist&&e.whitelist.indexOf("cimode")<0&&(e.whitelist=e.whitelist.concat(["cimode"])),e.supportedLngs=e.whitelist),e.nonExplicitWhitelist&&(e.nonExplicitSupportedLngs=e.nonExplicitWhitelist),e.supportedLngs&&e.supportedLngs.indexOf("cimode")<0&&(e.supportedLngs=e.supportedLngs.concat(["cimode"])),e}function $(){}var W,H=new(function(e){function t(){var e,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;if(o(this,t),e=a(this,u(t).call(this)),E&&p.call(f(e)),e.options=q(n),e.services={},e.logger=d,e.modules={external:[]},r&&!e.isInitialized&&!n.isClone){if(!e.options.initImmediate)return e.init(n,r),a(e,f(e));setTimeout((function(){e.init(n,r)}),0)}return e}return c(t,e),s(t,[{key:"init",value:function e(){var t=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;function o(e){return e?"function"==typeof e?new e:e:null}if("function"==typeof n&&(r=n,n={}),n.whitelist&&!n.supportedLngs&&this.logger.deprecate("whitelist",'option "whitelist" will be renamed to "supportedLngs" in the next major - please make sure to rename this option asap.'),n.nonExplicitWhitelist&&!n.nonExplicitSupportedLngs&&this.logger.deprecate("whitelist",'options "nonExplicitWhitelist" will be renamed to "nonExplicitSupportedLngs" in the next major - please make sure to rename this option asap.'),this.options=i({},U(),this.options,q(n)),this.format=this.options.interpolation.format,r||(r=$),!this.options.isClone){this.modules.logger?d.init(o(this.modules.logger),this.options):d.init(null,this.options);var s=new B(this.options);this.store=new A(this.options.resources,this.options);var a=this.services;a.logger=d,a.resourceStore=this.store,a.languageUtils=s,a.pluralResolver=new P(s,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),a.interpolator=new N(this.options),a.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},a.backendConnector=new z(o(this.modules.backend),a.resourceStore,a,this.options),a.backendConnector.on("*",(function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),i=1;i1?n-1:0),i=1;i0&&"dev"!==u[0]&&(this.options.lng=u[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined");var f=["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"];f.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments)}}));var c=["addResource","addResources","addResourceBundle","removeResourceBundle"];c.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments),t}}));var l=g(),h=function e(){var n=function e(n,i){t.isInitialized&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),l.resolve(i),r(n,i)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return n(null,t.t.bind(t));t.changeLanguage(t.options.lng,n)};return this.options.resources||!this.options.initImmediate?h():setTimeout(h,0),l}},{key:"loadResources",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,i=r,o="string"==typeof t?t:this.language;if("function"==typeof t&&(i=t),!this.options.resources||this.options.partialBundledLanguages){if(o&&"cimode"===o.toLowerCase())return i();var s=[],a=function e(t){var r;t&&n.services.languageUtils.toResolveHierarchy(t).forEach((function(e){s.indexOf(e)<0&&s.push(e)}))};if(o)a(o);else{var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.forEach((function(e){return a(e)}))}this.options.preload&&this.options.preload.forEach((function(e){return a(e)})),this.services.backendConnector.load(s,this.options.ns,i)}else i(null)}},{key:"reloadResources",value:function e(t,n,r){var i=g();return t||(t=this.languages),n||(n=this.options.ns),r||(r=$),this.services.backendConnector.reload(t,n,(function(e){i.resolve(),r(e)})),i}},{key:"use",value:function e(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&C.addPostProcessor(t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"changeLanguage",value:function e(t,n){var r=this;this.isLanguageChangingTo=t;var i=g();this.emit("languageChanging",t);var o=function e(t,o){o?(r.language=o,r.languages=r.services.languageUtils.toResolveHierarchy(o),r.translator.changeLanguage(o),r.isLanguageChangingTo=void 0,r.emit("languageChanged",o),r.logger.log("languageChanged",o)):r.isLanguageChangingTo=void 0,i.resolve((function(){return r.t.apply(r,arguments)})),n&&n(t,(function(){return r.t.apply(r,arguments)}))},s=function e(t){var n="string"==typeof t?t:r.services.languageUtils.getBestMatchFromCodes(t);n&&(r.language||(r.language=n,r.languages=r.services.languageUtils.toResolveHierarchy(n)),r.translator.language||r.translator.changeLanguage(n),r.services.languageDetector&&r.services.languageDetector.cacheUserLanguage(n)),r.loadResources(n,(function(e){o(e,n)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(s):s(t):s(this.services.languageDetector.detect()),i}},{key:"getFixedT",value:function e(t,n){var o=this,s=function e(t,n){var s;if("object"!==r(n)){for(var a=arguments.length,u=new Array(a>2?a-2:0),f=2;f1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var i=this.languages[0],o=!!this.options&&this.options.fallbackLng,s=this.languages[this.languages.length-1];if("cimode"===i.toLowerCase())return!0;var a=function e(t,r){var i=n.services.backendConnector.state["".concat(t,"|").concat(r)];return-1===i||2===i};if(r.precheck){var u=r.precheck(this,a);if(void 0!==u)return u}return!!this.hasResourceBundle(i,t)||(!this.services.backendConnector.backend||!(!a(i,t)||o&&!a(s,t)))}},{key:"loadNamespaces",value:function e(t,n){var r=this,i=g();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(e){r.options.ns.indexOf(e)<0&&r.options.ns.push(e)})),this.loadResources((function(e){i.resolve(),n&&n(e)})),i):(n&&n(),Promise.resolve())}},{key:"loadLanguages",value:function e(t,n){var r=g();"string"==typeof t&&(t=[t]);var i=this.options.preload||[],o=t.filter((function(e){return i.indexOf(e)<0}));return o.length?(this.options.preload=i.concat(o),this.loadResources((function(e){r.resolve(),n&&n(e)})),r):(n&&n(),Promise.resolve())}},{key:"dir",value:function e(t){return t||(t=this.languages&&this.languages.length>0?this.languages[0]:this.language),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>=0?"rtl":"ltr":"rtl";var n}},{key:"createInstance",value:function e(){var n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;return new t(n,r)}},{key:"cloneInstance",value:function e(){var n=this,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,s=i({},this.options,r,{isClone:!0}),a=new t(s),u=["store","services","language"];return u.forEach((function(e){a[e]=n[e]})),a.services=i({},this.services),a.services.utils={hasLoadedNamespace:a.hasLoadedNamespace.bind(a)},a.translator=new O(a.services,a.options),a.translator.on("*",(function(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;rr,root:()=>i,ArrayProto:()=>o,ObjProto:()=>s,SymbolProto:()=>a,push:()=>u,slice:()=>f,toString:()=>c,hasOwnProperty:()=>l,supportsArrayBuffer:()=>h,supportsDataView:()=>d,nativeIsArray:()=>p,nativeKeys:()=>g,nativeCreate:()=>b,nativeIsView:()=>m,_isNaN:()=>v,_isFinite:()=>y,hasEnumBug:()=>_,nonEnumerableProps:()=>w,MAX_ARRAY_INDEX:()=>k});var r="1.13.4",i="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},o=Array.prototype,s=Object.prototype,a="undefined"!=typeof Symbol?Symbol.prototype:null,u=o.push,f=o.slice,c=s.toString,l=s.hasOwnProperty,h="undefined"!=typeof ArrayBuffer,d="undefined"!=typeof DataView,p=Array.isArray,g=Object.keys,b=Object.create,m=h&&ArrayBuffer.isView,v=isNaN,y=isFinite,_=!{toString:null}.propertyIsEnumerable("toString"),w=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],k=Math.pow(2,53)-1},"restArguments.js":function e(t,n,e){function r(e,t){return t=null==t?e.length-1:+t,function(){for(var n=Math.max(arguments.length-t,0),r=Array(n),i=0;ir})},"isObject.js":function e(t,n,e){function r(e){var t=typeof e;return"function"===t||"object"===t&&!!e}e.export({default:()=>r})},"isNull.js":function e(t,n,e){function r(e){return null===e}e.export({default:()=>r})},"isUndefined.js":function e(t,n,e){function r(e){return void 0===e}e.export({default:()=>r})},"isBoolean.js":function e(t,n,e){let r;function i(e){return!0===e||!1===e||"[object Boolean]"===r.call(e)}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isElement.js":function e(t,n,e){function r(e){return!(!e||1!==e.nodeType)}e.export({default:()=>r})},"isString.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("String"))},"_tagTester.js":function e(t,n,e){let r;function i(e){var t="[object "+e+"]";return function(e){return r.call(e)===t}}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isNumber.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Number"))},"isDate.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Date"))},"isRegExp.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("RegExp"))},"isError.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Error"))},"isSymbol.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Symbol"))},"isArrayBuffer.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("ArrayBuffer"))},"isDataView.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isArrayBuffer.js",{default(e){o=e}},2),e.link("./_stringTagBug.js",{hasStringTagBug(e){s=e}},3);var a=r("DataView");function u(e){return null!=e&&i(e.getInt8)&&o(e.buffer)}e.exportDefault(s?u:a)},"isFunction.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_setup.js",{root(e){i=e}},1);var o=r("Function"),s=i.document&&i.document.childNodes;"function"!=typeof/./&&"object"!=typeof Int8Array&&"function"!=typeof s&&(o=function(e){return"function"==typeof e||!1}),e.exportDefault(o)},"_stringTagBug.js":function e(t,n,e){let r,i;e.export({hasStringTagBug:()=>o,isIE11:()=>s}),e.link("./_setup.js",{supportsDataView(e){r=e}},0),e.link("./_hasObjectTag.js",{default(e){i=e}},1);var o=r&&i(new DataView(new ArrayBuffer(8))),s="undefined"!=typeof Map&&i(new Map)},"_hasObjectTag.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Object"))},"isArray.js":function e(t,n,e){let r,i;e.link("./_setup.js",{nativeIsArray(e){r=e}},0),e.link("./_tagTester.js",{default(e){i=e}},1),e.exportDefault(r||i("Array"))},"isArguments.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1);var o=r("Arguments");!function(){o(arguments)||(o=function(e){return i(e,"callee")})}(),e.exportDefault(o)},"_has.js":function e(t,n,e){let r;function i(e,t){return null!=e&&r.call(e,t)}e.export({default:()=>i}),e.link("./_setup.js",{hasOwnProperty(e){r=e}},0)},"isFinite.js":function e(t,n,e){let r,i;function o(e){return!i(e)&&r(e)&&!isNaN(parseFloat(e))}e.export({default:()=>o}),e.link("./_setup.js",{_isFinite(e){r=e}},0),e.link("./isSymbol.js",{default(e){i=e}},1)},"isNaN.js":function e(t,n,e){let r,i;function o(e){return i(e)&&r(e)}e.export({default:()=>o}),e.link("./_setup.js",{_isNaN(e){r=e}},0),e.link("./isNumber.js",{default(e){i=e}},1)},"isTypedArray.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./_setup.js",{supportsArrayBuffer(e){r=e},nativeIsView(e){i=e},toString(e){o=e}},0),e.link("./isDataView.js",{default(e){s=e}},1),e.link("./constant.js",{default(e){a=e}},2),e.link("./_isBufferLike.js",{default(e){u=e}},3);var f=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;function c(e){return i?i(e)&&!s(e):u(e)&&f.test(o.call(e))}e.exportDefault(r?c:a(!1))},"constant.js":function e(t,n,e){function r(e){return function(){return e}}e.export({default:()=>r})},"_isBufferLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getByteLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createSizePropertyCheck.js":function e(t,n,e){let r;function i(e){return function(t){var n=e(t);return"number"==typeof n&&n>=0&&n<=r}}e.export({default:()=>i}),e.link("./_setup.js",{MAX_ARRAY_INDEX(e){r=e}},0)},"_getByteLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("byteLength"))},"_shallowProperty.js":function e(t,n,e){function r(e){return function(t){return null==t?void 0:t[e]}}e.export({default:()=>r})},"isEmpty.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(null==e)return!0;var t=r(e);return"number"==typeof t&&(i(e)||o(e)||s(e))?0===t:0===r(a(e))}e.export({default:()=>u}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3),e.link("./keys.js",{default(e){a=e}},4)},"_getLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("length"))},"keys.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(!r(e))return[];if(i)return i(e);var t=[];for(var n in e)s(e,n)&&t.push(n);return o&&a(e,t),t}e.export({default:()=>u}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeKeys(e){i=e},hasEnumBug(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2),e.link("./_collectNonEnumProps.js",{default(e){a=e}},3)},"_collectNonEnumProps.js":function e(t,n,e){let r,i,o,s;function a(e){for(var t={},n=e.length,r=0;ru}),e.link("./_setup.js",{nonEnumerableProps(e){r=e},ObjProto(e){i=e}},0),e.link("./isFunction.js",{default(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2)},"isMatch.js":function e(t,n,e){let r;function i(e,t){var n=r(t),i=n.length;if(null==e)return!i;for(var o=Object(e),s=0;si}),e.link("./keys.js",{default(e){r=e}},0)},"isEqual.js":function e(t,n,e){let r,i,o,s,a,u,f,c,l,h,d;e.export({default:()=>m}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_setup.js",{toString(e){i=e},SymbolProto(e){o=e}},1),e.link("./_getByteLength.js",{default(e){s=e}},2),e.link("./isTypedArray.js",{default(e){a=e}},3),e.link("./isFunction.js",{default(e){u=e}},4),e.link("./_stringTagBug.js",{hasStringTagBug(e){f=e}},5),e.link("./isDataView.js",{default(e){c=e}},6),e.link("./keys.js",{default(e){l=e}},7),e.link("./_has.js",{default(e){h=e}},8),e.link("./_toBufferView.js",{default(e){d=e}},9);var p="[object DataView]";function g(e,t,n,r){if(e===t)return 0!==e||1/e==1/t;if(null==e||null==t)return!1;if(e!=e)return t!=t;var i=typeof e;return("function"===i||"object"===i||"object"==typeof t)&&b(e,t,n,r)}function b(e,t,n,m){e instanceof r&&(e=e._wrapped),t instanceof r&&(t=t._wrapped);var v=i.call(e);if(v!==i.call(t))return!1;if(f&&"[object Object]"==v&&c(e)){if(!c(t))return!1;v=p}switch(v){case"[object RegExp]":case"[object String]":return""+e==""+t;case"[object Number]":return+e!=+e?+t!=+t:0==+e?1/+e==1/t:+e==+t;case"[object Date]":case"[object Boolean]":return+e==+t;case"[object Symbol]":return o.valueOf.call(e)===o.valueOf.call(t);case"[object ArrayBuffer]":case p:return b(d(e),d(t),n,m)}var y="[object Array]"===v;if(!y&&a(e)){var _;if(s(e)!==s(t))return!1;if(e.buffer===t.buffer&&e.byteOffset===t.byteOffset)return!0;y=!0}if(!y){if("object"!=typeof e||"object"!=typeof t)return!1;var w=e.constructor,k=t.constructor;if(w!==k&&!(u(w)&&w instanceof w&&u(k)&&k instanceof k)&&"constructor"in e&&"constructor"in t)return!1}m=m||[];for(var j=(n=n||[]).length;j--;)if(n[j]===e)return m[j]===t;if(n.push(e),m.push(t),y){if((j=e.length)!==t.length)return!1;for(;j--;)if(!g(e[j],t[j],n,m))return!1}else{var x=l(e),S;if(j=x.length,l(t).length!==j)return!1;for(;j--;)if(S=x[j],!h(t,S)||!g(e[S],t[S],n,m))return!1}return n.pop(),m.pop(),!0}function m(e,t){return g(e,t)}},"underscore.js":function e(t,n,e){let r;function i(e){return e instanceof i?e:this instanceof i?void(this._wrapped=e):new i(e)}e.export({default:()=>i}),e.link("./_setup.js",{VERSION(e){r=e}},0),i.VERSION=r,i.prototype.value=function(){return this._wrapped},i.prototype.valueOf=i.prototype.toJSON=i.prototype.value,i.prototype.toString=function(){return String(this._wrapped)}},"_toBufferView.js":function e(t,n,e){let r;function i(e){return new Uint8Array(e.buffer||e,e.byteOffset||0,r(e))}e.export({default:()=>i}),e.link("./_getByteLength.js",{default(e){r=e}},0)},"isMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},mapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Map"))},"_methodFingerprint.js":function e(t,n,e){let r,i,o;function s(e){var t=r(e);return function(n){if(null==n)return!1;var s=o(n);if(r(s))return!1;for(var u=0;us,mapMethods:()=>l,weakMapMethods:()=>h,setMethods:()=>d}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./allKeys.js",{default(e){o=e}},2);var a="forEach",u="has",f=["clear","delete"],c=["get","has","set"],l=f.concat(a,c),h=f.concat(c),d=["add"].concat(f,a,"has")},"allKeys.js":function e(t,n,e){let r,i,o;function s(e){if(!r(e))return[];var t=[];for(var n in e)t.push(n);return i&&o(e,t),t}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{hasEnumBug(e){i=e}},1),e.link("./_collectNonEnumProps.js",{default(e){o=e}},2)},"isWeakMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},weakMapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("WeakMap"))},"isSet.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},setMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Set"))},"isWeakSet.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("WeakSet"))},"values.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"pairs.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"invert.js":function e(t,n,e){let r;function i(e){for(var t={},n=r(e),i=0,o=n.length;ii}),e.link("./keys.js",{default(e){r=e}},0)},"functions.js":function e(t,n,e){let r;function i(e){var t=[];for(var n in e)r(e[n])&&t.push(n);return t.sort()}e.export({default:()=>i}),e.link("./isFunction.js",{default(e){r=e}},0)},"extend.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createAssigner.js":function e(t,n,e){function r(e,t){return function(n){var r=arguments.length;if(t&&(n=Object(n)),r<2||null==n)return n;for(var i=1;ir})},"extendOwn.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"defaults.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i,!0))},"create.js":function e(t,n,e){let r,i;function o(e,t){var n=r(e);return t&&i(n,t),n}e.export({default:()=>o}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./extendOwn.js",{default(e){i=e}},1)},"_baseCreate.js":function e(t,n,e){let r,i;function o(){return function(){}}function s(e){if(!r(e))return{};if(i)return i(e);var t=function(){};t.prototype=e;var n=new t;return t.prototype=null,n}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeCreate(e){i=e}},1)},"clone.js":function e(t,n,e){let r,i,o;function s(e){return r(e)?i(e)?e.slice():o({},e):e}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./extend.js",{default(e){o=e}},2)},"tap.js":function e(t,n,e){function r(e,t){return t(e),e}e.export({default:()=>r})},"get.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=i(e,r(t));return o(s)?n:s}e.export({default:()=>s}),e.link("./_toPath.js",{default(e){r=e}},0),e.link("./_deepGet.js",{default(e){i=e}},1),e.link("./isUndefined.js",{default(e){o=e}},2)},"_toPath.js":function e(t,n,e){let r;function i(e){return r.toPath(e)}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./toPath.js")},"toPath.js":function e(t,n,e){let r,i;function o(e){return i(e)?e:[e]}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),r.toPath=o},"_deepGet.js":function e(t,n,e){function r(e,t){for(var n=t.length,r=0;rr})},"has.js":function e(t,n,e){let r,i;function o(e,t){for(var n=(t=i(t)).length,o=0;oo}),e.link("./_has.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"mapObject.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s=o.length,a={},u=0;uo}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"_cb.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r.iteratee!==o?r.iteratee(e,t):i(e,t,n)}e.export({default:()=>s}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),e.link("./iteratee.js",{default(e){o=e}},2)},"_baseIteratee.js":function e(t,n,e){let r,i,o,s,a,u,f;function c(e,t,n){return null==e?r:i(e)?f(e,t,n):o(e)&&!s(e)?a(e):u(e)}e.export({default:()=>c}),e.link("./identity.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isObject.js",{default(e){o=e}},2),e.link("./isArray.js",{default(e){s=e}},3),e.link("./matcher.js",{default(e){a=e}},4),e.link("./property.js",{default(e){u=e}},5),e.link("./_optimizeCb.js",{default(e){f=e}},6)},"identity.js":function e(t,n,e){function r(e){return e}e.export({default:()=>r})},"matcher.js":function e(t,n,e){let r,i;function o(e){return e=r({},e),function(t){return i(t,e)}}e.export({default:()=>o}),e.link("./extendOwn.js",{default(e){r=e}},0),e.link("./isMatch.js",{default(e){i=e}},1)},"property.js":function e(t,n,e){let r,i;function o(e){return e=i(e),function(t){return r(t,e)}}e.export({default:()=>o}),e.link("./_deepGet.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"_optimizeCb.js":function e(t,n,e){function r(e,t,n){if(void 0===t)return e;switch(null==n?3:n){case 1:return function(n){return e.call(t,n)};case 3:return function(n,r,i){return e.call(t,n,r,i)};case 4:return function(n,r,i,o){return e.call(t,n,r,i,o)}}return function(){return e.apply(t,arguments)}}e.export({default:()=>r})},"iteratee.js":function e(t,n,e){let r,i;function o(e,t){return i(e,t,1/0)}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),r.iteratee=o},"noop.js":function e(t,n,e){function r(){}e.export({default:()=>r})},"propertyOf.js":function e(t,n,e){let r,i;function o(e){return null==e?r:function(t){return i(e,t)}}e.export({default:()=>o}),e.link("./noop.js",{default(e){r=e}},0),e.link("./get.js",{default(e){i=e}},1)},"times.js":function e(t,n,e){let r;function i(e,t,n){var i=Array(Math.max(0,e));t=r(t,n,1);for(var o=0;oi}),e.link("./_optimizeCb.js",{default(e){r=e}},0)},"random.js":function e(t,n,e){function r(e,t){return null==t&&(t=e,e=0),e+Math.floor(Math.random()*(t-e+1))}e.export({default:()=>r})},"now.js":function e(t,n,e){e.exportDefault(Date.now||function(){return(new Date).getTime()})},"escape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createEscaper.js":function e(t,n,e){let r;function i(e){var t=function(t){return e[t]},n="(?:"+r(e).join("|")+")",i=RegExp(n),o=RegExp(n,"g");return function(e){return e=null==e?"":""+e,i.test(e)?e.replace(o,t):e}}e.export({default:()=>i}),e.link("./keys.js",{default(e){r=e}},0)},"_escapeMap.js":function e(t,n,e){e.exportDefault({"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"})},"unescape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_unescapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_unescapeMap.js":function e(t,n,e){let r,i;e.link("./invert.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"templateSettings.js":function e(t,n,e){let r;e.link("./underscore.js",{default(e){r=e}},0),e.exportDefault(r.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g})},"template.js":function e(t,n,e){let r,i;e.export({default:()=>c}),e.link("./defaults.js",{default(e){r=e}},0),e.link("./underscore.js",{default(e){i=e}},1),e.link("./templateSettings.js");var o=/(.)^/,s={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},a=/\\|'|\r|\n|\u2028|\u2029/g;function u(e){return"\\"+s[e]}var f=/^\s*(\w|\$)+\s*$/;function c(e,t,n){!t&&n&&(t=n),t=r({},t,i.templateSettings);var s=RegExp([(t.escape||o).source,(t.interpolate||o).source,(t.evaluate||o).source].join("|")+"|$","g"),c=0,l="__p+='";e.replace(s,(function(t,n,r,i,o){return l+=e.slice(c,o).replace(a,u),c=o+t.length,n?l+="'+\n((__t=("+n+"))==null?'':_.escape(__t))+\n'":r?l+="'+\n((__t=("+r+"))==null?'':__t)+\n'":i&&(l+="';\n"+i+"\n__p+='"),t})),l+="';\n";var h=t.variable,d;if(h){if(!f.test(h))throw new Error("variable is not a bare identifier: "+h)}else l="with(obj||{}){\n"+l+"}\n",h="obj";l="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+l+"return __p;\n";try{d=new Function(h,"_",l)}catch(g){throw g.source=l,g}var p=function(e){return d.call(this,e,i)};return p.source="function("+h+"){\n"+l+"}",p}},"result.js":function e(t,n,e){let r,i;function o(e,t,n){var o=(t=i(t)).length;if(!o)return r(n)?n.call(e):n;for(var s=0;so}),e.link("./isFunction.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"uniqueId.js":function e(t,n,e){e.export({default:()=>i});var r=0;function i(e){var t=++r+"";return e?e+t:t}},"chain.js":function e(t,n,e){let r;function i(e){var t=r(e);return t._chain=!0,t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"partial.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_executeBound.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2);var s=r((function(e,t){var n=s.placeholder,r=function(){for(var o=0,s=t.length,a=Array(s),u=0;uo}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./isObject.js",{default(e){i=e}},1)},"bind.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_executeBound.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t,n){if(!i(e))throw new TypeError("Bind must be called on a function");var s=r((function(r){return o(e,s,t,this,n.concat(r))}));return s})))},"bindAll.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./bind.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t){var n=(t=i(t,!1,!1)).length;if(n<1)throw new Error("bindAll must be passed function names");for(;n--;){var r=t[n];e[r]=o(e[r],e)}return e})))},"_flatten.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,u){if(u=u||[],t||0===t){if(t<=0)return u.concat(e)}else t=1/0;for(var f=u.length,c=0,l=r(e);c1)a(h,t-1,n,u),f=u.length;else for(var d=0,p=h.length;da}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./isArray.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3)},"_isArrayLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"memoize.js":function e(t,n,e){let r;function i(e,t){var n=function(i){var o=n.cache,s=""+(t?t.apply(this,arguments):i);return r(o,s)||(o[s]=e.apply(this,arguments)),o[s]};return n.cache={},n}e.export({default:()=>i}),e.link("./_has.js",{default(e){r=e}},0)},"delay.js":function e(t,n,e){let r;e.link("./restArguments.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){return setTimeout((function(){return e.apply(null,n)}),t)})))},"defer.js":function e(t,n,e){let r,i,o;e.link("./partial.js",{default(e){r=e}},0),e.link("./delay.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2),e.exportDefault(r(i,o,1))},"throttle.js":function e(t,n,e){let r;function i(e,t,n){var i,o,s,a,u=0;n||(n={});var f=function(){u=!1===n.leading?0:r(),i=null,a=e.apply(o,s),i||(o=s=null)},c=function(){var c=r();u||!1!==n.leading||(u=c);var l=t-(c-u);return o=this,s=arguments,l<=0||l>t?(i&&(clearTimeout(i),i=null),u=c,a=e.apply(o,s),i||(o=s=null)):i||!1===n.trailing||(i=setTimeout(f,l)),a};return c.cancel=function(){clearTimeout(i),u=0,i=o=s=null},c}e.export({default:()=>i}),e.link("./now.js",{default(e){r=e}},0)},"debounce.js":function e(t,n,e){let r,i;function o(e,t,n){var o,s,a,u,f,c=function(){var r=i()-s;t>r?o=setTimeout(c,t-r):(o=null,n||(u=e.apply(f,a)),o||(a=f=null))},l=r((function(r){return f=this,a=r,s=i(),o||(o=setTimeout(c,t),n&&(u=e.apply(f,a))),u}));return l.cancel=function(){clearTimeout(o),o=a=f=null},l}e.export({default:()=>o}),e.link("./restArguments.js",{default(e){r=e}},0),e.link("./now.js",{default(e){i=e}},1)},"wrap.js":function e(t,n,e){let r;function i(e,t){return r(t,e)}e.export({default:()=>i}),e.link("./partial.js",{default(e){r=e}},0)},"negate.js":function e(t,n,e){function r(e){return function(){return!e.apply(this,arguments)}}e.export({default:()=>r})},"compose.js":function e(t,n,e){function r(){var e=arguments,t=e.length-1;return function(){for(var n=t,r=e[t].apply(this,arguments);n--;)r=e[n].call(this,r);return r}}e.export({default:()=>r})},"after.js":function e(t,n,e){function r(e,t){return function(){if(--e<1)return t.apply(this,arguments)}}e.export({default:()=>r})},"before.js":function e(t,n,e){function r(e,t){var n;return function(){return--e>0&&(n=t.apply(this,arguments)),e<=1&&(t=null),n}}e.export({default:()=>r})},"once.js":function e(t,n,e){let r,i;e.link("./partial.js",{default(e){r=e}},0),e.link("./before.js",{default(e){i=e}},1),e.exportDefault(r(i,2))},"findKey.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s,a=0,u=o.length;ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"findIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createPredicateIndexFinder.js":function e(t,n,e){let r,i;function o(e){return function(t,n,o){n=r(n,o);for(var s=i(t),a=e>0?0:s-1;a>=0&&ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"findLastIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"sortedIndex.js":function e(t,n,e){let r,i;function o(e,t,n,o){for(var s=(n=r(n,o,1))(t),a=0,u=i(e);ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"indexOf.js":function e(t,n,e){let r,i,o;e.link("./sortedIndex.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./_createIndexFinder.js",{default(e){o=e}},2),e.exportDefault(o(1,i,r))},"_createIndexFinder.js":function e(t,n,e){let r,i,o;function s(e,t,n){return function(s,a,u){var f=0,c=r(s);if("number"==typeof u)e>0?f=u>=0?u:Math.max(u+c,f):c=u>=0?Math.min(u+1,c):u+c+1;else if(n&&u&&c)return s[u=n(s,a)]===a?u:-1;if(a!=a)return(u=t(i.call(s,f,c),o))>=0?u+f:-1;for(u=e>0?f:c-1;u>=0&&us}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isNaN.js",{default(e){o=e}},2)},"lastIndexOf.js":function e(t,n,e){let r,i;e.link("./findLastIndex.js",{default(e){r=e}},0),e.link("./_createIndexFinder.js",{default(e){i=e}},1),e.exportDefault(i(-1,r))},"find.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a=(r(e)?i:o)(e,t,n);if(void 0!==a&&-1!==a)return e[a]}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./findKey.js",{default(e){o=e}},2)},"findWhere.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./find.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"each.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a;if(t=r(t,n),i(e))for(s=0,a=e.length;ss}),e.link("./_optimizeCb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"map.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=Array(a),f=0;fs}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"reduce.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createReduce.js":function e(t,n,e){let r,i,o;function s(e){var t=function(t,n,o,s){var a=!r(t)&&i(t),u=(a||t).length,f=e>0?0:u-1;for(s||(o=t[a?a[f]:f],f+=e);f>=0&&f=3;return t(e,o(n,i,4),r,s)}}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2)},"reduceRight.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"filter.js":function e(t,n,e){let r,i;function o(e,t,n){var o=[];return t=r(t,n),i(e,(function(e,n,r){t(e,n,r)&&o.push(e)})),o}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"reject.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r(e,i(o(t)),n)}e.export({default:()=>s}),e.link("./filter.js",{default(e){r=e}},0),e.link("./negate.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2)},"every.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"some.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"contains.js":function e(t,n,e){let r,i,o;function s(e,t,n,s){return r(e)||(e=i(e)),("number"!=typeof n||s)&&(n=0),o(e,t,n)>=0}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./indexOf.js",{default(e){o=e}},2)},"invoke.js":function e(t,n,e){let r,i,o,s,a;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2),e.link("./_deepGet.js",{default(e){s=e}},3),e.link("./_toPath.js",{default(e){a=e}},4),e.exportDefault(r((function(e,t,n){var r,u;return i(t)?u=t:(t=a(t),r=t.slice(0,-1),t=t[t.length-1]),o(e,(function(e){var i=u;if(!i){if(r&&r.length&&(e=s(e,r)),null==e)return;i=e[t]}return null==i?i:i.apply(e,n)}))})))},"pluck.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./map.js",{default(e){r=e}},0),e.link("./property.js",{default(e){i=e}},1)},"where.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./filter.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"max.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=-1/0,u=-1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la&&(a=f);else t=o(t,n),s(e,(function(e,n,r){((c=t(e,n,r))>u||c===-1/0&&a===-1/0)&&(a=e,u=c)}));return a}e.export({default:()=>a}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"min.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=1/0,u=1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"shuffle.js":function e(t,n,e){let r;function i(e){return r(e,1/0)}e.export({default:()=>i}),e.link("./sample.js",{default(e){r=e}},0)},"sample.js":function e(t,n,e){let r,i,o,s,a;function u(e,t,n){if(null==t||n)return r(e)||(e=i(e)),e[s(e.length-1)];var u=a(e),f=o(u);t=Math.max(Math.min(t,f),0);for(var c=f-1,l=0;lu}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./random.js",{default(e){s=e}},3),e.link("./toArray.js",{default(e){a=e}},4)},"toArray.js":function e(t,n,e){let r,i,o,s,a,u,f;e.export({default:()=>l}),e.link("./isArray.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./_isArrayLike.js",{default(e){s=e}},3),e.link("./map.js",{default(e){a=e}},4),e.link("./identity.js",{default(e){u=e}},5),e.link("./values.js",{default(e){f=e}},6);var c=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;function l(e){return e?r(e)?i.call(e):o(e)?e.match(c):s(e)?a(e,u):f(e):[]}},"sortBy.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=0;return t=r(t,n),i(o(e,(function(e,n,r){return{value:e,index:s++,criteria:t(e,n,r)}})).sort((function(e,t){var n=e.criteria,r=t.criteria;if(n!==r){if(n>r||void 0===n)return 1;if(ns}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./pluck.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2)},"groupBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n].push(t):e[n]=[t]})))},"_group.js":function e(t,n,e){let r,i;function o(e,t){return function(n,o,s){var a=t?[[],[]]:{};return o=r(o,s),i(n,(function(t,r){var i=o(t,r,n);e(a,t,i)})),a}}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"indexBy.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n]=t})))},"countBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n]++:e[n]=1})))},"partition.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n?0:1].push(t)}),!0))},"size.js":function e(t,n,e){let r,i;function o(e){return null==e?0:r(e)?e.length:i(e).length}e.export({default:()=>o}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"pick.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2),e.link("./allKeys.js",{default(e){s=e}},3),e.link("./_keyInObj.js",{default(e){a=e}},4),e.link("./_flatten.js",{default(e){u=e}},5),e.exportDefault(r((function(e,t){var n={},r=t[0];if(null==e)return n;i(r)?(t.length>1&&(r=o(r,t[1])),t=s(e)):(r=a,t=u(t,!1,!1),e=Object(e));for(var f=0,c=t.length;fr})},"omit.js":function e(t,n,e){let r,i,o,s,a,u,f;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./negate.js",{default(e){o=e}},2),e.link("./map.js",{default(e){s=e}},3),e.link("./_flatten.js",{default(e){a=e}},4),e.link("./contains.js",{default(e){u=e}},5),e.link("./pick.js",{default(e){f=e}},6),e.exportDefault(r((function(e,t){var n=t[0],r;return i(n)?(n=o(n),t.length>1&&(r=t[1])):(t=s(a(t,!1,!1),String),n=function(e,n){return!u(t,n)}),f(e,n,r)})))},"first.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[0]:r(e,e.length-t)}e.export({default:()=>i}),e.link("./initial.js",{default(e){r=e}},0)},"initial.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,0,Math.max(0,e.length-(null==t||n?1:t)))}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"last.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[e.length-1]:r(e,Math.max(0,e.length-t))}e.export({default:()=>i}),e.link("./rest.js",{default(e){r=e}},0)},"rest.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,null==t||n?1:t)}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"compact.js":function e(t,n,e){let r;function i(e){return r(e,Boolean)}e.export({default:()=>i}),e.link("./filter.js",{default(e){r=e}},0)},"flatten.js":function e(t,n,e){let r;function i(e,t){return r(e,t,!1)}e.export({default:()=>i}),e.link("./_flatten.js",{default(e){r=e}},0)},"without.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./difference.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t){return i(e,t)})))},"difference.js":function e(t,n,e){let r,i,o,s;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./filter.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3),e.exportDefault(r((function(e,t){return t=i(t,!0,!0),o(e,(function(e){return!s(t,e)}))})))},"uniq.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,a){r(t)||(a=n,n=t,t=!1),null!=n&&(n=i(n,a));for(var u=[],f=[],c=0,l=o(e);ca}),e.link("./isBoolean.js",{default(e){r=e}},0),e.link("./_cb.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3)},"union.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./uniq.js",{default(e){i=e}},1),e.link("./_flatten.js",{default(e){o=e}},2),e.exportDefault(r((function(e){return i(o(e,!0,!0))})))},"intersection.js":function e(t,n,e){let r,i;function o(e){for(var t=[],n=arguments.length,o=0,s=r(e);oo}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./contains.js",{default(e){i=e}},1)},"unzip.js":function e(t,n,e){let r,i,o;function s(e){for(var t=e&&r(e,i).length||0,n=Array(t),s=0;ss}),e.link("./max.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.link("./pluck.js",{default(e){o=e}},2)},"zip.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./unzip.js",{default(e){i=e}},1),e.exportDefault(r(i))},"object.js":function e(t,n,e){let r;function i(e,t){for(var n={},i=0,o=r(e);ii}),e.link("./_getLength.js",{default(e){r=e}},0)},"range.js":function e(t,n,e){function r(e,t,n){null==t&&(t=e||0,e=0),n||(n=tr})},"chunk.js":function e(t,n,e){let r;function i(e,t){if(null==t||t<1)return[];for(var n=[],i=0,o=e.length;ii}),e.link("./_setup.js",{slice(e){r=e}},0)},"mixin.js":function e(t,n,e){let r,i,o,s,a;function u(e){return i(o(e),(function(t){var n=r[t]=e[t];r.prototype[t]=function(){var e=[this._wrapped];return s.apply(e,arguments),a(this,n.apply(r,e))}})),r}e.export({default:()=>u}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./functions.js",{default(e){o=e}},2),e.link("./_setup.js",{push(e){s=e}},3),e.link("./_chainResult.js",{default(e){a=e}},4)},"_chainResult.js":function e(t,n,e){let r;function i(e,t){return e._chain?r(t).chain():t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"underscore-array-methods.js":function e(t,n,e){let r,i,o,s;e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./_setup.js",{ArrayProto(e){o=e}},2),e.link("./_chainResult.js",{default(e){s=e}},3),i(["pop","push","reverse","shift","sort","splice","unshift"],(function(e){var t=o[e];r.prototype[e]=function(){var n=this._wrapped;return null!=n&&(t.apply(n,arguments),"shift"!==e&&"splice"!==e||0!==n.length||delete n[0]),s(this,n)}})),i(["concat","join","slice"],(function(e){var t=o[e];r.prototype[e]=function(){var e=this._wrapped;return null!=e&&(e=t.apply(e,arguments)),s(this,e)}})),e.exportDefault(r)}}}}},cachers:{"package.json":function e(t,n,e){e.exports={name:"@steedos/cachers",version:"2.7.4-beta.2",main:"lib/index.js"}},lib:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getCacherNames=n.clearCacher=n.getCacher=void 0;var r={},i=t("./memory"),o=t("./memory-lru"),s=function(e,t){return r[e]||(e.startsWith("lru.")?r[e]=new o.MemoryLRUCacher(t):r[e]=new i.MemoryCacher),r[e]};n.getCacher=s;var a=function(e){r[e]&&r[e].clear()};n.clearCacher=a;var u=function(){return Object.keys(r)};n.getCacherNames=u},"memory.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryCacher=void 0;var r=t("lodash"),i=function(){function e(){this.cache={}}return e.prototype.get=function(e){return this.cache[e]},e.prototype.delete=function(e){delete this.cache[e]},e.prototype.set=function(e,t){this.cache[e]=t},e.prototype.clear=function(){this.cache={}},e.prototype.keys=function(){return(0,r.keys)(this.cache)},e.prototype.values=function(){return(0,r.values)(this.cache)},e}();n.MemoryCacher=i},"memory-lru.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryLRUCacher=void 0;var r=t("lodash"),i=t("lru-cache"),o={max:5e3,ttl:null,keygen:null,maxParamsLength:null},s=function(){function e(e){this.opts=(0,r.defaultsDeep)(e,o),this.cache=new i({max:this.opts.max,maxAge:this.opts.ttl?1e3*this.opts.ttl:null,updateAgeOnGet:!!this.opts.ttl})}return e.prototype.get=function(e){return this.cache.get(e)},e.prototype.set=function(e,t,n){return this.cache.set(e,t,n)},e.prototype.delete=function(e){return this.cache.delete(e)},e.prototype.clear=function(){return this.cache.clear()},e.prototype.keys=function(){return this.cache.keys()},e.prototype.values=function(){return this.cache.values()},e}();n.MemoryLRUCacher=s}},node_modules:{"lru-cache":{"package.json":function e(t,n,e){e.exports={name:"lru-cache",version:"7.14.1",main:"index.js"}},"index.js":function e(t,n,e){const r="object"==typeof performance&&performance&&"function"==typeof performance.now?performance:Date,i="function"==typeof AbortController,o=i?AbortController:class e{constructor(){this.signal=new u}abort(){this.signal.dispatchEvent("abort")}},s="function"==typeof AbortSignal,a="function"==typeof o.AbortSignal,u=s?AbortSignal:a?o.AbortController:class e{constructor(){this.aborted=!1,this._listeners=[]}dispatchEvent(e){if("abort"===e){this.aborted=!0;const t={type:e,target:this};this.onabort(t),this._listeners.forEach(e=>e(t),this)}}onabort(){}addEventListener(e,t){"abort"===e&&this._listeners.push(t)}removeEventListener(e,t){"abort"===e&&(this._listeners=this._listeners.filter(e=>e!==t))}},f=new Set,c=(e,t)=>{const n=`LRU_CACHE_OPTION_${e}`;p(n)&&g(n,`${e} option`,`options.${t}`,_)},l=(e,t)=>{const n=`LRU_CACHE_METHOD_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} method`,`cache.${t}()`,i)}},h=(e,t)=>{const n=`LRU_CACHE_PROPERTY_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} property`,`cache.${t}`,i)}},d=(...e)=>{"object"==typeof process&&process&&"function"==typeof process.emitWarning?process.emitWarning(...e):console.error(...e)},p=e=>!f.has(e),g=(e,t,n,r)=>{f.add(e);const i=`The ${t} is deprecated. Please use ${n} instead.`;d(i,"DeprecationWarning",e,r)},b=e=>e&&e===Math.floor(e)&&e>0&&isFinite(e),m=e=>b(e)?e<=Math.pow(2,8)?Uint8Array:e<=Math.pow(2,16)?Uint16Array:e<=Math.pow(2,32)?Uint32Array:e<=Number.MAX_SAFE_INTEGER?v:null:null;class v extends Array{constructor(e){super(e),this.fill(0)}}class y{constructor(e){if(0===e)return[];const t=m(e);this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}}class _{constructor(e={}){const{max:t=0,ttl:n,ttlResolution:r=1,ttlAutopurge:i,updateAgeOnGet:o,updateAgeOnHas:s,allowStale:a,dispose:u,disposeAfter:l,noDisposeOnSet:h,noUpdateTTL:g,maxSize:v=0,maxEntrySize:w=0,sizeCalculation:k,fetchMethod:j,fetchContext:x,noDeleteOnFetchRejection:S,noDeleteOnStaleGet:D}=e,{length:E,maxAge:A,stale:C}=e instanceof _?{}:e;if(0!==t&&!b(t))throw new TypeError("max option must be a nonnegative integer");const M=t?m(t):Array;if(!M)throw new Error("invalid max value: "+t);if(this.max=t,this.maxSize=v,this.maxEntrySize=w||this.maxSize,this.sizeCalculation=k||E,this.sizeCalculation){if(!this.maxSize&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if("function"!=typeof this.sizeCalculation)throw new TypeError("sizeCalculation set to non-function")}if(this.fetchMethod=j||null,this.fetchMethod&&"function"!=typeof this.fetchMethod)throw new TypeError("fetchMethod must be a function if specified");if(this.fetchContext=x,!this.fetchMethod&&void 0!==x)throw new TypeError("cannot set fetchContext without fetchMethod");if(this.keyMap=new Map,this.keyList=new Array(t).fill(null),this.valList=new Array(t).fill(null),this.next=new M(t),this.prev=new M(t),this.head=0,this.tail=0,this.free=new y(t),this.initialFill=1,this.size=0,"function"==typeof u&&(this.dispose=u),"function"==typeof l?(this.disposeAfter=l,this.disposed=[]):(this.disposeAfter=null,this.disposed=null),this.noDisposeOnSet=!!h,this.noUpdateTTL=!!g,this.noDeleteOnFetchRejection=!!S,0!==this.maxEntrySize){if(0!==this.maxSize&&!b(this.maxSize))throw new TypeError("maxSize must be a positive integer if specified");if(!b(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.initializeSizeTracking()}if(this.allowStale=!!a||!!C,this.noDeleteOnStaleGet=!!D,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!s,this.ttlResolution=b(r)||0===r?r:1,this.ttlAutopurge=!!i,this.ttl=n||A||0,this.ttl){if(!b(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.initializeTTLTracking()}if(0===this.max&&0===this.ttl&&0===this.maxSize)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.max&&!this.maxSize){const e="LRU_CACHE_UNBOUNDED";if(p(e)){f.add(e);const t="TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";d(t,"UnboundedCacheWarning",e,_)}}C&&c("stale","allowStale"),A&&c("maxAge","ttl"),E&&c("length","sizeCalculation")}getRemainingTTL(e){return this.has(e,{updateAgeOnHas:!1})?1/0:0}initializeTTLTracking(){this.ttls=new v(this.max),this.starts=new v(this.max),this.setItemTTL=(e,t,n=r.now())=>{if(this.starts[e]=0!==t?n:0,this.ttls[e]=t,0!==t&&this.ttlAutopurge){const n=setTimeout(()=>{this.isStale(e)&&this.delete(this.keyList[e])},t+1);n.unref&&n.unref()}},this.updateItemAge=e=>{this.starts[e]=0!==this.ttls[e]?r.now():0};let e=0;const t=()=>{const t=r.now();if(this.ttlResolution>0){e=t;const n=setTimeout(()=>e=0,this.ttlResolution);n.unref&&n.unref()}return t};this.getRemainingTTL=n=>{const r=this.keyMap.get(n);return void 0===r?0:0===this.ttls[r]||0===this.starts[r]?1/0:this.starts[r]+this.ttls[r]-(e||t())},this.isStale=n=>0!==this.ttls[n]&&0!==this.starts[n]&&(e||t())-this.starts[n]>this.ttls[n]}updateItemAge(e){}setItemTTL(e,t,n){}isStale(e){return!1}initializeSizeTracking(){this.calculatedSize=0,this.sizes=new v(this.max),this.removeItemSize=e=>{this.calculatedSize-=this.sizes[e],this.sizes[e]=0},this.requireSize=(e,t,n,r)=>{if(this.isBackgroundFetch(t))return 0;if(!b(n)){if(!r)throw new TypeError("invalid size value (must be positive integer)");if("function"!=typeof r)throw new TypeError("sizeCalculation must be a function");if(n=r(t,e),!b(n))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}return n},this.addItemSize=(e,t)=>{if(this.sizes[e]=t,this.maxSize){const t=this.maxSize-this.sizes[e];for(;this.calculatedSize>t;)this.evict(!0)}this.calculatedSize+=this.sizes[e]}}removeItemSize(e){}addItemSize(e,t){}requireSize(e,t,n,r){if(n||r)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache")}*indexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.tail;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.head);)t=this.prev[t]}*rindexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.head;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.tail);)t=this.next[t]}isValidIndex(e){return this.keyMap.get(this.keyList[e])===e}*entries(){for(const e of this.indexes())yield[this.keyList[e],this.valList[e]]}*rentries(){for(const e of this.rindexes())yield[this.keyList[e],this.valList[e]]}*keys(){for(const e of this.indexes())yield this.keyList[e]}*rkeys(){for(const e of this.rindexes())yield this.keyList[e]}*values(){for(const e of this.indexes())yield this.valList[e]}*rvalues(){for(const e of this.rindexes())yield this.valList[e]}[Symbol.iterator](){return this.entries()}find(e,t={}){for(const n of this.indexes())if(e(this.valList[n],this.keyList[n],this))return this.get(this.keyList[n],t)}forEach(e,t=this){for(const n of this.indexes())e.call(t,this.valList[n],this.keyList[n],this)}rforEach(e,t=this){for(const n of this.rindexes())e.call(t,this.valList[n],this.keyList[n],this)}get prune(){return l("prune","purgeStale"),this.purgeStale}purgeStale(){let e=!1;for(const t of this.rindexes({allowStale:!0}))this.isStale(t)&&(this.delete(this.keyList[t]),e=!0);return e}dump(){const e=[];for(const t of this.indexes({allowStale:!0})){const n=this.keyList[t],i=this.valList[t],o=this.isBackgroundFetch(i)?i.__staleWhileFetching:i,s={value:o};if(this.ttls){s.ttl=this.ttls[t];const e=r.now()-this.starts[t];s.start=Math.floor(Date.now()-e)}this.sizes&&(s.size=this.sizes[t]),e.unshift([n,s])}return e}load(e){this.clear();for(const[t,n]of e){if(n.start){const e=Date.now()-n.start;n.start=r.now()-e}this.set(t,n.value,n)}}dispose(e,t,n){}set(e,t,{ttl:n=this.ttl,start:r,noDisposeOnSet:i=this.noDisposeOnSet,size:o=0,sizeCalculation:s=this.sizeCalculation,noUpdateTTL:a=this.noUpdateTTL}={}){if(o=this.requireSize(e,t,o,s),this.maxEntrySize&&o>this.maxEntrySize)return this.delete(e),this;let u=0===this.size?void 0:this.keyMap.get(e);if(void 0===u)u=this.newIndex(),this.keyList[u]=e,this.valList[u]=t,this.keyMap.set(e,u),this.next[this.tail]=u,this.prev[u]=this.tail,this.tail=u,this.size++,this.addItemSize(u,o),a=!1;else{const n=this.valList[u];t!==n&&(this.isBackgroundFetch(n)?n.__abortController.abort():i||(this.dispose(n,e,"set"),this.disposeAfter&&this.disposed.push([n,e,"set"])),this.removeItemSize(u),this.valList[u]=t,this.addItemSize(u,o)),this.moveToTail(u)}if(0===n||0!==this.ttl||this.ttls||this.initializeTTLTracking(),a||this.setItemTTL(u,n,r),this.disposeAfter)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return this}newIndex(){return 0===this.size?this.tail:this.size===this.max&&0!==this.max?this.evict(!1):0!==this.free.length?this.free.pop():this.initialFill++}pop(){if(this.size){const e=this.valList[this.head];return this.evict(!0),e}}evict(e){const t=this.head,n=this.keyList[t],r=this.valList[t];return this.isBackgroundFetch(r)?r.__abortController.abort():(this.dispose(r,n,"evict"),this.disposeAfter&&this.disposed.push([r,n,"evict"])),this.removeItemSize(t),e&&(this.keyList[t]=null,this.valList[t]=null,this.free.push(t)),this.head=this.next[t],this.keyMap.delete(n),this.size--,t}has(e,{updateAgeOnHas:t=this.updateAgeOnHas}={}){const n=this.keyMap.get(e);return void 0!==n&&!this.isStale(n)&&(t&&this.updateItemAge(n),!0)}peek(e,{allowStale:t=this.allowStale}={}){const n=this.keyMap.get(e);if(void 0!==n&&(t||!this.isStale(n))){const e=this.valList[n];return this.isBackgroundFetch(e)?e.__staleWhileFetching:e}}backgroundFetch(e,t,n,r){const i=void 0===t?void 0:this.valList[t];if(this.isBackgroundFetch(i))return i;const s=new o,a={signal:s.signal,options:n,context:r},u=t=>(s.signal.aborted||this.set(e,t,a.options),t),f=r=>{if(this.valList[t]===l){const r=!n.noDeleteOnFetchRejection||void 0===l.__staleWhileFetching;r?this.delete(e):this.valList[t]=l.__staleWhileFetching}if(l.__returned===l)throw r},c=t=>t(this.fetchMethod(e,i,a)),l=new Promise(c).then(u,f);return l.__abortController=s,l.__staleWhileFetching=i,l.__returned=null,void 0===t?(this.set(e,l,a.options),t=this.keyMap.get(e)):this.valList[t]=l,l}isBackgroundFetch(e){return e&&"object"==typeof e&&"function"==typeof e.then&&Object.prototype.hasOwnProperty.call(e,"__staleWhileFetching")&&Object.prototype.hasOwnProperty.call(e,"__returned")&&(e.__returned===e||null===e.__returned)}async fetch(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet,ttl:i=this.ttl,noDisposeOnSet:o=this.noDisposeOnSet,size:s=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:u=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,fetchContext:c=this.fetchContext,forceRefresh:l=!1}={}){if(!this.fetchMethod)return this.get(e,{allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r});const h={allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r,ttl:i,noDisposeOnSet:o,size:s,sizeCalculation:a,noUpdateTTL:u,noDeleteOnFetchRejection:f};let d=this.keyMap.get(e);if(void 0===d){const t=this.backgroundFetch(e,d,h,c);return t.__returned=t}{const r=this.valList[d];if(this.isBackgroundFetch(r))return t&&void 0!==r.__staleWhileFetching?r.__staleWhileFetching:r.__returned=r;if(!l&&!this.isStale(d))return this.moveToTail(d),n&&this.updateItemAge(d),r;const i=this.backgroundFetch(e,d,h,c);return t&&void 0!==i.__staleWhileFetching?i.__staleWhileFetching:i.__returned=i}}get(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet}={}){const i=this.keyMap.get(e);if(void 0!==i){const o=this.valList[i],s=this.isBackgroundFetch(o);if(this.isStale(i))return s?t?o.__staleWhileFetching:void 0:(r||this.delete(e),t?o:void 0);if(s)return;return this.moveToTail(i),n&&this.updateItemAge(i),o}}connect(e,t){this.prev[t]=e,this.next[e]=t}moveToTail(e){e!==this.tail&&(e===this.head?this.head=this.next[e]:this.connect(this.prev[e],this.next[e]),this.connect(this.tail,e),this.tail=e)}get del(){return l("del","delete"),this.delete}delete(e){let t=!1;if(0!==this.size){const n=this.keyMap.get(e);if(void 0!==n)if(t=!0,1===this.size)this.clear();else{this.removeItemSize(n);const t=this.valList[n];this.isBackgroundFetch(t)?t.__abortController.abort():(this.dispose(t,e,"delete"),this.disposeAfter&&this.disposed.push([t,e,"delete"])),this.keyMap.delete(e),this.keyList[n]=null,this.valList[n]=null,n===this.tail?this.tail=this.prev[n]:n===this.head?this.head=this.next[n]:(this.next[this.prev[n]]=this.next[n],this.prev[this.next[n]]=this.prev[n]),this.size--,this.free.push(n)}}if(this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return t}clear(){for(const e of this.rindexes({allowStale:!0})){const t=this.valList[e];if(this.isBackgroundFetch(t))t.__abortController.abort();else{const n=this.keyList[e];this.dispose(t,n,"delete"),this.disposeAfter&&this.disposed.push([t,n,"delete"])}}if(this.keyMap.clear(),this.valList.fill(null),this.keyList.fill(null),this.ttls&&(this.ttls.fill(0),this.starts.fill(0)),this.sizes&&this.sizes.fill(0),this.head=0,this.tail=0,this.initialFill=1,this.free.length=0,this.calculatedSize=0,this.size=0,this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift())}get reset(){return l("reset","clear"),this.clear}get length(){return h("length","size"),this.size}static get AbortController(){return o}static get AbortSignal(){return u}}e.exports=_}}}},"form-builder":{"package.json":function e(t,n,e){e.exports={name:"@steedos/form-builder",version:"3.6.2-patch.5",private:!1,publishConfig:{access:"public"},main:"dist/form-builder.min.js",homepage:"https://formbuilder.online/",repository:{url:"https://github.com/kevinchappell/formBuilder.git",type:"git"},files:["dist/**/*","docs/**/*","src/**/*"],author:"Kevin Chappell ",contributors:[],bugs:"https://github.com/kevinchappell/formBuilder/issues",description:"A jQuery plugin for drag and drop form building",keywords:["jquery-plugin","forms","drag and drop","form builder","form create"],license:"MIT",ignore:["**/*","node_modules","test"],config:{files:{test:["test/**/*.spec.js"],pluginsDir:"src/js/control_plugins/",fonts:"src/fonts",sass:"src/sass",formBuilder:{js:"src/js/form-builder.js",sass:["src/sass/form-builder.scss"]},formRender:{js:"src/js/form-render.js",sass:["src/sass/form-render.scss"]},site:["demo/assets/sass/site.scss"]},fontServer:"http://fontello.com",fontelloToken:"09d648f01d6c57cb9f9b8cc55043e0c0"},babel:{presets:[["@babel/preset-env",{targets:{browsers:["> 1%"]},loose:!0}]],comments:!1,plugins:["@babel/plugin-proposal-object-rest-spread","@babel/plugin-proposal-class-properties"]},scripts:{"build:analyze":"webpack --mode production -p --progress --config tools/webpack.config --analyze","build:plugins":"webpack --mode production -p --display-entrypoints --progress --config tools/webpack.plugins.config","build:vendor":"babel-node tools/build-vendor",build:"webpack --mode production -p --progress --config tools/webpack.config","build:all":"npm-run-all build:plugins build:vendor build copy",copy:"cp -a dist/* demo/assets/js/ && cp CONTRIBUTING.md docs/contributing.md && cp LICENSE docs/license.md && npm run copy:lang","copy:lang":"babel-node tools/copy-language-files","deploy:all":"npm-run-all deploy:demo deploy:site","deploy:demo":"node tools/deploy-demo.js","deploy:site":"node tools/deploy-site.js",docs:"mkdocs build",font:"babel-node tools/icon-font",lint:"eslint ./src --ext .js || true","semantic-release":"semantic-release","start:devServer":"webpack-dev-server --mode development --config tools/webpack.config",prestart:"npm-run-all -p build:vendor copy:lang",start:"npm run start:devServer",test:"npm run-script build"},dependencies:{jquery:">=3.4.1","jquery-ui-sortable":"*"},devDependencies:{"@babel/cli":"^7.10.5","@babel/core":"^7.11.4","@babel/node":"^7.10.5","@babel/plugin-proposal-class-properties":"^7.10.4","@babel/plugin-proposal-object-rest-spread":"^7.11.0","@babel/plugin-syntax-object-rest-spread":"^7.8.3","@babel/plugin-transform-destructuring":"^7.10.4","@babel/preset-env":"^7.11.0","@semantic-release/changelog":"^5.0.1","@semantic-release/git":"^9.0.0","@semantic-release/npm":"^7.0.5",autoprefixer:"^9.8.6","babel-eslint":"^10.1.0","babel-loader":"^8.1.0","clean-webpack-plugin":"^3.0.0",clui:"^0.3.6","compression-webpack-plugin":"^5.0.1","concat-files":"^0.1.1","cross-env":"^7.0.2","css-loader":"^4.2.1",eslint:"^7.7.0","eslint-loader":"^4.0.2","formbuilder-languages":"latest","fs-extra":"^9.0.1","html-webpack-harddisk-plugin":"^1.0.2","html-webpack-plugin":"^4.3.0",inquirer:"^7.3.3",mi18n:"^0.4.8","node-sass":"6.0.1","npm-run-all":"^4.1.5",opener:"^1.5.1","postcss-loader":"^3.0.0","replace-in-file":"^6.1.0",request:"^2.88.2","sass-loader":"10.5.2","semantic-release":"^17.1.1",semver:"^7.3.2","style-loader":"^1.2.1",unzipper:"^0.10.11",webpack:"^4.44.1","webpack-bundle-analyzer":"^3.8.0","webpack-cli":"^3.3.12","webpack-dev-server":"^3.11.0","wrapper-webpack-plugin":"^2.1.0"},prettier:{singleQuote:!0,trailingComma:"all",printWidth:120,semi:!1,arrowParens:"avoid",spaceAfterFunction:!1},engines:{},release:{branch:"master",verifyConditions:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"],prepare:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"]},browserslist:["> 1%"]}},dist:{"form-builder.min.js":[]}}},tslib:{"package.json":function e(t,n,e){e.exports={name:"tslib",version:"2.3.1",module:"tslib.es6.js",main:"tslib.js"}},"tslib.es6.js":function e(t,n,e){e.export({__extends:()=>i,__assign:()=>o,__rest:()=>s,__decorate:()=>a,__param:()=>u,__metadata:()=>f,__awaiter:()=>c,__generator:()=>l,__createBinding:()=>h,__exportStar:()=>d,__values:()=>p,__read:()=>g,__spread:()=>b,__spreadArrays:()=>m,__spreadArray:()=>v,__await:()=>y,__asyncGenerator:()=>_,__asyncDelegator:()=>w,__asyncValues:()=>k,__makeTemplateObject:()=>j,__importStar:()=>S,__importDefault:()=>D,__classPrivateFieldGet:()=>E,__classPrivateFieldSet:()=>A}); /*! ***************************************************************************** Copyright (c) Microsoft Corporation. @@ -249,7 +249,7 @@ Package._define("mobile-experience"); !function(){var a=Package["ddp-client"].DDP;Package._define("ddp",{DDP:a})}(); -Package._define("ddp-server"); +!function(){var e,a,d;Package._define("ddp-server")}(); !function(){var e=Package.meteor.Meteor,t=Package.meteor.global,o=Package.meteor.meteorEnv,n=Package.minimongo.LocalCollection,r=Package.minimongo.Minimongo,i=Package.check.check,c=Package.check.Match,s=Package.ejson.EJSON,l=Package["ddp-client"].DDP,a=Package.modules.meteorInstall,d=Package.promise.Promise,f,u;a({node_modules:{meteor:{"allow-deny":{"allow-deny.js":function t(){const o=Object.prototype.hasOwnProperty,r=(f={CollectionPrototype:{}}).CollectionPrototype;r.allow=function(e){h(this,"allow",e)},r.deny=function(e){h(this,"deny",e)},r._defineMutationMethods=function(t){const n=this;if(t=t||{},n._restricted=!1,n._insecure=void 0,n._validators={insert:{allow:[],deny:[]},update:{allow:[],deny:[]},remove:{allow:[],deny:[]},upsert:{allow:[],deny:[]},fetch:[],fetchAllFields:!1},n._name&&(n._prefix="/"+n._name+"/",n._connection&&(n._connection===e.server||e.isClient))){const r={};["insert","update","remove"].forEach(s=>{const l=n._prefix+s;if(t.useExisting){const t=e.isClient?"_methodHandlers":"method_handlers";if(n._connection[t]&&"function"==typeof n._connection[t][l])return}r[l]=function(){i(arguments,[c.Any]);const t=Array.from(arguments);try{let r=null;if("insert"!==s||o.call(t[0],"_id")||(r=n._makeNewID()),this.isSimulation)return null!==r&&(t[0]._id=r),n._collection[s].apply(n._collection,t);if("insert"!==s&&_(t[0],s),n._restricted){if(0===n._validators[s].allow.length)throw new e.Error(403,"Access denied. No allow validators set on restricted collection for method '"+s+"'.");const o="_validated"+s.charAt(0).toUpperCase()+s.slice(1);return t.unshift(this.userId),"insert"===s&&t.push(r),n[o].apply(n,t)}if(n._isInsecure())return null!==r&&(t[0]._id=r),n._collection[s].apply(n._collection,t);throw new e.Error(403,"Access denied")}catch(r){throw"MongoError"===r.name||"MinimongoError"===r.name?new e.Error(409,r.toString()):r}}}),n._connection.methods(r)}},r._updateFetch=function(e){const t=this;if(!t._validators.fetchAllFields)if(e){const o=Object.create(null),n=e=>e&&e.forEach(e=>o[e]=1);n(t._validators.fetch),n(e),t._validators.fetch=Object.keys(o)}else t._validators.fetchAllFields=!0,t._validators.fetch=null},r._isInsecure=function(){const e=this;return void 0===this._insecure?!!Package.insecure:this._insecure},r._validatedInsert=function(t,o,n){const r=this;if(this._validators.insert.deny.some(e=>e(t,u(e,o,n))))throw new e.Error(403,"Access denied");if(this._validators.insert.allow.every(e=>!e(t,u(e,o,n))))throw new e.Error(403,"Access denied");null!==n&&(o._id=n),this._collection.insert.call(this._collection,o)},r._validatedUpdate=function(t,r,c,s){const l=this;if(i(c,Object),s=Object.assign(Object.create(null),s),!n._selectorIsIdPerhapsAsObject(r))throw new Error("validated update should be of a single ID");if(s.upsert)throw new e.Error(403,"Access denied. Upserts not allowed in a restricted collection.");const f="Access denied. In a restricted collection you can only update documents, not replace them. Use a Mongo update operator, such as '$set'.",u=Object.keys(c),h={};if(0===u.length)throw new e.Error(403,f);u.forEach(t=>{const n=c[t];if("$"!==t.charAt(0))throw new e.Error(403,f);if(!o.call(a,t))throw new e.Error(403,"Access denied. Operator "+t+" not allowed in a restricted collection.");Object.keys(n).forEach(e=>{-1!==e.indexOf(".")&&(e=e.substring(0,e.indexOf("."))),h[e]=!0})});const _=Object.keys(h),m={transform:null};l._validators.fetchAllFields||(m.fields={},l._validators.fetch.forEach(e=>{m.fields[e]=1}));const w=l._collection.findOne(r,m);if(!w)return 0;if(l._validators.update.deny.some(e=>{const o=d(e,w);return e(t,o,_,c)}))throw new e.Error(403,"Access denied");if(l._validators.update.allow.every(e=>{const o=d(e,w);return!e(t,o,_,c)}))throw new e.Error(403,"Access denied");return s._forbidReplace=!0,l._collection.update.call(l._collection,r,c,s)};const a={$inc:1,$set:1,$unset:1,$addToSet:1,$pop:1,$pullAll:1,$pull:1,$pushAll:1,$push:1,$bit:1};function d(e,t){return e.transform?e.transform(t):t}function u(e,t,o){let n=t;return e.transform&&(n=s.clone(t),null!==o&&(n._id=o),n=e.transform(n)),n}function h(e,t,r){const i=/^(?:insert|update|remove|fetch|transform)$/;if(Object.keys(r).forEach(e=>{if(!i.test(e))throw new Error(t+": Invalid key: "+e)}),e._restricted=!0,["insert","update","remove"].forEach(i=>{if(o.call(r,i)){if(!(r[i]instanceof Function))throw new Error(t+": Value for `"+i+"` must be a function");void 0===r.transform?r[i].transform=e._transform:r[i].transform=n.wrapTransform(r.transform),e._validators[i][t].push(r[i])}}),r.update||r.remove||r.fetch){if(r.fetch&&!(r.fetch instanceof Array))throw new Error(t+": Value for `fetch` must be an array");e._updateFetch(r.fetch)}}function _(t,o){if(!n._selectorIsIdPerhapsAsObject(t))throw new e.Error(403,"Not permitted. Untrusted code may only "+o+" documents by ID.")}function m(){var e;const t=(l._CurrentMethodInvocation||l._CurrentInvocation).get();return t&&t.isSimulation}r._validatedRemove=function(t,o){const n=this,r={transform:null};n._validators.fetchAllFields||(r.fields={},n._validators.fetch.forEach(e=>{r.fields[e]=1}));const i=n._collection.findOne(o,r);if(!i)return 0;if(n._validators.remove.deny.some(e=>e(t,d(e,i))))throw new e.Error(403,"Access denied");if(n._validators.remove.allow.every(e=>!e(t,d(e,i))))throw new e.Error(403,"Access denied");return n._collection.remove.call(n._collection,o)},r._callMutatorMethod=function t(o,n,r){!e.isClient||r||m()||(r=function(t){t&&e._debug(o+" failed: "+(t.reason||t.stack))});const i="update"===o||"remove"===o;i&&!m()&&_(n[0],o);const c=this._prefix+o;return this._connection.apply(c,n,{returnStubValue:!0},r)}}}}}},{extensions:[".js",".json"]})("/node_modules/meteor/allow-deny/allow-deny.js"),Package._define("allow-deny",{AllowDeny:f})}(); diff --git a/server/bundle/programs/web.browser.legacy/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json b/server/bundle/programs/web.browser.legacy/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json similarity index 99% rename from server/bundle/programs/web.browser.legacy/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json rename to server/bundle/programs/web.browser.legacy/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json index f421ff5a81..32cdd99b94 100644 --- a/server/bundle/programs/web.browser.legacy/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json +++ b/server/bundle/programs/web.browser.legacy/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json @@ -3,8 +3,8 @@ "name": "standard-minifier-js", "version": "2.6.0" }, - "totalMinifiedBytes": 4306712, - "totalMinifiedGzipBytes": 1085048, + "totalMinifiedBytes": 4306737, + "totalMinifiedGzipBytes": 1085046, "minifiedBytesByPackage": { "packages/meteor.js": 9504, "packages/coffeescript.js": 32, @@ -1584,7 +1584,7 @@ } ], "packages/ddp.js": 78, - "packages/ddp-server.js": 30, + "packages/ddp-server.js": 55, "packages/allow-deny.js": [ 5767, { diff --git a/server/bundle/programs/web.browser.legacy/program.json b/server/bundle/programs/web.browser.legacy/program.json index ebba1ab57a..8dc087892f 100644 --- a/server/bundle/programs/web.browser.legacy/program.json +++ b/server/bundle/programs/web.browser.legacy/program.json @@ -2,24 +2,24 @@ "format": "web-program-pre1", "manifest": [ { - "path": "79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js", + "path": "7d27de16d6eab9175efa4d52871e8cc6588f4811.js", "where": "client", "type": "js", "cacheable": true, - "url": "/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js?meteor_js_resource=true", - "size": 4306712, - "hash": "79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9", - "sri": "8V1LAdKwQ3YDuCf6NLWIc8ANTjyPPal4eMgPcDSh7DgxhEPYKlU6Ng1mUyFf41upRtf3cWipGUF8Bks86cK3Xg==" + "url": "/7d27de16d6eab9175efa4d52871e8cc6588f4811.js?meteor_js_resource=true", + "size": 4306737, + "hash": "7d27de16d6eab9175efa4d52871e8cc6588f4811", + "sri": "mQJ9d8Y1Rd2yLC9UkYFqc8DKdWTK+EbdVcXzlUriN9g92KUMPH+VnggxIBgtYFspWYpGlxV7xGxOIieDJ5ACcg==" }, { - "path": "79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json", + "path": "7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json", "where": "client", "type": "json", "cacheable": true, - "url": "/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json?meteor_js_resource=true", + "url": "/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json?meteor_js_resource=true", "size": 92684, - "hash": "84b3c49ed8cbcc47c24972dbe109f0a26e1c615f", - "sri": "9TD3noiNc7n1kIu/MLlA5a+iI7Zw7X3uqMMLIepNxhm2titxz91fBgCPj5bpXr60mvkrz+5WmQd7JBkRh5M8PQ==" + "hash": "09ae6c73b3f27edc9130f5c46771c9c45954f508", + "sri": "zVvOLAKlxGGT0HM1ez3LJh6n8LNY7HTZ23MTiXz0eUEOUNiG6OYB/AID6bCJaDNjWU9eKCk3WsYO5YL6W6Tiaw==" }, { "path": "dynamic/node_modules/@steedos/form-builder/dist/form-builder.min.js", diff --git a/server/bundle/programs/web.browser/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js b/server/bundle/programs/web.browser/7d27de16d6eab9175efa4d52871e8cc6588f4811.js similarity index 99% rename from server/bundle/programs/web.browser/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js rename to server/bundle/programs/web.browser/7d27de16d6eab9175efa4d52871e8cc6588f4811.js index a92b7b4af7..3947c05c4c 100644 --- a/server/bundle/programs/web.browser/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js +++ b/server/bundle/programs/web.browser/7d27de16d6eab9175efa4d52871e8cc6588f4811.js @@ -68,7 +68,7 @@ object-assign * Copyright 2011-2019 Twitter, Inc. * Licensed under the MIT license */ -if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(jQuery),function(e){"use strict";function t(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var n in t)if(void 0!==e.style[n])return{end:t[n]};return!1}e.fn.emulateTransitionEnd=function(t){var n=!1,r=this,i;return e(this).one("bsTransitionEnd",(function(){n=!0})),setTimeout((function(){n||e(r).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=t(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(jQuery),function(e){"use strict";var t='[data-dismiss="alert"]',n=function(n){e(n).on("click",t,this.close)};function r(t){return this.each((function(){var r=e(this),i=r.data("bs.alert");i||r.data("bs.alert",i=new n(this)),"string"==typeof t&&i[t].call(r)}))}n.VERSION="3.4.1",n.TRANSITION_DURATION=150,n.prototype.close=function(t){var r=e(this),i=r.attr("data-target");i||(i=(i=r.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=e(document).find(i);function s(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=r.closest(".alert")),o.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),e.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",s).emulateTransitionEnd(n.TRANSITION_DURATION):s())};var i=e.fn.alert;e.fn.alert=r,e.fn.alert.Constructor=n,e.fn.alert.noConflict=function(){return e.fn.alert=i,this},e(document).on("click.bs.alert.data-api",t,n.prototype.close)}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.isLoading=!1};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.button"),o="object"==typeof n&&n;i||r.data("bs.button",i=new t(this,o)),"toggle"==n?i.toggle():n&&i.setState(n)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var n="disabled",r=this.$element,i=r.is("input")?"val":"html",o=r.data();t+="Text",null==o.resetText&&r.data("resetText",r[i]()),setTimeout(e.proxy((function(){r[i](null==o[t]?this.options[t]:o[t]),"loadingText"==t?(this.isLoading=!0,r.addClass(n).attr(n,n).prop(n,!0)):this.isLoading&&(this.isLoading=!1,r.removeClass(n).removeAttr(n).prop(n,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var n=this.$element.find("input");"radio"==n.prop("type")?(n.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==n.prop("type")&&(n.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),n.prop("checked",this.$element.hasClass("active")),e&&n.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var r=e.fn.button;e.fn.button=n,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=r,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var r=e(t.target).closest(".btn");n.call(r,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),r.is("input,button")?r.trigger("focus"):r.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(jQuery),function(e){"use strict";var t=function(t,n){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=n,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.carousel"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n),s="string"==typeof n?n:o.slide;i||r.data("bs.carousel",i=new t(this,o)),"number"==typeof n?i.to(n):s?i[s]():o.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var n=this.getItemIndex(t),r;if(("prev"==e&&0===n||"next"==e&&n==this.$items.length-1)&&!this.options.wrap)return t;var i,o=(n+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(o)},t.prototype.to=function(e){var t=this,n=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):n==e?this.pause().cycle():this.slide(e>n?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(n,r){var i=this.$element.find(".item.active"),o=r||this.getItemForDirection(n,i),s=this.interval,a="next"==n?"left":"right",u=this;if(o.hasClass("active"))return this.sliding=!1;var f=o[0],c=e.Event("slide.bs.carousel",{relatedTarget:f,direction:a});if(this.$element.trigger(c),!c.isDefaultPrevented()){if(this.sliding=!0,s&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var l=e(this.$indicators.children()[this.getItemIndex(o)]);l&&l.addClass("active")}var h=e.Event("slid.bs.carousel",{relatedTarget:f,direction:a});return e.support.transition&&this.$element.hasClass("slide")?(o.addClass(n),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(a),o.addClass(a),i.one("bsTransitionEnd",(function(){o.removeClass([n,a].join(" ")).addClass("active"),i.removeClass(["active",a].join(" ")),u.sliding=!1,setTimeout((function(){u.$element.trigger(h)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(h)),s&&this.cycle(),this}};var r=e.fn.carousel;e.fn.carousel=n,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=r,this};var i=function(t){var r=e(this),i=r.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=r.attr("data-target")||i,s=e(document).find(o);if(s.hasClass("carousel")){var a=e.extend({},s.data(),r.data()),u=r.attr("data-slide-to");u&&(a.interval=!1),n.call(s,a),u&&s.data("bs.carousel").to(u),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);n.call(t,t.data())}))}))}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.$trigger=e('[data-toggle="collapse"][href="#'+n.id+'"],[data-toggle="collapse"][data-target="#'+n.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var n,r=t.attr("data-target")||(n=t.attr("href"))&&n.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(r)}function r(n){return this.each((function(){var r=e(this),i=r.data("bs.collapse"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n);!i&&o.toggle&&/show|hide/.test(n)&&(o.toggle=!1),i||r.data("bs.collapse",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){var e;return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var n,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(n=i.data("bs.collapse"))&&n.transitioning)){var o=e.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){i&&i.length&&(r.call(i,"hide"),n||i.data("bs.collapse",null));var s=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[s](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var a=function(){this.$element.removeClass("collapsing").addClass("collapse in")[s](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return a.call(this);var u=e.camelCase(["scroll",s].join("-"));this.$element.one("bsTransitionEnd",e.proxy(a,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[s](this.$element[0][u])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var n=e.Event("hide.bs.collapse");if(this.$element.trigger(n),!n.isDefaultPrevented()){var r=this.dimension();this.$element[r](this.$element[r]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[r](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,r){var i=e(r);this.addAriaAndCollapsedClass(n(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var n=e.hasClass("in");e.attr("aria-expanded",n),t.toggleClass("collapsed",!n).attr("aria-expanded",n)};var i=e.fn.collapse;e.fn.collapse=r,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var o=n(i),s,a=o.data("bs.collapse")?"toggle":i.data();r.call(o,a)}))}(jQuery),function(e){"use strict";var t=".dropdown-backdrop",n='[data-toggle="dropdown"]',r=function(t){e(t).on("click.bs.dropdown",this.toggle)};function i(t){var n=t.attr("data-target");n||(n=(n=t.attr("href"))&&/#[A-Za-z]/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,""));var r="#"!==n?e(document).find(n):null;return r&&r.length?r:t.parent()}function o(r){r&&3===r.which||(e(t).remove(),e(n).each((function(){var t=e(this),n=i(t),o={relatedTarget:this};n.hasClass("open")&&(r&&"click"==r.type&&/input|textarea/i.test(r.target.tagName)&&e.contains(n[0],r.target)||(n.trigger(r=e.Event("hide.bs.dropdown",o)),r.isDefaultPrevented()||(t.attr("aria-expanded","false"),n.removeClass("open").trigger(e.Event("hidden.bs.dropdown",o)))))})))}function s(t){return this.each((function(){var n=e(this),i=n.data("bs.dropdown");i||n.data("bs.dropdown",i=new r(this)),"string"==typeof t&&i[t].call(n)}))}r.VERSION="3.4.1",r.prototype.toggle=function(t){var n=e(this);if(!n.is(".disabled, :disabled")){var r=i(n),s=r.hasClass("open");if(o(),!s){"ontouchstart"in document.documentElement&&!r.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",o);var a={relatedTarget:this};if(r.trigger(t=e.Event("show.bs.dropdown",a)),t.isDefaultPrevented())return;n.trigger("focus").attr("aria-expanded","true"),r.toggleClass("open").trigger(e.Event("shown.bs.dropdown",a))}return!1}},r.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var r=e(this);if(t.preventDefault(),t.stopPropagation(),!r.is(".disabled, :disabled")){var o=i(r),s=o.hasClass("open");if(!s&&27!=t.which||s&&27==t.which)return 27==t.which&&o.find(n).trigger("focus"),r.trigger("click");var a=" li:not(.disabled):visible a",u=o.find(".dropdown-menu"+a);if(u.length){var f=u.index(t.target);38==t.which&&f>0&&f--,40==t.which&&fdocument.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},f.prototype.init=function(t,n,r){if(this.enabled=!0,this.type=t,this.$element=e(n),this.options=this.getOptions(r),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),o=i.length;o--;){var s=i[o];if("click"==s)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=s){var a="hover"==s?"mouseenter":"focusin",u="hover"==s?"mouseleave":"focusout";this.$element.on(a+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(u+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},f.prototype.getDefaults=function(){return f.DEFAULTS},f.prototype.getOptions=function(n){var r=this.$element.data();for(var i in r)r.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete r[i];return(n=e.extend({},this.getDefaults(),r,n)).delay&&"number"==typeof n.delay&&(n.delay={show:n.delay,hide:n.delay}),n.sanitize&&(n.template=u(n.template,n.whiteList,n.sanitizeFn)),n},f.prototype.getDelegateOptions=function(){var t={},n=this.getDefaults();return this._options&&e.each(this._options,(function(e,r){n[e]!=r&&(t[e]=r)})),t},f.prototype.enter=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusin"==t.type?"focus":"hover"]=!0),n.tip().hasClass("in")||"in"==n.hoverState)n.hoverState="in";else{if(clearTimeout(n.timeout),n.hoverState="in",!n.options.delay||!n.options.delay.show)return n.show();n.timeout=setTimeout((function(){"in"==n.hoverState&&n.show()}),n.options.delay.show)}},f.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},f.prototype.leave=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusout"==t.type?"focus":"hover"]=!1),!n.isInStateTrue()){if(clearTimeout(n.timeout),n.hoverState="out",!n.options.delay||!n.options.delay.hide)return n.hide();n.timeout=setTimeout((function(){"out"==n.hoverState&&n.hide()}),n.options.delay.hide)}},f.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var n=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!n)return;var r=this,i=this.tip(),o=this.getUID(this.type);this.setContent(),i.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&i.addClass("fade");var s="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,a=/\s?auto?\s?/i,u=a.test(s);u&&(s=s.replace(a,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(s).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var c=this.getPosition(),l=i[0].offsetWidth,h=i[0].offsetHeight;if(u){var d=s,p=this.getPosition(this.$viewport);s="bottom"==s&&c.bottom+h>p.bottom?"top":"top"==s&&c.top-hp.width?"left":"left"==s&&c.left-ls.top+s.height&&(i.top=s.top+s.height-u)}else{var f=t.left-o,c=t.left+o+n;fs.right&&(i.left=s.left+s.width-c)}return i},f.prototype.getTitle=function(){var e,t=this.$element,n=this.options;return e=t.attr("data-original-title")||("function"==typeof n.title?n.title.call(t[0]):n.title)},f.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},f.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},f.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},f.prototype.enable=function(){this.enabled=!0},f.prototype.disable=function(){this.enabled=!1},f.prototype.toggleEnabled=function(){this.enabled=!this.enabled},f.prototype.toggle=function(t){var n=this;t&&((n=e(t.currentTarget).data("bs."+this.type))||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n))),t?(n.inState.click=!n.inState.click,n.isInStateTrue()?n.enter(n):n.leave(n)):n.tip().hasClass("in")?n.leave(n):n.enter(n)},f.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},f.prototype.sanitizeHtml=function(e){return u(e,this.options.whiteList,this.options.sanitizeFn)};var l=e.fn.tooltip;e.fn.tooltip=c,e.fn.tooltip.Constructor=f,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=l,this}}(jQuery),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");function n(n){return this.each((function(){var r=e(this),i=r.data("bs.popover"),o="object"==typeof n&&n;!i&&/destroy|hide/.test(n)||(i||r.data("bs.popover",i=new t(this,o)),"string"==typeof n&&i[n]())}))}t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:''}),t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype),t.prototype.constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),n=this.getContent();if(this.options.html){var r=typeof n;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===r&&(n=this.sanitizeHtml(n))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===r?"html":"append"](n)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(n);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var r=e.fn.popover;e.fn.popover=n,e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=r,this}}(jQuery),function(e){"use strict";function t(n,r){this.$body=e(document.body),this.$scrollElement=e(n).is(document.body)?e(window):e(n),this.options=e.extend({},t.DEFAULTS,r),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function n(n){return this.each((function(){var r=e(this),i=r.data("bs.scrollspy"),o="object"==typeof n&&n;i||r.data("bs.scrollspy",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,n="offset",r=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(n="position",r=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),o=/^#./.test(i)&&e(i);return o&&o.length&&o.is(":visible")&&[[o[n]().top+r,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.getScrollHeight(),n=this.options.offset+t-this.$scrollElement.height(),r=this.offsets,i=this.targets,o=this.activeTarget,s;if(this.scrollHeight!=t&&this.refresh(),e>=n)return o!=(s=i[i.length-1])&&this.activate(s);if(o&&e=r[s]&&(void 0===r[s+1]||e .active"),s=i&&e.support.transition&&(o.length&&o.hasClass("fade")||!!r.find("> .fade").length);function a(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),n.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),s?(n[0].offsetWidth,n.addClass("in")):n.removeClass("fade"),n.parent(".dropdown-menu").length&&n.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&s?o.one("bsTransitionEnd",a).emulateTransitionEnd(t.TRANSITION_DURATION):a(),o.removeClass("in")};var r=e.fn.tab;e.fn.tab=n,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=r,this};var i=function(t){t.preventDefault(),n.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(e){"use strict";var t=function(n,r){this.options=e.extend({},t.DEFAULTS,r);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(n),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.affix"),o="object"==typeof n&&n;i||r.data("bs.affix",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,n,r){var i=this.$target.scrollTop(),o=this.$element.offset(),s=this.$target.height();if(null!=n&&"top"==this.affixed)return i=e-r&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),n=this.$element.offset();return this.pinnedOffset=n.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var n=this.$element.height(),r=this.options.offset,i=r.top,o=r.bottom,s=Math.max(e(document).height(),e(document.body).height());"object"!=typeof r&&(o=i=r),"function"==typeof i&&(i=r.top(this.$element)),"function"==typeof o&&(o=r.bottom(this.$element));var a=this.getState(s,n,i,o);if(this.affixed!=a){null!=this.unpin&&this.$element.css("top","");var u="affix"+(a?"-"+a:""),f=e.Event(u+".bs.affix");if(this.$element.trigger(f),f.isDefaultPrevented())return;this.affixed=a,this.unpin="bottom"==a?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(u).trigger(u.replace("affix","affixed")+".bs.affix")}"bottom"==a&&this.$element.offset({top:s-n-o})}};var r=e.fn.affix;e.fn.affix=n,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=r,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),r=t.data();r.offset=r.offset||{},null!=r.offsetBottom&&(r.offset.bottom=r.offsetBottom),null!=r.offsetTop&&(r.offset.top=r.offsetTop),n.call(t,r)}))}))}(jQuery)}}}},fibers:{"package.json":function e(t,n,e){e.exports={name:"fibers",version:"5.0.3",main:"fibers"}},"fibers.js":function e(t,n,e,r,i){if(process.fiberLib)e.exports=process.fiberLib;else{var o=t("fs"),s=t("path"),a=t("detect-libc");Math.random();var u=s.join(i,"bin",process.platform+"-"+process.arch+"-"+process.versions.modules+("linux"===process.platform?"-"+a.family:""),"fibers");try{process.fiberLib=e.exports=t(u).Fiber}catch(c){throw console.error("## There is an issue with `node-fibers` ##\n`"+u+".node` is missing.\n\nTry running this to fix the issue: "+process.execPath+" "+i.replace(" ","\\ ")+"/build"),console.error(c.stack||c.message||c),new Error("Missing binary. See message above.")}f(e.exports)}function f(e){try{var t=process.binding("async_wrap"),n;if(t.asyncIdStackSize instanceof Function)n=t.asyncIdStackSize;else{if(void 0===t.constants.kStackLength)throw new Error("Couldn't figure out how to get async stack size");l=t.constants.kStackLength,n=function(){return t.async_hook_fields[l]}}var r=t.popAsyncContext||t.popAsyncIds,i=t.pushAsyncContext||t.pushAsyncIds,o,s;if(!r||!i)throw new Error("Push/pop do not exist");o=void 0===t.constants.kExecutionAsyncId?t.constants.kCurrentAsyncId:t.constants.kExecutionAsyncId,s=void 0===t.constants.kTriggerAsyncId?t.constants.kCurrentTriggerId:t.constants.kTriggerAsyncId;var a=t.async_id_fields||t.async_uid_fields;function u(){for(var e=n(),t=new Array(e);e>0;--e){var i=a[o];t[e-1]={asyncId:i,triggerId:a[s]},r(i)}return t}function f(e){for(var t=0;t0)i.changeLanguage(e,r);else if(0!=a[u]){a[u]=0;var f=new XMLHttpRequest;f.overrideMimeType("application/json"),f.open("GET",u,!1),f.send(null),200===f.status?a[u]=1:a[u]=-1,n.addResourceBundle(e,s,JSON.parse(f.response)||{}),i.changeLanguage(e,r)}};n.changeLanguage=p;var g=function(e,t,n){return i.format(e,t,n)};n.format=g;var b=function(){return i.languages};n.getLanguages=b;var m=function(e,t){return i.loadLanguages(e,t)};n.loadLanguages=m;var v=function(e,t){return i.loadNamespaces(e,t)};n.loadNamespaces=v;var y=function(e,t){return i.on(e,t)};n.on=y;var _=function(e,t){return i.off(e,t)};n.off=_,r.__exportStar(t("./i18n/i18n"),n),r.__exportStar(t("./i18n/i18n.app"),n),r.__exportStar(t("./translations"),n)},i18n:{"i18n.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.fallbackKeys=n.getObjectI18nTemplate=n.translationI18nObjects=n.addObjectsI18n=n.translationI18nObject=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="_",a="base",u="core",f="translation",c=function(e,t){var n={lng:t,ns:f};if((0,r.exists)(e,n))return(0,r._t)(e,n)},l=function(e){return"".concat(e,"__object")},h=function(e,t){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t)},d=function(e,t){var n=h(e,t);return"".concat(n).concat("_","inlineHelpText")},p=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","group").concat("_").concat(n)},g=function(e,t,n){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t).concat("_","options").concat("_").concat(n)},b=function(e,t){return"".concat(e).concat("_","action").concat("_").concat(t)},m=function(e,t){return"".concat(e).concat("_","listview").concat("_").concat(t)},v=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},y=function(e,t,n){var r=l(t);return c(r,e)||n||""},_=function(e,t,n,r,i){var o=h(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=_(e,a,n,r,i))}return s||r||""},w=function(e,t,n,r,i){var o=d(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=w(e,a,n,r,i))}return s||r||""},k=function(e,t,n,r){var i=p(t,n);return c(i,e)||r||""},j=function(e,t,n,r,i,o){var s=g(t,n,r),a=c(s,e);if(!a){var u=v(o);u&&"base"!=t&&"core"!=t&&(a=j(e,u,n,r,i,o))}return a||i||""},x=function(e,t,n,r,i){var o=b(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=x(e,a,n,r,i))}return s||r||""},S=function(e,t,n,r,i){var o=m(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=S(e,a,n,r,i))}return s||r||""},D=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},E=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;return e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(D(e))}))):n.push(D(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},A=function(e,t,n){n.label=y(e,t,n.label),i.each(n.fields,(function(r,o){if(r.label=_(e,t,o,r.label,n.datasource),r.inlineHelpText&&(r.inlineHelpText=w(e,t,o,r.inlineHelpText,n.datasource)),r.group&&(r.group=k(e,t,r.group,r.group)),r.options){var s=[];i.each(r.options,(function(r){if(i.has(r,"value")){var a=j(e,t,o,r.value,r.label,n.datasource);s.push(i.extend({},r,{label:a}))}else s.push(r)})),r.options=s}})),i.each(n.actions,(function(r,i){r.label=x(e,t,i,r.label,n.datasource)})),i.each(n.list_views,(function(r,i){r.label=S(e,t,i,r.label,n.datasource)}))};n.translationI18nObject=A;var C=function(e){i.each(e,(function(e){(0,r.addResourceBundle)(e.lng,f,e.data,!0,!0)}))};n.addObjectsI18n=C;var M=function(e,t){i.each(t,(function(t,r){(0,n.translationI18nObject)(e,r,t)}))};n.translationI18nObjects=M;var O=function(e,t,n){var r=o(n);E(r);var s={};return s[l(t)]=y(e,t,r.label),i.each(r.fields,(function(n,o){s[h(t,o)]=_(e,t,o,n.label),n.inlineHelpText&&(s[d(t,o)]=w(e,t,o,n.inlineHelpText,r.datasource)),n.group&&(s[p(t,n.group)]=k(e,t,n.group,n.group)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[g(t,o,n.value)]=j(e,t,o,n.value,n.label))}))})),i.each(r.actions,(function(n,r){s[b(t,r)]=x(e,t,r,n.label)})),i.each(r.list_views,(function(n,r){s[m(t,r)]=S(e,t,r,n.label)})),s};n.getObjectI18nTemplate=O,n.fallbackKeys={getObjectLabelKey:l,getObjectFieldLabelKey:h,getObjectFieldInlineHelpTextLabelKey:d,getObjectFieldGroupKey:p,getObjectFieldOptionsLabelKey:g,getObjectActionLabelKey:b,getObjectListviewLabelKey:m}},"i18n.app.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.appFallbackKeys=n.getAppI18nTemplate=n.translationI18nApps=n.translationI18nMenus=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="translation",a="_",u=function(e,t){var n={lng:t,ns:s};if((0,r.exists)(e,n))return(0,r._t)(e,n)},f=function(e){return"app".concat("_").concat(e).concat("_","name")},c=function(e){return"app".concat("_").concat(e).concat("_","description")},l=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","tab_group").concat("_").concat(n)},h=function(e){return"menu".concat("_").concat(e)},d=function(e){return"tab".concat("_").concat(e)},p=function(e,t,n){var r=f(t);return u(r,e)||n||""},g=function(e,t,n){var r=c(t);return u(r,e)||n||""},b=function(e,t,n){var r=h(t);return u(r,e)||n||""},m=function(e,t,r){r.label=p(e,t,r.label||r.name),r.description=g(e,t,r.description),(0,n.translationI18nMenus)(e,r.admin_menus)},v=function(e,t){i.each(t,(function(t){var n=b(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationI18nMenus=v;var y=function(e,t){i.each(t,(function(t,n){m(e,n,t)}))};n.translationI18nApps=y;var _=function(e,t,n){var r=o(n),s={};return s[f(t)]=p(e,t,r.label||r.name),s[c(t)]=g(e,t,r.description),i.each(r.admin_menus,(function(t){s[h(t._id)]=b(e,t._id,t.label||t.name)})),s};n.getAppI18nTemplate=_,n.appFallbackKeys={getAppLabelKey:f,getAppDescriptionKey:c,getAppGroupKey:l,getMenuLabelKey:h,getTabKey:d}}},translations:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.SteedosTranslationPrefixKeys=n.convertObject=void 0;var r=t("tslib"),i=t("underscore");r.__exportStar(t("./objectTranslation"),n),r.__exportStar(t("./translation"),n),r.__exportStar(t("./templates/objectTranslation"),n),r.__exportStar(t("./templates/translation"),n);var o=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},s=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(o(e))}))):n.push(o(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else if(e.options&&i.isArray(e.options))try{i.forEach(e.options,(function(e){i.isString(e)?n.push(o(e)):n.push(e)})),e.options=n}catch(r){console.error("Creator.convertFieldsOptions",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},a;n.convertObject=s,function(e){e.Object="CustomObject",e.Field="CustomField",e.Action="CustomAction",e.Listview="CustomListview",e.Permission="CustomPermission",e.ValidationRule="CustomValidationRule",e.Application="CustomApplication",e.Tab="CustomTabs",e.Permissionset="CustomPermissionset",e.Profile="CustomProfile",e.Report="CustomReport",e.Workflow="Workflow",e.Layout="Layout",e.Client="Client",e.Server="Server",e.Function="Function",e.Router="Router",e.Trigger="Trigger"}(a=n.SteedosTranslationPrefixKeys||(n.SteedosTranslationPrefixKeys={}))},"objectTranslation.js":function e(t,n,e,r){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addObjectsTranslation=n.getObjectTranslationTemplate=n.translationObjects=n.translationObject=n.translationObjectLabel=void 0;var i=t("underscore"),o=t("./"),s=t("../index"),a=t("./index"),u=t("../i18n/i18n"),f=t("lodash"),c=t("crypto"),l,h=(0,t("@steedos/cachers").getCacher)("lru.translations.objects");function d(e){var t;return c.createHash("md5").update(e).digest("hex")}var p=function(e,t){return"".concat(e,"_").concat(t.name,"_").concat(d(JSON.stringify(t)))},g=t("clone"),b=".",m="base",v="core",y="translation",_="object",w="field",k="listview",j="action",x=function(e,t){var n={lng:t,ns:y,keySeparator:!1};if((0,s.exists)(e,n))return(0,s._t)(e,n)},S=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},D=function(e){switch(e){case"object":return o.SteedosTranslationPrefixKeys.Object;case"field":return o.SteedosTranslationPrefixKeys.Field;case"listview":return o.SteedosTranslationPrefixKeys.Listview;case"action":return o.SteedosTranslationPrefixKeys.Action;default:return"CustomLabels"}},E=function(e){var t;return[D(),e].join(".")},A=function(e){var t;return[D("object"),e,"label"].join(".")},C=function(e){var t;return[D("object"),e,"description"].join(".")},M=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"label"].join(".")},O=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"help"].join(".")},T=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"description"].join(".")},B=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_"),r;return[D("field"),e,"group",n].join(".")},I=function(e,t,n){var r;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"options",n].join(".")},R=function(e,t){var n;return[D("action"),e,t].join(".")},F=function(e,t){var n;return[D("listview"),e,t].join(".")},P=function(e,t,n){var r,i=[A(t)],o=u.fallbackKeys.getObjectLabelKey(t);return o&&i.push(o),x(i,e)||n||""};n.translationObjectLabel=P;var N=function(e,t,n){var r=C(t);return x(r,e)||n||""},L=function(e,t,n,r,i,o){var s,a=[M(t,n)],f=u.fallbackKeys.getObjectFieldLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=L(e,l,n,r,i))}return c||r||""},z=function(e,t,n,r,i,o){var s,a=[O(t,n)],f=u.fallbackKeys.getObjectFieldInlineHelpTextLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=z(e,l,n,r,i))}return c||r||""},U=function(e,t,n,r,i,o){var s=T(t,n),a,u=x([s],e);if(1!=o&&!u){var f=S(i);f&&"base"!=t&&"core"!=t&&(u=U(e,f,n,r,i))}return u||r||""},q=function(e,t,n,r,i,o){var s,a=[B(t,n)],f=u.fallbackKeys.getObjectFieldGroupKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=q(e,l,n,r,i))}return c||r||""},$=function(e,t,n,r,i,o,s){var a,f=[I(t,n,r)],c=u.fallbackKeys.getObjectFieldOptionsLabelKey(t,n,r);c&&f.push(c);var l=x(f,e);if(1!=s&&!l){var h=S(o);h&&"base"!=t&&"core"!=t&&(l=$(e,h,n,r,i,o))}return l||i||""},W=function(e,t,n,r,i,o){var s,a=[R(t,n)],f=u.fallbackKeys.getObjectActionLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=W(e,l,n,r,i))}return c||r||""},H=function(e,t,n,r,i,o){var s,a=[F(t,n)],f=u.fallbackKeys.getObjectListviewLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=H(e,l,n,r,i))}return c||r||""},Y=function(e,t,r,o,s){void 0===s&&(s=!1);var u=p(e,r),c=h.get(u);if(c)return Object.assign(r,(0,f.cloneDeep)(c));o&&(0,a.convertObject)(r),r.label=(0,n.translationObjectLabel)(e,t,r.label),r.description=N(e,t,r.description),i.each(r.fields,(function(n,o){if(n.label=L(e,t,o,n.label,r.datasource,s),n.inlineHelpText=z(e,t,o,n.inlineHelpText,r.datasource,s),n.description=U(e,t,o,n.description,r.datasource,s),n.group&&(n.group=q(e,t,n.group,n.group,r.datasource,s)),n.options){var a=[];i.each(n.options,(function(n){if(i.has(n,"value")){var u=$(e,t,o,n.value,n.label,r.datasource,s);a.push(i.extend({},n,{label:u}))}else a.push(n)})),n.options=a}})),i.each(r.actions,(function(n,i){n.label=W(e,t,i,n.label,r.datasource,s)})),i.each(r.list_views,(function(n,i){n.label=H(e,t,i,n.label,r.datasource,s)})),h.set(u,(0,f.cloneDeep)(r))};n.translationObject=Y;var V=function(e,t){i.each(t,(function(t,r){(0,n.translationObject)(e,r,t)}))};n.translationObjects=V;var K=function(e,t,r){var o=g(r);(0,a.convertObject)(o);var s={};return s[A(t)]=(0,n.translationObjectLabel)(e,t,o.label),s[C(t)]=N(e,t,o.description),i.each(o.fields,(function(n,r){s[M(t,r)]=L(e,t,r,n.label),n.inlineHelpText&&(s[O(t,r)]=z(e,t,r,n.inlineHelpText,o.datasource)),n.description&&(s[T(t,r)]=U(e,t,r,n.description,o.datasource)),n.group&&(s[B(t,n.group)]=q(e,t,n.group,n.group,o.datasource)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[I(t,r,n.value)]=$(e,t,r,n.value,n.label))}))})),i.each(o.actions,(function(n,r){s[R(t,r)]=W(e,t,r,n.label)})),i.each(o.list_views,(function(n,r){s[F(t,r)]=H(e,t,r,n.label)})),s};function G(e,t){var n=g(e);(0,a.convertObject)(n);var r={},o=n.name;return o||console.error("Error: Invalid objectTranslation:"+t),r[A(o)]=n.label,r[C(o)]=n.description,i.each(n.fields,(function(e,t){r[M(o,t)]=e.label,e.help&&(r[O(o,t)]=e.help),e.description&&(r[T(o,t)]=e.description),e.options&&i.each(e.options,(function(e){i.has(e,"value")&&(r[I(o,t,e.value)]=e.label)}))})),i.each(n.groups,(function(e,t){r[B(o,t)]=e})),i.each(n.actions,(function(e,t){r[R(o,t)]=e.label})),i.each(n.listviews,(function(e,t){r[F(o,t)]=e.label})),i.each(n.CustomLabels,(function(e,t){r[E(t)]=e})),r}n.getObjectTranslationTemplate=K;var X=function(e){i.each(e,(function(e){var t=G(e.data,e.__filename);(0,s.addResourceBundle)(e.lng,y,t,!0,!0)}))};n.addObjectsTranslation=X},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addTranslations=n.convertTranslation=n.convertTranslationData=n.getAppTranslationTemplate=n.translationApps=n.translationMenus=n.translationApp=n.translationTabLabel=n.translationTabGroup=void 0;var r=t("../index"),i=t("underscore"),o=t("./"),s=t("../i18n/i18n.app"),a=t("clone"),u="translation",f=".",c="app",l="menu",h="tab",d=function(e){switch(e){case"app":return o.SteedosTranslationPrefixKeys.Application;case"tab":return o.SteedosTranslationPrefixKeys.Tab;default:return"CustomLabels"}},p=function(e){var t;return[d(),e].join(".")},g=function(e,t){var n={lng:t,ns:u,keySeparator:!1};if((0,r.exists)(e,n))return(0,r._t)(e,n)},b=function(e){var t;return[d("app"),e,"name"].join(".")},m=function(e){var t;return[d("app"),e,"description"].join(".")},v=function(e,t){var n,r;return[d("app"),e,"groups",t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_")].join(".")},y=function(e){var t;return[d("menu"),"menu_".concat(e)].join(".")},_=function(e){var t;return[d("tab"),e].join(".")},w=function(e,t,n){var r,i=[b(t)],o=s.appFallbackKeys.getAppLabelKey(t);return o&&i.push(o),g(i,e)||n||""},k=function(e,t,n){var r,i=[m(t)],o=s.appFallbackKeys.getAppDescriptionKey(t);return o&&i.push(o),g(i,e)||n||""},j=function(e,t,n,r){var i,o=[v(t,n)],a=s.appFallbackKeys.getAppGroupKey(t,n);return a&&o.push(a),g(o,e)||r||""};n.translationTabGroup=j;var x=function(e,t,n){var r,i=[y(t)],o=s.appFallbackKeys.getMenuLabelKey(t);return o&&i.push(o),g(i,e)||n||""},S=function(e,t,n){var r,i=[_(t)],o=s.appFallbackKeys.getTabKey(t);return o&&i.push(o),g(i,e)||n||""};n.translationTabLabel=S;var D=function(e,t,r){r.label=w(e,t,r.label||r.name),r.description=k(e,t,r.description),i.each(r.tab_groups,(function(i,o){r.tab_groups[o].id=i.id||i.group_name,r.tab_groups[o].group_name=(0,n.translationTabGroup)(e,t,i.group_name,i.group_name)})),(0,n.translationMenus)(e,r.admin_menus)};n.translationApp=D;var E=function(e,t){i.each(t,(function(t){var n=x(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationMenus=E;var A=function(e,t){i.each(t,(function(t,r){(0,n.translationApp)(e,r,t)}))};n.translationApps=A;var C=function(e,t,n){var r=a(n),o={};return o[b(t)]=w(e,t,r.label||r.name),o[m(t)]=k(e,t,r.description),i.each(r.admin_menus,(function(t){o[y(t._id)]=x(e,t._id,t.label||t.name)})),o};n.getAppTranslationTemplate=C;var M=function(e,t,n){i.isArray(n)?i.each(n,(function(e){M(e,"",e)})):n&&i.each(i.keys(n),(function(r){var o=t?"".concat(t,".").concat(r):r,s=n[r];"object"==typeof s?i.isArray(s)?i.each(s,(function(e){M(e,o,s)})):M(e,o,s):e[o]=s}))};function O(e){for(var t in e)"object"==typeof e[t]&&M(e,t,e[t]);return e}n.convertTranslationData=O;var T=function(e){var t=a(e),n={};return i.each(t.CustomApplications,(function(e,t){n[b(t)]=e.name,n[m(t)]=e.description,i.each(e.groups,(function(e,r){n[v(t,r)]=e}))})),i.each(t.CustomTabs,(function(e,t){n[_(t)]=e})),i.each(t.CustomLabels,(function(e,t){var r;if("simpleschema"!=t&&i.isObject(e)){var o=O(((r={})[t]=e,r));i.each(o,(function(e,t){i.isObject(e)||(n[p(t)]=e)}))}else n[p(t)]=e})),n};n.convertTranslation=T;var B=function(e){i.each(e,(function(e){var t=(0,n.convertTranslation)(e.data);(0,r.addResourceBundle)(e.lng,u,t,!0,!0)}))};n.addTranslations=B},templates:{"objectTranslation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getObjectMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]="help"===e?t.inlineHelpText||"":t[e]||""})),n}function a(e){return s(["label","description"],e)}function u(e){switch(e.type){case"select":return s(["label","help","options","description"],e);default:return s(["label","help","description"],e)}}function f(e){return s(["label"],e)}function c(e){return s(["label"],e)}function l(e){var t={};return r.each(e,(function(e,n){t[n]=u(e)})),t}function h(e){var t={};return r.each(e,(function(e,n){t[n]=c(e)})),t}function d(e){var t={};return r.each(e,(function(e,n){t[n]=f(e)})),t}function p(e,t){var n={};return r.each(e,(function(e,r){if(e.group){var i=e.group.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");n[i]=t[r].group}})),n}var g=function(e,t,n,s){void 0===s&&(s=!1);var u=o(n);1!=s&&(0,i.translationObject)(e,t,u,!0,s);var f=Object.assign({},a(u));f=Object.assign({},f,{fields:l(u.fields)});var c=p(n.fields,u.fields);r.isEmpty(c)||(f=Object.assign({},f,{groups:c}));var g=d(u.list_views);r.isEmpty(g)||(f=Object.assign({},f,{listviews:g}));var b=h(u.actions);return r.isEmpty(b)||(f=Object.assign({},f,{actions:b})),Object.assign({name:t},f)};n.getObjectMetadataTranslationTemplate=g},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getAppMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]=t[e]||""})),n}function a(e){var t={groups:{}};return e?(r.each(e,(function(e){var n=e.group_name.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t.groups[n]=e.group_name})),t):{}}var u=function(e){return Object.assign({},s(["name","description"],e),a(e.tab_groups))},f=function(e){var t={};return r.each(e,(function(e,n){t[n]=n})),t},c=function(e){var t={};return r.each(e,(function(e){var n=e.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t[n]=e})),t},l=function(e,t,n){var r,s=o(n);(0,i.translationApp)(e,t,s);var a={},l;return s.tab_items?a=f(s.tab_items):s.tabs&&(a=c(s.tabs)),Object.assign({},{CustomApplications:(r={},r[t]=u(s),r)},{CustomTabs:a})};n.getAppMetadataTranslationTemplate=l}}}},node_modules:{i18next:{"package.json":function e(t,n,e){e.exports={name:"i18next",version:"19.9.2",module:"./dist/esm/i18next.js",main:"./dist/cjs/i18next.js"}},dist:{esm:{"i18next.js":function e(t,n,e){let r,i,o,s,a,u,f,c;e.link("@babel/runtime/helpers/esm/typeof",{default(e){r=e}},0),e.link("@babel/runtime/helpers/esm/objectSpread",{default(e){i=e}},1),e.link("@babel/runtime/helpers/esm/classCallCheck",{default(e){o=e}},2),e.link("@babel/runtime/helpers/esm/createClass",{default(e){s=e}},3),e.link("@babel/runtime/helpers/esm/possibleConstructorReturn",{default(e){a=e}},4),e.link("@babel/runtime/helpers/esm/getPrototypeOf",{default(e){u=e}},5),e.link("@babel/runtime/helpers/esm/assertThisInitialized",{default(e){f=e}},6),e.link("@babel/runtime/helpers/esm/inherits",{default(e){c=e}},7);var l={type:"logger",log:function e(t){this.output("log",t)},warn:function e(t){this.output("warn",t)},error:function e(t){this.output("error",t)},output:function e(t,n){console&&console[t]&&console[t].apply(console,n)}},h,d=new(function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.init(t,n)}return s(e,[{key:"init",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=n.prefix||"i18next:",this.logger=t||l,this.options=n,this.debug=n.debug}},{key:"setDebug",value:function e(t){this.debug=t}},{key:"log",value:function e(){for(var t=arguments.length,n=new Array(t),r=0;r1?n-1:0),i=1;i-1?e.replace(/###/g,"."):e}function i(){return!e||"string"==typeof e}for(var o="string"!=typeof t?[].concat(t):t.split(".");o.length>1;){if(i())return{};var s=r(o.shift());!e[s]&&n&&(e[s]=new n),e=Object.prototype.hasOwnProperty.call(e,s)?e[s]:{}}return i()?{}:{obj:e,k:r(o.shift())}}function y(e,t,n){var r=v(e,t,Object),i,o;r.obj[r.k]=n}function _(e,t,n,r){var i=v(e,t,Object),o=i.obj,s=i.k;o[s]=o[s]||[],r&&(o[s]=o[s].concat(n)),r||o[s].push(n)}function w(e,t){var n=v(e,t),r=n.obj,i=n.k;if(r)return r[i]}function k(e,t,n){var r=w(e,n);return void 0!==r?r:w(t,n)}function j(e,t,n){for(var r in t)"__proto__"!==r&&"constructor"!==r&&(r in e?"string"==typeof e[r]||e[r]instanceof String||"string"==typeof t[r]||t[r]instanceof String?n&&(e[r]=t[r]):j(e[r],t[r],n):e[r]=t[r]);return e}function x(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var S={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};function D(e){return"string"==typeof e?e.replace(/[&<>"'\/]/g,(function(e){return S[e]})):e}var E="undefined"!=typeof window&&window.navigator&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,A=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),n.data=e||{},n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n}return c(t,e),s(t,[{key:"addNamespaces",value:function e(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function e(t){var n=this.options.ns.indexOf(t);n>-1&&this.options.ns.splice(n,1)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==i.keySeparator?i.keySeparator:this.options.keySeparator,s=[t,n];return r&&"string"!=typeof r&&(s=s.concat(r)),r&&"string"==typeof r&&(s=s.concat(o?r.split(o):r)),t.indexOf(".")>-1&&(s=t.split(".")),w(this.data,s)}},{key:"addResource",value:function e(t,n,r,i){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},s=this.options.keySeparator;void 0===s&&(s=".");var a=[t,n];r&&(a=a.concat(s?r.split(s):r)),t.indexOf(".")>-1&&(i=n,n=(a=t.split("."))[1]),this.addNamespaces(n),y(this.data,a,i),o.silent||this.emit("added",t,n,r,i)}},{key:"addResources",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in r)"string"!=typeof r[o]&&"[object Array]"!==Object.prototype.toString.apply(r[o])||this.addResource(t,n,o,r[o],{silent:!0});i.silent||this.emit("added",t,n,r)}},{key:"addResourceBundle",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},u=[t,n];t.indexOf(".")>-1&&(o=r,r=n,n=(u=t.split("."))[1]),this.addNamespaces(n);var f=w(this.data,u)||{};o?j(f,r,s):f=i({},f,r),y(this.data,u,f),a.silent||this.emit("added",t,n,r)}},{key:"removeResourceBundle",value:function e(t,n){this.hasResourceBundle(t,n)&&delete this.data[t][n],this.removeNamespaces(n),this.emit("removed",t,n)}},{key:"hasResourceBundle",value:function e(t,n){return void 0!==this.getResource(t,n)}},{key:"getResourceBundle",value:function e(t,n){return n||(n=this.options.defaultNS),"v1"===this.options.compatibilityAPI?i({},{},this.getResource(t,n)):this.getResource(t,n)}},{key:"getDataByLanguage",value:function e(t){return this.data[t]}},{key:"toJSON",value:function e(){return this.data}}]),t}(p),C={processors:{},addPostProcessor:function e(t){this.processors[t.name]=t},handle:function e(t,n,r,i,o){var s=this;return t.forEach((function(e){s.processors[e]&&(n=s.processors[e].process(n,r,i,o))})),n}},M={},O=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),m(["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],e,f(n)),n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n.logger=d.create("translator"),n}return c(t,e),s(t,[{key:"changeLanguage",value:function e(t){t&&(this.language=t)}},{key:"exists",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}},r=this.resolve(t,n);return r&&void 0!==r.res}},{key:"extractFromKey",value:function e(t,n){var r=void 0!==n.nsSeparator?n.nsSeparator:this.options.nsSeparator;void 0===r&&(r=":");var i=void 0!==n.keySeparator?n.keySeparator:this.options.keySeparator,o=n.ns||this.options.defaultNS;if(r&&t.indexOf(r)>-1){var s=t.match(this.interpolator.nestingRegexp);if(s&&s.length>0)return{key:t,namespaces:o};var a=t.split(r);(r!==i||r===i&&this.options.ns.indexOf(a[0])>-1)&&(o=a.shift()),t=a.join(i)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function e(n,o,s){var a=this;if("object"!==r(o)&&this.options.overloadTranslationOptionHandler&&(o=this.options.overloadTranslationOptionHandler(arguments)),o||(o={}),null==n)return"";Array.isArray(n)||(n=[String(n)]);var u=void 0!==o.keySeparator?o.keySeparator:this.options.keySeparator,f=this.extractFromKey(n[n.length-1],o),c=f.key,l=f.namespaces,h=l[l.length-1],d=o.lng||this.language,p=o.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(d&&"cimode"===d.toLowerCase()){if(p){var g=o.nsSeparator||this.options.nsSeparator;return h+g+c}return c}var b=this.resolve(n,o),m=b&&b.res,v=b&&b.usedKey||c,y=b&&b.exactUsedKey||c,_=Object.prototype.toString.apply(m),w=["[object Number]","[object Function]","[object RegExp]"],k=void 0!==o.joinArrays?o.joinArrays:this.options.joinArrays,j=!this.i18nFormat||this.i18nFormat.handleAsObject,x="string"!=typeof m&&"boolean"!=typeof m&&"number"!=typeof m;if(j&&m&&x&&w.indexOf(_)<0&&("string"!=typeof k||"[object Array]"!==_)){if(!o.returnObjects&&!this.options.returnObjects)return this.logger.warn("accessing an object - but returnObjects options is not enabled!"),this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,m,o):"key '".concat(c," (").concat(this.language,")' returned an object instead of string.");if(u){var S="[object Array]"===_,D=S?[]:{},E=S?y:v;for(var A in m)if(Object.prototype.hasOwnProperty.call(m,A)){var C="".concat(E).concat(u).concat(A);D[A]=this.translate(C,i({},o,{joinArrays:!1,ns:l})),D[A]===C&&(D[A]=m[A])}m=D}}else if(j&&"string"==typeof k&&"[object Array]"===_)(m=m.join(k))&&(m=this.extendTranslation(m,n,o,s));else{var M=!1,O=!1,T=void 0!==o.count&&"string"!=typeof o.count,B=t.hasDefaultValue(o),I=T?this.pluralResolver.getSuffix(d,o.count):"",R=o["defaultValue".concat(I)]||o.defaultValue;!this.isValidLookup(m)&&B&&(M=!0,m=R),this.isValidLookup(m)||(O=!0,m=c);var F=B&&R!==m&&this.options.updateMissing;if(O||M||F){if(this.logger.log(F?"updateKey":"missingKey",d,h,c,F?R:m),u){var P=this.resolve(c,i({},o,{keySeparator:!1}));P&&P.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var N=[],L=this.languageUtils.getFallbackCodes(this.options.fallbackLng,o.lng||this.language);if("fallback"===this.options.saveMissingTo&&L&&L[0])for(var z=0;z1&&void 0!==arguments[1]?arguments[1]:{},i,o,s,a,u;return"string"==typeof t&&(t=[t]),t.forEach((function(e){if(!n.isValidLookup(i)){var t=n.extractFromKey(e,r),f=t.key;o=f;var c=t.namespaces;n.options.fallbackNS&&(c=c.concat(n.options.fallbackNS));var l=void 0!==r.count&&"string"!=typeof r.count,h=void 0!==r.context&&"string"==typeof r.context&&""!==r.context,d=r.lngs?r.lngs:n.languageUtils.toResolveHierarchy(r.lng||n.language,r.fallbackLng);c.forEach((function(e){n.isValidLookup(i)||(u=e,!M["".concat(d[0],"-").concat(e)]&&n.utils&&n.utils.hasLoadedNamespace&&!n.utils.hasLoadedNamespace(u)&&(M["".concat(d[0],"-").concat(e)]=!0,n.logger.warn('key "'.concat(o,'" for languages "').concat(d.join(", "),'" won\'t get resolved as namespace "').concat(u,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),d.forEach((function(t){if(!n.isValidLookup(i)){a=t;var o=f,u=[o],c,d;if(n.i18nFormat&&n.i18nFormat.addLookupKeys)n.i18nFormat.addLookupKeys(u,f,t,e,r);else l&&(c=n.pluralResolver.getSuffix(t,r.count)),l&&h&&u.push(o+c),h&&u.push(o+="".concat(n.options.contextSeparator).concat(r.context)),l&&u.push(o+=c);for(;d=u.pop();)n.isValidLookup(i)||(s=d,i=n.getResource(t,e,d,r))}})))}))}})),{res:i,usedKey:o,exactUsedKey:s,usedLng:a,usedNS:u}}},{key:"isValidLookup",value:function e(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,n,r,i):this.resourceStore.getResource(t,n,r,i)}}],[{key:"hasDefaultValue",value:function e(t){var n="defaultValue";for(var r in t)if(Object.prototype.hasOwnProperty.call(t,r)&&n===r.substring(0,n.length)&&void 0!==t[r])return!0;return!1}}]),t}(p);function T(e){return e.charAt(0).toUpperCase()+e.slice(1)}var B=function(){function e(t){o(this,e),this.options=t,this.whitelist=this.options.supportedLngs||!1,this.supportedLngs=this.options.supportedLngs||!1,this.logger=d.create("languageUtils")}return s(e,[{key:"getScriptPartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return null;var n=t.split("-");return 2===n.length?null:(n.pop(),"x"===n[n.length-1].toLowerCase()?null:this.formatLanguageCode(n.join("-")))}},{key:"getLanguagePartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return t;var n=t.split("-");return this.formatLanguageCode(n[0])}},{key:"formatLanguageCode",value:function e(t){if("string"==typeof t&&t.indexOf("-")>-1){var n=["hans","hant","latn","cyrl","cans","mong","arab"],r=t.split("-");return this.options.lowerCaseLng?r=r.map((function(e){return e.toLowerCase()})):2===r.length?(r[0]=r[0].toLowerCase(),r[1]=r[1].toUpperCase(),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase()))):3===r.length&&(r[0]=r[0].toLowerCase(),2===r[1].length&&(r[1]=r[1].toUpperCase()),"sgn"!==r[0]&&2===r[2].length&&(r[2]=r[2].toUpperCase()),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase())),n.indexOf(r[2].toLowerCase())>-1&&(r[2]=T(r[2].toLowerCase()))),r.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isWhitelisted",value:function e(t){return this.logger.deprecate("languageUtils.isWhitelisted",'function "isWhitelisted" will be renamed to "isSupportedCode" in the next major - please make sure to rename it\'s usage asap.'),this.isSupportedCode(t)}},{key:"isSupportedCode",value:function e(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function e(t){var n=this,r;return t?(t.forEach((function(e){if(!r){var t=n.formatLanguageCode(e);n.options.supportedLngs&&!n.isSupportedCode(t)||(r=t)}})),!r&&this.options.supportedLngs&&t.forEach((function(e){if(!r){var t=n.getLanguagePartFromCode(e);if(n.isSupportedCode(t))return r=t;r=n.options.supportedLngs.find((function(e){if(0===e.indexOf(t))return e}))}})),r||(r=this.getFallbackCodes(this.options.fallbackLng)[0]),r):null}},{key:"getFallbackCodes",value:function e(t,n){if(!t)return[];if("function"==typeof t&&(t=t(n)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!n)return t.default||[];var r=t[n];return r||(r=t[this.getScriptPartFromCode(n)]),r||(r=t[this.formatLanguageCode(n)]),r||(r=t[this.getLanguagePartFromCode(n)]),r||(r=t.default),r||[]}},{key:"toResolveHierarchy",value:function e(t,n){var r=this,i=this.getFallbackCodes(n||this.options.fallbackLng||[],t),o=[],s=function e(t){t&&(r.isSupportedCode(t)?o.push(t):r.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&s(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&s(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&s(this.getLanguagePartFromCode(t))):"string"==typeof t&&s(this.formatLanguageCode(t)),i.forEach((function(e){o.indexOf(e)<0&&s(r.formatLanguageCode(e))})),o}}]),e}(),I=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","kk","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],R={1:function e(t){return Number(t>1)},2:function e(t){return Number(1!=t)},3:function e(t){return 0},4:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function e(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function e(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function e(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function e(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function e(t){return Number(t>=2)},10:function e(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function e(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function e(t){return Number(t%10!=1||t%100==11)},13:function e(t){return Number(0!==t)},14:function e(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function e(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function e(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function e(t){return Number(0==t?0:1==t?1:2)},19:function e(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function e(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function e(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function e(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}};function F(){var e={};return I.forEach((function(t){t.lngs.forEach((function(n){e[n]={numbers:t.nr,plurals:R[t.fc]}}))})),e}var P=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.languageUtils=t,this.options=n,this.logger=d.create("pluralResolver"),this.rules=F()}return s(e,[{key:"addRule",value:function e(t,n){this.rules[t]=n}},{key:"getRule",value:function e(t){return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function e(t){var n=this.getRule(t);return n&&n.numbers.length>1}},{key:"getPluralFormsOfKey",value:function e(t,n){return this.getSuffixes(t).map((function(e){return n+e}))}},{key:"getSuffixes",value:function e(t){var n=this,r=this.getRule(t);return r?r.numbers.map((function(e){return n.getSuffix(t,e)})):[]}},{key:"getSuffix",value:function e(t,n){var r=this,i=this.getRule(t);if(i){var o=i.noAbs?i.plurals(n):i.plurals(Math.abs(n)),s=i.numbers[o];this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]&&(2===s?s="plural":1===s&&(s=""));var a=function e(){return r.options.prepend&&s.toString()?r.options.prepend+s.toString():s.toString()};return"v1"===this.options.compatibilityJSON?1===s?"":"number"==typeof s?"_plural_".concat(s.toString()):a():"v2"===this.options.compatibilityJSON?a():this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]?a():this.options.prepend&&o.toString()?this.options.prepend+o.toString():o.toString()}return this.logger.warn("no plural rule found for: ".concat(t)),""}}]),e}(),N=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};o(this,e),this.logger=d.create("interpolator"),this.options=t,this.format=t.interpolation&&t.interpolation.format||function(e){return e},this.init(t)}return s(e,[{key:"init",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var n=t.interpolation;this.escape=void 0!==n.escape?n.escape:D,this.escapeValue=void 0===n.escapeValue||n.escapeValue,this.useRawValueToEscape=void 0!==n.useRawValueToEscape&&n.useRawValueToEscape,this.prefix=n.prefix?x(n.prefix):n.prefixEscaped||"{{",this.suffix=n.suffix?x(n.suffix):n.suffixEscaped||"}}",this.formatSeparator=n.formatSeparator?n.formatSeparator:n.formatSeparator||",",this.unescapePrefix=n.unescapeSuffix?"":n.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":n.unescapeSuffix||"",this.nestingPrefix=n.nestingPrefix?x(n.nestingPrefix):n.nestingPrefixEscaped||x("$t("),this.nestingSuffix=n.nestingSuffix?x(n.nestingSuffix):n.nestingSuffixEscaped||x(")"),this.nestingOptionsSeparator=n.nestingOptionsSeparator?n.nestingOptionsSeparator:n.nestingOptionsSeparator||",",this.maxReplaces=n.maxReplaces?n.maxReplaces:1e3,this.alwaysFormat=void 0!==n.alwaysFormat&&n.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function e(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function e(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var n="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(n,"g");var r="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(r,"g")}},{key:"interpolate",value:function e(t,n,r,i){var o=this,s,a,u,f=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function c(e){return e.replace(/\$/g,"$$$$")}var l=function e(t){if(t.indexOf(o.formatSeparator)<0){var s=k(n,f,t);return o.alwaysFormat?o.format(s,void 0,r):s}var a=t.split(o.formatSeparator),u=a.shift().trim(),c=a.join(o.formatSeparator).trim();return o.format(k(n,f,u),c,r,i)};this.resetRegExp();var h=i&&i.missingInterpolationHandler||this.options.missingInterpolationHandler,d=i&&i.interpolation&&i.interpolation.skipOnVariables||this.options.interpolation.skipOnVariables,p;return[{regex:this.regexpUnescape,safeValue:function e(t){return c(t)}},{regex:this.regexp,safeValue:function e(t){return o.escapeValue?c(o.escape(t)):c(t)}}].forEach((function(e){for(u=0;s=e.regex.exec(t);){if(void 0===(a=l(s[1].trim())))if("function"==typeof h){var n=h(t,s,i);a="string"==typeof n?n:""}else{if(d){a=s[0];continue}o.logger.warn("missed to pass in variable ".concat(s[1]," for interpolating ").concat(t)),a=""}else"string"==typeof a||o.useRawValueToEscape||(a=b(a));if(t=t.replace(s[0],e.safeValue(a)),e.regex.lastIndex=0,++u>=o.maxReplaces)break}})),t}},{key:"nest",value:function e(t,n){var r=this,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},s,a,u=i({},o);function f(e,t){var n=this.nestingOptionsSeparator;if(e.indexOf(n)<0)return e;var r=e.split(new RegExp("".concat(n,"[ ]*{"))),o="{".concat(r[1]);e=r[0],o=(o=this.interpolate(o,u)).replace(/'/g,'"');try{u=JSON.parse(o),t&&(u=i({},t,u))}catch(s){return this.logger.warn("failed parsing options string in nesting for key ".concat(e),s),"".concat(e).concat(n).concat(o)}return delete u.defaultValue,e}for(u.applyPostProcessor=!1,delete u.defaultValue;s=this.nestingRegexp.exec(t);){var c=[],l=!1;if(s[0].includes(this.formatSeparator)&&!/{.*}/.test(s[1])){var h=s[1].split(this.formatSeparator).map((function(e){return e.trim()}));s[1]=h.shift(),c=h,l=!0}if((a=n(f.call(this,s[1].trim(),u),u))&&s[0]===t&&"string"!=typeof a)return a;"string"!=typeof a&&(a=b(a)),a||(this.logger.warn("missed to resolve ".concat(s[1]," for nesting ").concat(t)),a=""),l&&(a=c.reduce((function(e,t){return r.format(e,t,o.lng,o)}),a.trim())),t=t.replace(s[0],a),this.regexp.lastIndex=0}return t}}]),e}();function L(e,t){for(var n=e.indexOf(t);-1!==n;)e.splice(n,1),n=e.indexOf(t)}var z=function(e){function t(e,n,r){var i,s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return o(this,t),i=a(this,u(t).call(this)),E&&p.call(f(i)),i.backend=e,i.store=n,i.services=r,i.languageUtils=r.languageUtils,i.options=s,i.logger=d.create("backendConnector"),i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(r,s.backend,s),i}return c(t,e),s(t,[{key:"queueLoad",value:function e(t,n,r,i){var o=this,s=[],a=[],u=[],f=[];return t.forEach((function(e){var t=!0;n.forEach((function(n){var i="".concat(e,"|").concat(n);!r.reload&&o.store.hasResourceBundle(e,n)?o.state[i]=2:o.state[i]<0||(1===o.state[i]?a.indexOf(i)<0&&a.push(i):(o.state[i]=1,t=!1,a.indexOf(i)<0&&a.push(i),s.indexOf(i)<0&&s.push(i),f.indexOf(n)<0&&f.push(n)))})),t||u.push(e)})),(s.length||a.length)&&this.queue.push({pending:a,loaded:{},errors:[],callback:i}),{toLoad:s,pending:a,toLoadLanguages:u,toLoadNamespaces:f}}},{key:"loaded",value:function e(t,n,r){var i=t.split("|"),o=i[0],s=i[1];n&&this.emit("failedLoading",o,s,n),r&&this.store.addResourceBundle(o,s,r),this.state[t]=n?-1:2;var e={};this.queue.forEach((function(r){_(r.loaded,[o],s),L(r.pending,t),n&&r.errors.push(n),0!==r.pending.length||r.done||(Object.keys(r.loaded).forEach((function(t){e[t]||(e[t]=[]),r.loaded[t].length&&r.loaded[t].forEach((function(n){e[t].indexOf(n)<0&&e[t].push(n)}))})),r.done=!0,r.errors.length?r.callback(r.errors):r.callback())})),this.emit("loaded",e),this.queue=this.queue.filter((function(e){return!e.done}))}},{key:"read",value:function e(t,n,r){var i=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:350,a=arguments.length>5?arguments[5]:void 0;return t.length?this.backend[r](t,n,(function(e,u){e&&u&&o<5?setTimeout((function(){i.read.call(i,t,n,r,o+1,2*s,a)}),s):a(e,u)})):a(null,{})}},{key:"prepareLoading",value:function e(t,n){var r=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof n&&(n=[n]);var s=this.queueLoad(t,n,i,o);if(!s.toLoad.length)return s.pending.length||o(),null;s.toLoad.forEach((function(e){r.loadOne(e)}))}},{key:"load",value:function e(t,n,r){this.prepareLoading(t,n,{},r)}},{key:"reload",value:function e(t,n,r){this.prepareLoading(t,n,{reload:!0},r)}},{key:"loadOne",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=t.split("|"),o=i[0],s=i[1];this.read(o,s,"read",void 0,void 0,(function(e,i){e&&n.logger.warn("".concat(r,"loading namespace ").concat(s," for language ").concat(o," failed"),e),!e&&i&&n.logger.log("".concat(r,"loaded namespace ").concat(s," for language ").concat(o),i),n.loaded(t,e,i)}))}},{key:"saveMissing",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(n)?this.logger.warn('did not save key "'.concat(r,'" as the namespace "').concat(n,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=r&&""!==r&&(this.backend&&this.backend.create&&this.backend.create(t,n,r,o,null,i({},a,{isUpdate:s})),t&&t[0]&&this.store.addResource(t[0],n,r,o))}}]),t}(p);function U(){return{debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,whitelist:!1,nonExplicitWhitelist:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function e(t){var n={};if("object"===r(t[1])&&(n=t[1]),"string"==typeof t[1]&&(n.defaultValue=t[1]),"string"==typeof t[2]&&(n.tDescription=t[2]),"object"===r(t[2])||"object"===r(t[3])){var i=t[3]||t[2];Object.keys(i).forEach((function(e){n[e]=i[e]}))}return n},interpolation:{escapeValue:!0,format:function e(t,n,r,i){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!1}}}function q(e){return"string"==typeof e.ns&&(e.ns=[e.ns]),"string"==typeof e.fallbackLng&&(e.fallbackLng=[e.fallbackLng]),"string"==typeof e.fallbackNS&&(e.fallbackNS=[e.fallbackNS]),e.whitelist&&(e.whitelist&&e.whitelist.indexOf("cimode")<0&&(e.whitelist=e.whitelist.concat(["cimode"])),e.supportedLngs=e.whitelist),e.nonExplicitWhitelist&&(e.nonExplicitSupportedLngs=e.nonExplicitWhitelist),e.supportedLngs&&e.supportedLngs.indexOf("cimode")<0&&(e.supportedLngs=e.supportedLngs.concat(["cimode"])),e}function $(){}var W,H=new(function(e){function t(){var e,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;if(o(this,t),e=a(this,u(t).call(this)),E&&p.call(f(e)),e.options=q(n),e.services={},e.logger=d,e.modules={external:[]},r&&!e.isInitialized&&!n.isClone){if(!e.options.initImmediate)return e.init(n,r),a(e,f(e));setTimeout((function(){e.init(n,r)}),0)}return e}return c(t,e),s(t,[{key:"init",value:function e(){var t=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;function o(e){return e?"function"==typeof e?new e:e:null}if("function"==typeof n&&(r=n,n={}),n.whitelist&&!n.supportedLngs&&this.logger.deprecate("whitelist",'option "whitelist" will be renamed to "supportedLngs" in the next major - please make sure to rename this option asap.'),n.nonExplicitWhitelist&&!n.nonExplicitSupportedLngs&&this.logger.deprecate("whitelist",'options "nonExplicitWhitelist" will be renamed to "nonExplicitSupportedLngs" in the next major - please make sure to rename this option asap.'),this.options=i({},U(),this.options,q(n)),this.format=this.options.interpolation.format,r||(r=$),!this.options.isClone){this.modules.logger?d.init(o(this.modules.logger),this.options):d.init(null,this.options);var s=new B(this.options);this.store=new A(this.options.resources,this.options);var a=this.services;a.logger=d,a.resourceStore=this.store,a.languageUtils=s,a.pluralResolver=new P(s,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),a.interpolator=new N(this.options),a.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},a.backendConnector=new z(o(this.modules.backend),a.resourceStore,a,this.options),a.backendConnector.on("*",(function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),i=1;i1?n-1:0),i=1;i0&&"dev"!==u[0]&&(this.options.lng=u[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined");var f=["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"];f.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments)}}));var c=["addResource","addResources","addResourceBundle","removeResourceBundle"];c.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments),t}}));var l=g(),h=function e(){var n=function e(n,i){t.isInitialized&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),l.resolve(i),r(n,i)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return n(null,t.t.bind(t));t.changeLanguage(t.options.lng,n)};return this.options.resources||!this.options.initImmediate?h():setTimeout(h,0),l}},{key:"loadResources",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,i=r,o="string"==typeof t?t:this.language;if("function"==typeof t&&(i=t),!this.options.resources||this.options.partialBundledLanguages){if(o&&"cimode"===o.toLowerCase())return i();var s=[],a=function e(t){var r;t&&n.services.languageUtils.toResolveHierarchy(t).forEach((function(e){s.indexOf(e)<0&&s.push(e)}))};if(o)a(o);else{var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.forEach((function(e){return a(e)}))}this.options.preload&&this.options.preload.forEach((function(e){return a(e)})),this.services.backendConnector.load(s,this.options.ns,i)}else i(null)}},{key:"reloadResources",value:function e(t,n,r){var i=g();return t||(t=this.languages),n||(n=this.options.ns),r||(r=$),this.services.backendConnector.reload(t,n,(function(e){i.resolve(),r(e)})),i}},{key:"use",value:function e(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&C.addPostProcessor(t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"changeLanguage",value:function e(t,n){var r=this;this.isLanguageChangingTo=t;var i=g();this.emit("languageChanging",t);var o=function e(t,o){o?(r.language=o,r.languages=r.services.languageUtils.toResolveHierarchy(o),r.translator.changeLanguage(o),r.isLanguageChangingTo=void 0,r.emit("languageChanged",o),r.logger.log("languageChanged",o)):r.isLanguageChangingTo=void 0,i.resolve((function(){return r.t.apply(r,arguments)})),n&&n(t,(function(){return r.t.apply(r,arguments)}))},s=function e(t){var n="string"==typeof t?t:r.services.languageUtils.getBestMatchFromCodes(t);n&&(r.language||(r.language=n,r.languages=r.services.languageUtils.toResolveHierarchy(n)),r.translator.language||r.translator.changeLanguage(n),r.services.languageDetector&&r.services.languageDetector.cacheUserLanguage(n)),r.loadResources(n,(function(e){o(e,n)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(s):s(t):s(this.services.languageDetector.detect()),i}},{key:"getFixedT",value:function e(t,n){var o=this,s=function e(t,n){var s;if("object"!==r(n)){for(var a=arguments.length,u=new Array(a>2?a-2:0),f=2;f1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var i=this.languages[0],o=!!this.options&&this.options.fallbackLng,s=this.languages[this.languages.length-1];if("cimode"===i.toLowerCase())return!0;var a=function e(t,r){var i=n.services.backendConnector.state["".concat(t,"|").concat(r)];return-1===i||2===i};if(r.precheck){var u=r.precheck(this,a);if(void 0!==u)return u}return!!this.hasResourceBundle(i,t)||(!this.services.backendConnector.backend||!(!a(i,t)||o&&!a(s,t)))}},{key:"loadNamespaces",value:function e(t,n){var r=this,i=g();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(e){r.options.ns.indexOf(e)<0&&r.options.ns.push(e)})),this.loadResources((function(e){i.resolve(),n&&n(e)})),i):(n&&n(),Promise.resolve())}},{key:"loadLanguages",value:function e(t,n){var r=g();"string"==typeof t&&(t=[t]);var i=this.options.preload||[],o=t.filter((function(e){return i.indexOf(e)<0}));return o.length?(this.options.preload=i.concat(o),this.loadResources((function(e){r.resolve(),n&&n(e)})),r):(n&&n(),Promise.resolve())}},{key:"dir",value:function e(t){return t||(t=this.languages&&this.languages.length>0?this.languages[0]:this.language),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>=0?"rtl":"ltr":"rtl";var n}},{key:"createInstance",value:function e(){var n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;return new t(n,r)}},{key:"cloneInstance",value:function e(){var n=this,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,s=i({},this.options,r,{isClone:!0}),a=new t(s),u=["store","services","language"];return u.forEach((function(e){a[e]=n[e]})),a.services=i({},this.services),a.services.utils={hasLoadedNamespace:a.hasLoadedNamespace.bind(a)},a.translator=new O(a.services,a.options),a.translator.on("*",(function(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;rr,root:()=>i,ArrayProto:()=>o,ObjProto:()=>s,SymbolProto:()=>a,push:()=>u,slice:()=>f,toString:()=>c,hasOwnProperty:()=>l,supportsArrayBuffer:()=>h,supportsDataView:()=>d,nativeIsArray:()=>p,nativeKeys:()=>g,nativeCreate:()=>b,nativeIsView:()=>m,_isNaN:()=>v,_isFinite:()=>y,hasEnumBug:()=>_,nonEnumerableProps:()=>w,MAX_ARRAY_INDEX:()=>k});var r="1.13.4",i="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},o=Array.prototype,s=Object.prototype,a="undefined"!=typeof Symbol?Symbol.prototype:null,u=o.push,f=o.slice,c=s.toString,l=s.hasOwnProperty,h="undefined"!=typeof ArrayBuffer,d="undefined"!=typeof DataView,p=Array.isArray,g=Object.keys,b=Object.create,m=h&&ArrayBuffer.isView,v=isNaN,y=isFinite,_=!{toString:null}.propertyIsEnumerable("toString"),w=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],k=Math.pow(2,53)-1},"restArguments.js":function e(t,n,e){function r(e,t){return t=null==t?e.length-1:+t,function(){for(var n=Math.max(arguments.length-t,0),r=Array(n),i=0;ir})},"isObject.js":function e(t,n,e){function r(e){var t=typeof e;return"function"===t||"object"===t&&!!e}e.export({default:()=>r})},"isNull.js":function e(t,n,e){function r(e){return null===e}e.export({default:()=>r})},"isUndefined.js":function e(t,n,e){function r(e){return void 0===e}e.export({default:()=>r})},"isBoolean.js":function e(t,n,e){let r;function i(e){return!0===e||!1===e||"[object Boolean]"===r.call(e)}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isElement.js":function e(t,n,e){function r(e){return!(!e||1!==e.nodeType)}e.export({default:()=>r})},"isString.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("String"))},"_tagTester.js":function e(t,n,e){let r;function i(e){var t="[object "+e+"]";return function(e){return r.call(e)===t}}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isNumber.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Number"))},"isDate.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Date"))},"isRegExp.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("RegExp"))},"isError.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Error"))},"isSymbol.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Symbol"))},"isArrayBuffer.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("ArrayBuffer"))},"isDataView.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isArrayBuffer.js",{default(e){o=e}},2),e.link("./_stringTagBug.js",{hasStringTagBug(e){s=e}},3);var a=r("DataView");function u(e){return null!=e&&i(e.getInt8)&&o(e.buffer)}e.exportDefault(s?u:a)},"isFunction.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_setup.js",{root(e){i=e}},1);var o=r("Function"),s=i.document&&i.document.childNodes;"function"!=typeof/./&&"object"!=typeof Int8Array&&"function"!=typeof s&&(o=function(e){return"function"==typeof e||!1}),e.exportDefault(o)},"_stringTagBug.js":function e(t,n,e){let r,i;e.export({hasStringTagBug:()=>o,isIE11:()=>s}),e.link("./_setup.js",{supportsDataView(e){r=e}},0),e.link("./_hasObjectTag.js",{default(e){i=e}},1);var o=r&&i(new DataView(new ArrayBuffer(8))),s="undefined"!=typeof Map&&i(new Map)},"_hasObjectTag.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Object"))},"isArray.js":function e(t,n,e){let r,i;e.link("./_setup.js",{nativeIsArray(e){r=e}},0),e.link("./_tagTester.js",{default(e){i=e}},1),e.exportDefault(r||i("Array"))},"isArguments.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1);var o=r("Arguments");!function(){o(arguments)||(o=function(e){return i(e,"callee")})}(),e.exportDefault(o)},"_has.js":function e(t,n,e){let r;function i(e,t){return null!=e&&r.call(e,t)}e.export({default:()=>i}),e.link("./_setup.js",{hasOwnProperty(e){r=e}},0)},"isFinite.js":function e(t,n,e){let r,i;function o(e){return!i(e)&&r(e)&&!isNaN(parseFloat(e))}e.export({default:()=>o}),e.link("./_setup.js",{_isFinite(e){r=e}},0),e.link("./isSymbol.js",{default(e){i=e}},1)},"isNaN.js":function e(t,n,e){let r,i;function o(e){return i(e)&&r(e)}e.export({default:()=>o}),e.link("./_setup.js",{_isNaN(e){r=e}},0),e.link("./isNumber.js",{default(e){i=e}},1)},"isTypedArray.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./_setup.js",{supportsArrayBuffer(e){r=e},nativeIsView(e){i=e},toString(e){o=e}},0),e.link("./isDataView.js",{default(e){s=e}},1),e.link("./constant.js",{default(e){a=e}},2),e.link("./_isBufferLike.js",{default(e){u=e}},3);var f=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;function c(e){return i?i(e)&&!s(e):u(e)&&f.test(o.call(e))}e.exportDefault(r?c:a(!1))},"constant.js":function e(t,n,e){function r(e){return function(){return e}}e.export({default:()=>r})},"_isBufferLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getByteLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createSizePropertyCheck.js":function e(t,n,e){let r;function i(e){return function(t){var n=e(t);return"number"==typeof n&&n>=0&&n<=r}}e.export({default:()=>i}),e.link("./_setup.js",{MAX_ARRAY_INDEX(e){r=e}},0)},"_getByteLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("byteLength"))},"_shallowProperty.js":function e(t,n,e){function r(e){return function(t){return null==t?void 0:t[e]}}e.export({default:()=>r})},"isEmpty.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(null==e)return!0;var t=r(e);return"number"==typeof t&&(i(e)||o(e)||s(e))?0===t:0===r(a(e))}e.export({default:()=>u}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3),e.link("./keys.js",{default(e){a=e}},4)},"_getLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("length"))},"keys.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(!r(e))return[];if(i)return i(e);var t=[];for(var n in e)s(e,n)&&t.push(n);return o&&a(e,t),t}e.export({default:()=>u}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeKeys(e){i=e},hasEnumBug(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2),e.link("./_collectNonEnumProps.js",{default(e){a=e}},3)},"_collectNonEnumProps.js":function e(t,n,e){let r,i,o,s;function a(e){for(var t={},n=e.length,r=0;ru}),e.link("./_setup.js",{nonEnumerableProps(e){r=e},ObjProto(e){i=e}},0),e.link("./isFunction.js",{default(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2)},"isMatch.js":function e(t,n,e){let r;function i(e,t){var n=r(t),i=n.length;if(null==e)return!i;for(var o=Object(e),s=0;si}),e.link("./keys.js",{default(e){r=e}},0)},"isEqual.js":function e(t,n,e){let r,i,o,s,a,u,f,c,l,h,d;e.export({default:()=>m}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_setup.js",{toString(e){i=e},SymbolProto(e){o=e}},1),e.link("./_getByteLength.js",{default(e){s=e}},2),e.link("./isTypedArray.js",{default(e){a=e}},3),e.link("./isFunction.js",{default(e){u=e}},4),e.link("./_stringTagBug.js",{hasStringTagBug(e){f=e}},5),e.link("./isDataView.js",{default(e){c=e}},6),e.link("./keys.js",{default(e){l=e}},7),e.link("./_has.js",{default(e){h=e}},8),e.link("./_toBufferView.js",{default(e){d=e}},9);var p="[object DataView]";function g(e,t,n,r){if(e===t)return 0!==e||1/e==1/t;if(null==e||null==t)return!1;if(e!=e)return t!=t;var i=typeof e;return("function"===i||"object"===i||"object"==typeof t)&&b(e,t,n,r)}function b(e,t,n,m){e instanceof r&&(e=e._wrapped),t instanceof r&&(t=t._wrapped);var v=i.call(e);if(v!==i.call(t))return!1;if(f&&"[object Object]"==v&&c(e)){if(!c(t))return!1;v=p}switch(v){case"[object RegExp]":case"[object String]":return""+e==""+t;case"[object Number]":return+e!=+e?+t!=+t:0==+e?1/+e==1/t:+e==+t;case"[object Date]":case"[object Boolean]":return+e==+t;case"[object Symbol]":return o.valueOf.call(e)===o.valueOf.call(t);case"[object ArrayBuffer]":case p:return b(d(e),d(t),n,m)}var y="[object Array]"===v;if(!y&&a(e)){var _;if(s(e)!==s(t))return!1;if(e.buffer===t.buffer&&e.byteOffset===t.byteOffset)return!0;y=!0}if(!y){if("object"!=typeof e||"object"!=typeof t)return!1;var w=e.constructor,k=t.constructor;if(w!==k&&!(u(w)&&w instanceof w&&u(k)&&k instanceof k)&&"constructor"in e&&"constructor"in t)return!1}m=m||[];for(var j=(n=n||[]).length;j--;)if(n[j]===e)return m[j]===t;if(n.push(e),m.push(t),y){if((j=e.length)!==t.length)return!1;for(;j--;)if(!g(e[j],t[j],n,m))return!1}else{var x=l(e),S;if(j=x.length,l(t).length!==j)return!1;for(;j--;)if(S=x[j],!h(t,S)||!g(e[S],t[S],n,m))return!1}return n.pop(),m.pop(),!0}function m(e,t){return g(e,t)}},"underscore.js":function e(t,n,e){let r;function i(e){return e instanceof i?e:this instanceof i?void(this._wrapped=e):new i(e)}e.export({default:()=>i}),e.link("./_setup.js",{VERSION(e){r=e}},0),i.VERSION=r,i.prototype.value=function(){return this._wrapped},i.prototype.valueOf=i.prototype.toJSON=i.prototype.value,i.prototype.toString=function(){return String(this._wrapped)}},"_toBufferView.js":function e(t,n,e){let r;function i(e){return new Uint8Array(e.buffer||e,e.byteOffset||0,r(e))}e.export({default:()=>i}),e.link("./_getByteLength.js",{default(e){r=e}},0)},"isMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},mapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Map"))},"_methodFingerprint.js":function e(t,n,e){let r,i,o;function s(e){var t=r(e);return function(n){if(null==n)return!1;var s=o(n);if(r(s))return!1;for(var u=0;us,mapMethods:()=>l,weakMapMethods:()=>h,setMethods:()=>d}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./allKeys.js",{default(e){o=e}},2);var a="forEach",u="has",f=["clear","delete"],c=["get","has","set"],l=f.concat(a,c),h=f.concat(c),d=["add"].concat(f,a,"has")},"allKeys.js":function e(t,n,e){let r,i,o;function s(e){if(!r(e))return[];var t=[];for(var n in e)t.push(n);return i&&o(e,t),t}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{hasEnumBug(e){i=e}},1),e.link("./_collectNonEnumProps.js",{default(e){o=e}},2)},"isWeakMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},weakMapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("WeakMap"))},"isSet.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},setMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Set"))},"isWeakSet.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("WeakSet"))},"values.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"pairs.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"invert.js":function e(t,n,e){let r;function i(e){for(var t={},n=r(e),i=0,o=n.length;ii}),e.link("./keys.js",{default(e){r=e}},0)},"functions.js":function e(t,n,e){let r;function i(e){var t=[];for(var n in e)r(e[n])&&t.push(n);return t.sort()}e.export({default:()=>i}),e.link("./isFunction.js",{default(e){r=e}},0)},"extend.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createAssigner.js":function e(t,n,e){function r(e,t){return function(n){var r=arguments.length;if(t&&(n=Object(n)),r<2||null==n)return n;for(var i=1;ir})},"extendOwn.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"defaults.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i,!0))},"create.js":function e(t,n,e){let r,i;function o(e,t){var n=r(e);return t&&i(n,t),n}e.export({default:()=>o}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./extendOwn.js",{default(e){i=e}},1)},"_baseCreate.js":function e(t,n,e){let r,i;function o(){return function(){}}function s(e){if(!r(e))return{};if(i)return i(e);var t=function(){};t.prototype=e;var n=new t;return t.prototype=null,n}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeCreate(e){i=e}},1)},"clone.js":function e(t,n,e){let r,i,o;function s(e){return r(e)?i(e)?e.slice():o({},e):e}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./extend.js",{default(e){o=e}},2)},"tap.js":function e(t,n,e){function r(e,t){return t(e),e}e.export({default:()=>r})},"get.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=i(e,r(t));return o(s)?n:s}e.export({default:()=>s}),e.link("./_toPath.js",{default(e){r=e}},0),e.link("./_deepGet.js",{default(e){i=e}},1),e.link("./isUndefined.js",{default(e){o=e}},2)},"_toPath.js":function e(t,n,e){let r;function i(e){return r.toPath(e)}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./toPath.js")},"toPath.js":function e(t,n,e){let r,i;function o(e){return i(e)?e:[e]}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),r.toPath=o},"_deepGet.js":function e(t,n,e){function r(e,t){for(var n=t.length,r=0;rr})},"has.js":function e(t,n,e){let r,i;function o(e,t){for(var n=(t=i(t)).length,o=0;oo}),e.link("./_has.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"mapObject.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s=o.length,a={},u=0;uo}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"_cb.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r.iteratee!==o?r.iteratee(e,t):i(e,t,n)}e.export({default:()=>s}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),e.link("./iteratee.js",{default(e){o=e}},2)},"_baseIteratee.js":function e(t,n,e){let r,i,o,s,a,u,f;function c(e,t,n){return null==e?r:i(e)?f(e,t,n):o(e)&&!s(e)?a(e):u(e)}e.export({default:()=>c}),e.link("./identity.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isObject.js",{default(e){o=e}},2),e.link("./isArray.js",{default(e){s=e}},3),e.link("./matcher.js",{default(e){a=e}},4),e.link("./property.js",{default(e){u=e}},5),e.link("./_optimizeCb.js",{default(e){f=e}},6)},"identity.js":function e(t,n,e){function r(e){return e}e.export({default:()=>r})},"matcher.js":function e(t,n,e){let r,i;function o(e){return e=r({},e),function(t){return i(t,e)}}e.export({default:()=>o}),e.link("./extendOwn.js",{default(e){r=e}},0),e.link("./isMatch.js",{default(e){i=e}},1)},"property.js":function e(t,n,e){let r,i;function o(e){return e=i(e),function(t){return r(t,e)}}e.export({default:()=>o}),e.link("./_deepGet.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"_optimizeCb.js":function e(t,n,e){function r(e,t,n){if(void 0===t)return e;switch(null==n?3:n){case 1:return function(n){return e.call(t,n)};case 3:return function(n,r,i){return e.call(t,n,r,i)};case 4:return function(n,r,i,o){return e.call(t,n,r,i,o)}}return function(){return e.apply(t,arguments)}}e.export({default:()=>r})},"iteratee.js":function e(t,n,e){let r,i;function o(e,t){return i(e,t,1/0)}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),r.iteratee=o},"noop.js":function e(t,n,e){function r(){}e.export({default:()=>r})},"propertyOf.js":function e(t,n,e){let r,i;function o(e){return null==e?r:function(t){return i(e,t)}}e.export({default:()=>o}),e.link("./noop.js",{default(e){r=e}},0),e.link("./get.js",{default(e){i=e}},1)},"times.js":function e(t,n,e){let r;function i(e,t,n){var i=Array(Math.max(0,e));t=r(t,n,1);for(var o=0;oi}),e.link("./_optimizeCb.js",{default(e){r=e}},0)},"random.js":function e(t,n,e){function r(e,t){return null==t&&(t=e,e=0),e+Math.floor(Math.random()*(t-e+1))}e.export({default:()=>r})},"now.js":function e(t,n,e){e.exportDefault(Date.now||function(){return(new Date).getTime()})},"escape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createEscaper.js":function e(t,n,e){let r;function i(e){var t=function(t){return e[t]},n="(?:"+r(e).join("|")+")",i=RegExp(n),o=RegExp(n,"g");return function(e){return e=null==e?"":""+e,i.test(e)?e.replace(o,t):e}}e.export({default:()=>i}),e.link("./keys.js",{default(e){r=e}},0)},"_escapeMap.js":function e(t,n,e){e.exportDefault({"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"})},"unescape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_unescapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_unescapeMap.js":function e(t,n,e){let r,i;e.link("./invert.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"templateSettings.js":function e(t,n,e){let r;e.link("./underscore.js",{default(e){r=e}},0),e.exportDefault(r.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g})},"template.js":function e(t,n,e){let r,i;e.export({default:()=>c}),e.link("./defaults.js",{default(e){r=e}},0),e.link("./underscore.js",{default(e){i=e}},1),e.link("./templateSettings.js");var o=/(.)^/,s={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},a=/\\|'|\r|\n|\u2028|\u2029/g;function u(e){return"\\"+s[e]}var f=/^\s*(\w|\$)+\s*$/;function c(e,t,n){!t&&n&&(t=n),t=r({},t,i.templateSettings);var s=RegExp([(t.escape||o).source,(t.interpolate||o).source,(t.evaluate||o).source].join("|")+"|$","g"),c=0,l="__p+='";e.replace(s,(function(t,n,r,i,o){return l+=e.slice(c,o).replace(a,u),c=o+t.length,n?l+="'+\n((__t=("+n+"))==null?'':_.escape(__t))+\n'":r?l+="'+\n((__t=("+r+"))==null?'':__t)+\n'":i&&(l+="';\n"+i+"\n__p+='"),t})),l+="';\n";var h=t.variable,d;if(h){if(!f.test(h))throw new Error("variable is not a bare identifier: "+h)}else l="with(obj||{}){\n"+l+"}\n",h="obj";l="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+l+"return __p;\n";try{d=new Function(h,"_",l)}catch(g){throw g.source=l,g}var p=function(e){return d.call(this,e,i)};return p.source="function("+h+"){\n"+l+"}",p}},"result.js":function e(t,n,e){let r,i;function o(e,t,n){var o=(t=i(t)).length;if(!o)return r(n)?n.call(e):n;for(var s=0;so}),e.link("./isFunction.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"uniqueId.js":function e(t,n,e){e.export({default:()=>i});var r=0;function i(e){var t=++r+"";return e?e+t:t}},"chain.js":function e(t,n,e){let r;function i(e){var t=r(e);return t._chain=!0,t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"partial.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_executeBound.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2);var s=r((function(e,t){var n=s.placeholder,r=function(){for(var o=0,s=t.length,a=Array(s),u=0;uo}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./isObject.js",{default(e){i=e}},1)},"bind.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_executeBound.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t,n){if(!i(e))throw new TypeError("Bind must be called on a function");var s=r((function(r){return o(e,s,t,this,n.concat(r))}));return s})))},"bindAll.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./bind.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t){var n=(t=i(t,!1,!1)).length;if(n<1)throw new Error("bindAll must be passed function names");for(;n--;){var r=t[n];e[r]=o(e[r],e)}return e})))},"_flatten.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,u){if(u=u||[],t||0===t){if(t<=0)return u.concat(e)}else t=1/0;for(var f=u.length,c=0,l=r(e);c1)a(h,t-1,n,u),f=u.length;else for(var d=0,p=h.length;da}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./isArray.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3)},"_isArrayLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"memoize.js":function e(t,n,e){let r;function i(e,t){var n=function(i){var o=n.cache,s=""+(t?t.apply(this,arguments):i);return r(o,s)||(o[s]=e.apply(this,arguments)),o[s]};return n.cache={},n}e.export({default:()=>i}),e.link("./_has.js",{default(e){r=e}},0)},"delay.js":function e(t,n,e){let r;e.link("./restArguments.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){return setTimeout((function(){return e.apply(null,n)}),t)})))},"defer.js":function e(t,n,e){let r,i,o;e.link("./partial.js",{default(e){r=e}},0),e.link("./delay.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2),e.exportDefault(r(i,o,1))},"throttle.js":function e(t,n,e){let r;function i(e,t,n){var i,o,s,a,u=0;n||(n={});var f=function(){u=!1===n.leading?0:r(),i=null,a=e.apply(o,s),i||(o=s=null)},c=function(){var c=r();u||!1!==n.leading||(u=c);var l=t-(c-u);return o=this,s=arguments,l<=0||l>t?(i&&(clearTimeout(i),i=null),u=c,a=e.apply(o,s),i||(o=s=null)):i||!1===n.trailing||(i=setTimeout(f,l)),a};return c.cancel=function(){clearTimeout(i),u=0,i=o=s=null},c}e.export({default:()=>i}),e.link("./now.js",{default(e){r=e}},0)},"debounce.js":function e(t,n,e){let r,i;function o(e,t,n){var o,s,a,u,f,c=function(){var r=i()-s;t>r?o=setTimeout(c,t-r):(o=null,n||(u=e.apply(f,a)),o||(a=f=null))},l=r((function(r){return f=this,a=r,s=i(),o||(o=setTimeout(c,t),n&&(u=e.apply(f,a))),u}));return l.cancel=function(){clearTimeout(o),o=a=f=null},l}e.export({default:()=>o}),e.link("./restArguments.js",{default(e){r=e}},0),e.link("./now.js",{default(e){i=e}},1)},"wrap.js":function e(t,n,e){let r;function i(e,t){return r(t,e)}e.export({default:()=>i}),e.link("./partial.js",{default(e){r=e}},0)},"negate.js":function e(t,n,e){function r(e){return function(){return!e.apply(this,arguments)}}e.export({default:()=>r})},"compose.js":function e(t,n,e){function r(){var e=arguments,t=e.length-1;return function(){for(var n=t,r=e[t].apply(this,arguments);n--;)r=e[n].call(this,r);return r}}e.export({default:()=>r})},"after.js":function e(t,n,e){function r(e,t){return function(){if(--e<1)return t.apply(this,arguments)}}e.export({default:()=>r})},"before.js":function e(t,n,e){function r(e,t){var n;return function(){return--e>0&&(n=t.apply(this,arguments)),e<=1&&(t=null),n}}e.export({default:()=>r})},"once.js":function e(t,n,e){let r,i;e.link("./partial.js",{default(e){r=e}},0),e.link("./before.js",{default(e){i=e}},1),e.exportDefault(r(i,2))},"findKey.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s,a=0,u=o.length;ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"findIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createPredicateIndexFinder.js":function e(t,n,e){let r,i;function o(e){return function(t,n,o){n=r(n,o);for(var s=i(t),a=e>0?0:s-1;a>=0&&ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"findLastIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"sortedIndex.js":function e(t,n,e){let r,i;function o(e,t,n,o){for(var s=(n=r(n,o,1))(t),a=0,u=i(e);ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"indexOf.js":function e(t,n,e){let r,i,o;e.link("./sortedIndex.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./_createIndexFinder.js",{default(e){o=e}},2),e.exportDefault(o(1,i,r))},"_createIndexFinder.js":function e(t,n,e){let r,i,o;function s(e,t,n){return function(s,a,u){var f=0,c=r(s);if("number"==typeof u)e>0?f=u>=0?u:Math.max(u+c,f):c=u>=0?Math.min(u+1,c):u+c+1;else if(n&&u&&c)return s[u=n(s,a)]===a?u:-1;if(a!=a)return(u=t(i.call(s,f,c),o))>=0?u+f:-1;for(u=e>0?f:c-1;u>=0&&us}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isNaN.js",{default(e){o=e}},2)},"lastIndexOf.js":function e(t,n,e){let r,i;e.link("./findLastIndex.js",{default(e){r=e}},0),e.link("./_createIndexFinder.js",{default(e){i=e}},1),e.exportDefault(i(-1,r))},"find.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a=(r(e)?i:o)(e,t,n);if(void 0!==a&&-1!==a)return e[a]}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./findKey.js",{default(e){o=e}},2)},"findWhere.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./find.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"each.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a;if(t=r(t,n),i(e))for(s=0,a=e.length;ss}),e.link("./_optimizeCb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"map.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=Array(a),f=0;fs}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"reduce.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createReduce.js":function e(t,n,e){let r,i,o;function s(e){var t=function(t,n,o,s){var a=!r(t)&&i(t),u=(a||t).length,f=e>0?0:u-1;for(s||(o=t[a?a[f]:f],f+=e);f>=0&&f=3;return t(e,o(n,i,4),r,s)}}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2)},"reduceRight.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"filter.js":function e(t,n,e){let r,i;function o(e,t,n){var o=[];return t=r(t,n),i(e,(function(e,n,r){t(e,n,r)&&o.push(e)})),o}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"reject.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r(e,i(o(t)),n)}e.export({default:()=>s}),e.link("./filter.js",{default(e){r=e}},0),e.link("./negate.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2)},"every.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"some.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"contains.js":function e(t,n,e){let r,i,o;function s(e,t,n,s){return r(e)||(e=i(e)),("number"!=typeof n||s)&&(n=0),o(e,t,n)>=0}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./indexOf.js",{default(e){o=e}},2)},"invoke.js":function e(t,n,e){let r,i,o,s,a;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2),e.link("./_deepGet.js",{default(e){s=e}},3),e.link("./_toPath.js",{default(e){a=e}},4),e.exportDefault(r((function(e,t,n){var r,u;return i(t)?u=t:(t=a(t),r=t.slice(0,-1),t=t[t.length-1]),o(e,(function(e){var i=u;if(!i){if(r&&r.length&&(e=s(e,r)),null==e)return;i=e[t]}return null==i?i:i.apply(e,n)}))})))},"pluck.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./map.js",{default(e){r=e}},0),e.link("./property.js",{default(e){i=e}},1)},"where.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./filter.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"max.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=-1/0,u=-1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la&&(a=f);else t=o(t,n),s(e,(function(e,n,r){((c=t(e,n,r))>u||c===-1/0&&a===-1/0)&&(a=e,u=c)}));return a}e.export({default:()=>a}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"min.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=1/0,u=1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"shuffle.js":function e(t,n,e){let r;function i(e){return r(e,1/0)}e.export({default:()=>i}),e.link("./sample.js",{default(e){r=e}},0)},"sample.js":function e(t,n,e){let r,i,o,s,a;function u(e,t,n){if(null==t||n)return r(e)||(e=i(e)),e[s(e.length-1)];var u=a(e),f=o(u);t=Math.max(Math.min(t,f),0);for(var c=f-1,l=0;lu}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./random.js",{default(e){s=e}},3),e.link("./toArray.js",{default(e){a=e}},4)},"toArray.js":function e(t,n,e){let r,i,o,s,a,u,f;e.export({default:()=>l}),e.link("./isArray.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./_isArrayLike.js",{default(e){s=e}},3),e.link("./map.js",{default(e){a=e}},4),e.link("./identity.js",{default(e){u=e}},5),e.link("./values.js",{default(e){f=e}},6);var c=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;function l(e){return e?r(e)?i.call(e):o(e)?e.match(c):s(e)?a(e,u):f(e):[]}},"sortBy.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=0;return t=r(t,n),i(o(e,(function(e,n,r){return{value:e,index:s++,criteria:t(e,n,r)}})).sort((function(e,t){var n=e.criteria,r=t.criteria;if(n!==r){if(n>r||void 0===n)return 1;if(ns}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./pluck.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2)},"groupBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n].push(t):e[n]=[t]})))},"_group.js":function e(t,n,e){let r,i;function o(e,t){return function(n,o,s){var a=t?[[],[]]:{};return o=r(o,s),i(n,(function(t,r){var i=o(t,r,n);e(a,t,i)})),a}}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"indexBy.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n]=t})))},"countBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n]++:e[n]=1})))},"partition.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n?0:1].push(t)}),!0))},"size.js":function e(t,n,e){let r,i;function o(e){return null==e?0:r(e)?e.length:i(e).length}e.export({default:()=>o}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"pick.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2),e.link("./allKeys.js",{default(e){s=e}},3),e.link("./_keyInObj.js",{default(e){a=e}},4),e.link("./_flatten.js",{default(e){u=e}},5),e.exportDefault(r((function(e,t){var n={},r=t[0];if(null==e)return n;i(r)?(t.length>1&&(r=o(r,t[1])),t=s(e)):(r=a,t=u(t,!1,!1),e=Object(e));for(var f=0,c=t.length;fr})},"omit.js":function e(t,n,e){let r,i,o,s,a,u,f;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./negate.js",{default(e){o=e}},2),e.link("./map.js",{default(e){s=e}},3),e.link("./_flatten.js",{default(e){a=e}},4),e.link("./contains.js",{default(e){u=e}},5),e.link("./pick.js",{default(e){f=e}},6),e.exportDefault(r((function(e,t){var n=t[0],r;return i(n)?(n=o(n),t.length>1&&(r=t[1])):(t=s(a(t,!1,!1),String),n=function(e,n){return!u(t,n)}),f(e,n,r)})))},"first.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[0]:r(e,e.length-t)}e.export({default:()=>i}),e.link("./initial.js",{default(e){r=e}},0)},"initial.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,0,Math.max(0,e.length-(null==t||n?1:t)))}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"last.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[e.length-1]:r(e,Math.max(0,e.length-t))}e.export({default:()=>i}),e.link("./rest.js",{default(e){r=e}},0)},"rest.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,null==t||n?1:t)}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"compact.js":function e(t,n,e){let r;function i(e){return r(e,Boolean)}e.export({default:()=>i}),e.link("./filter.js",{default(e){r=e}},0)},"flatten.js":function e(t,n,e){let r;function i(e,t){return r(e,t,!1)}e.export({default:()=>i}),e.link("./_flatten.js",{default(e){r=e}},0)},"without.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./difference.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t){return i(e,t)})))},"difference.js":function e(t,n,e){let r,i,o,s;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./filter.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3),e.exportDefault(r((function(e,t){return t=i(t,!0,!0),o(e,(function(e){return!s(t,e)}))})))},"uniq.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,a){r(t)||(a=n,n=t,t=!1),null!=n&&(n=i(n,a));for(var u=[],f=[],c=0,l=o(e);ca}),e.link("./isBoolean.js",{default(e){r=e}},0),e.link("./_cb.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3)},"union.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./uniq.js",{default(e){i=e}},1),e.link("./_flatten.js",{default(e){o=e}},2),e.exportDefault(r((function(e){return i(o(e,!0,!0))})))},"intersection.js":function e(t,n,e){let r,i;function o(e){for(var t=[],n=arguments.length,o=0,s=r(e);oo}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./contains.js",{default(e){i=e}},1)},"unzip.js":function e(t,n,e){let r,i,o;function s(e){for(var t=e&&r(e,i).length||0,n=Array(t),s=0;ss}),e.link("./max.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.link("./pluck.js",{default(e){o=e}},2)},"zip.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./unzip.js",{default(e){i=e}},1),e.exportDefault(r(i))},"object.js":function e(t,n,e){let r;function i(e,t){for(var n={},i=0,o=r(e);ii}),e.link("./_getLength.js",{default(e){r=e}},0)},"range.js":function e(t,n,e){function r(e,t,n){null==t&&(t=e||0,e=0),n||(n=tr})},"chunk.js":function e(t,n,e){let r;function i(e,t){if(null==t||t<1)return[];for(var n=[],i=0,o=e.length;ii}),e.link("./_setup.js",{slice(e){r=e}},0)},"mixin.js":function e(t,n,e){let r,i,o,s,a;function u(e){return i(o(e),(function(t){var n=r[t]=e[t];r.prototype[t]=function(){var e=[this._wrapped];return s.apply(e,arguments),a(this,n.apply(r,e))}})),r}e.export({default:()=>u}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./functions.js",{default(e){o=e}},2),e.link("./_setup.js",{push(e){s=e}},3),e.link("./_chainResult.js",{default(e){a=e}},4)},"_chainResult.js":function e(t,n,e){let r;function i(e,t){return e._chain?r(t).chain():t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"underscore-array-methods.js":function e(t,n,e){let r,i,o,s;e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./_setup.js",{ArrayProto(e){o=e}},2),e.link("./_chainResult.js",{default(e){s=e}},3),i(["pop","push","reverse","shift","sort","splice","unshift"],(function(e){var t=o[e];r.prototype[e]=function(){var n=this._wrapped;return null!=n&&(t.apply(n,arguments),"shift"!==e&&"splice"!==e||0!==n.length||delete n[0]),s(this,n)}})),i(["concat","join","slice"],(function(e){var t=o[e];r.prototype[e]=function(){var e=this._wrapped;return null!=e&&(e=t.apply(e,arguments)),s(this,e)}})),e.exportDefault(r)}}}}},cachers:{"package.json":function e(t,n,e){e.exports={name:"@steedos/cachers",version:"2.7.4-beta.1",main:"lib/index.js"}},lib:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getCacherNames=n.clearCacher=n.getCacher=void 0;var r={},i=t("./memory"),o=t("./memory-lru"),s=function(e,t){return r[e]||(e.startsWith("lru.")?r[e]=new o.MemoryLRUCacher(t):r[e]=new i.MemoryCacher),r[e]};n.getCacher=s;var a=function(e){r[e]&&r[e].clear()};n.clearCacher=a;var u=function(){return Object.keys(r)};n.getCacherNames=u},"memory.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryCacher=void 0;var r=t("lodash"),i=function(){function e(){this.cache={}}return e.prototype.get=function(e){return this.cache[e]},e.prototype.delete=function(e){delete this.cache[e]},e.prototype.set=function(e,t){this.cache[e]=t},e.prototype.clear=function(){this.cache={}},e.prototype.keys=function(){return(0,r.keys)(this.cache)},e.prototype.values=function(){return(0,r.values)(this.cache)},e}();n.MemoryCacher=i},"memory-lru.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryLRUCacher=void 0;var r=t("lodash"),i=t("lru-cache"),o={max:5e3,ttl:null,keygen:null,maxParamsLength:null},s=function(){function e(e){this.opts=(0,r.defaultsDeep)(e,o),this.cache=new i({max:this.opts.max,maxAge:this.opts.ttl?1e3*this.opts.ttl:null,updateAgeOnGet:!!this.opts.ttl})}return e.prototype.get=function(e){return this.cache.get(e)},e.prototype.set=function(e,t,n){return this.cache.set(e,t,n)},e.prototype.delete=function(e){return this.cache.delete(e)},e.prototype.clear=function(){return this.cache.clear()},e.prototype.keys=function(){return this.cache.keys()},e.prototype.values=function(){return this.cache.values()},e}();n.MemoryLRUCacher=s}},node_modules:{"lru-cache":{"package.json":function e(t,n,e){e.exports={name:"lru-cache",version:"7.14.1",main:"index.js"}},"index.js":function e(t,n,e){const r="object"==typeof performance&&performance&&"function"==typeof performance.now?performance:Date,i="function"==typeof AbortController,o=i?AbortController:class e{constructor(){this.signal=new u}abort(){this.signal.dispatchEvent("abort")}},s="function"==typeof AbortSignal,a="function"==typeof o.AbortSignal,u=s?AbortSignal:a?o.AbortController:class e{constructor(){this.aborted=!1,this._listeners=[]}dispatchEvent(e){if("abort"===e){this.aborted=!0;const t={type:e,target:this};this.onabort(t),this._listeners.forEach(e=>e(t),this)}}onabort(){}addEventListener(e,t){"abort"===e&&this._listeners.push(t)}removeEventListener(e,t){"abort"===e&&(this._listeners=this._listeners.filter(e=>e!==t))}},f=new Set,c=(e,t)=>{const n=`LRU_CACHE_OPTION_${e}`;p(n)&&g(n,`${e} option`,`options.${t}`,_)},l=(e,t)=>{const n=`LRU_CACHE_METHOD_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} method`,`cache.${t}()`,i)}},h=(e,t)=>{const n=`LRU_CACHE_PROPERTY_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} property`,`cache.${t}`,i)}},d=(...e)=>{"object"==typeof process&&process&&"function"==typeof process.emitWarning?process.emitWarning(...e):console.error(...e)},p=e=>!f.has(e),g=(e,t,n,r)=>{f.add(e);const i=`The ${t} is deprecated. Please use ${n} instead.`;d(i,"DeprecationWarning",e,r)},b=e=>e&&e===Math.floor(e)&&e>0&&isFinite(e),m=e=>b(e)?e<=Math.pow(2,8)?Uint8Array:e<=Math.pow(2,16)?Uint16Array:e<=Math.pow(2,32)?Uint32Array:e<=Number.MAX_SAFE_INTEGER?v:null:null;class v extends Array{constructor(e){super(e),this.fill(0)}}class y{constructor(e){if(0===e)return[];const t=m(e);this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}}class _{constructor(e={}){const{max:t=0,ttl:n,ttlResolution:r=1,ttlAutopurge:i,updateAgeOnGet:o,updateAgeOnHas:s,allowStale:a,dispose:u,disposeAfter:l,noDisposeOnSet:h,noUpdateTTL:g,maxSize:v=0,maxEntrySize:w=0,sizeCalculation:k,fetchMethod:j,fetchContext:x,noDeleteOnFetchRejection:S,noDeleteOnStaleGet:D}=e,{length:E,maxAge:A,stale:C}=e instanceof _?{}:e;if(0!==t&&!b(t))throw new TypeError("max option must be a nonnegative integer");const M=t?m(t):Array;if(!M)throw new Error("invalid max value: "+t);if(this.max=t,this.maxSize=v,this.maxEntrySize=w||this.maxSize,this.sizeCalculation=k||E,this.sizeCalculation){if(!this.maxSize&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if("function"!=typeof this.sizeCalculation)throw new TypeError("sizeCalculation set to non-function")}if(this.fetchMethod=j||null,this.fetchMethod&&"function"!=typeof this.fetchMethod)throw new TypeError("fetchMethod must be a function if specified");if(this.fetchContext=x,!this.fetchMethod&&void 0!==x)throw new TypeError("cannot set fetchContext without fetchMethod");if(this.keyMap=new Map,this.keyList=new Array(t).fill(null),this.valList=new Array(t).fill(null),this.next=new M(t),this.prev=new M(t),this.head=0,this.tail=0,this.free=new y(t),this.initialFill=1,this.size=0,"function"==typeof u&&(this.dispose=u),"function"==typeof l?(this.disposeAfter=l,this.disposed=[]):(this.disposeAfter=null,this.disposed=null),this.noDisposeOnSet=!!h,this.noUpdateTTL=!!g,this.noDeleteOnFetchRejection=!!S,0!==this.maxEntrySize){if(0!==this.maxSize&&!b(this.maxSize))throw new TypeError("maxSize must be a positive integer if specified");if(!b(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.initializeSizeTracking()}if(this.allowStale=!!a||!!C,this.noDeleteOnStaleGet=!!D,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!s,this.ttlResolution=b(r)||0===r?r:1,this.ttlAutopurge=!!i,this.ttl=n||A||0,this.ttl){if(!b(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.initializeTTLTracking()}if(0===this.max&&0===this.ttl&&0===this.maxSize)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.max&&!this.maxSize){const e="LRU_CACHE_UNBOUNDED";if(p(e)){f.add(e);const t="TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";d(t,"UnboundedCacheWarning",e,_)}}C&&c("stale","allowStale"),A&&c("maxAge","ttl"),E&&c("length","sizeCalculation")}getRemainingTTL(e){return this.has(e,{updateAgeOnHas:!1})?1/0:0}initializeTTLTracking(){this.ttls=new v(this.max),this.starts=new v(this.max),this.setItemTTL=(e,t,n=r.now())=>{if(this.starts[e]=0!==t?n:0,this.ttls[e]=t,0!==t&&this.ttlAutopurge){const n=setTimeout(()=>{this.isStale(e)&&this.delete(this.keyList[e])},t+1);n.unref&&n.unref()}},this.updateItemAge=e=>{this.starts[e]=0!==this.ttls[e]?r.now():0};let e=0;const t=()=>{const t=r.now();if(this.ttlResolution>0){e=t;const n=setTimeout(()=>e=0,this.ttlResolution);n.unref&&n.unref()}return t};this.getRemainingTTL=n=>{const r=this.keyMap.get(n);return void 0===r?0:0===this.ttls[r]||0===this.starts[r]?1/0:this.starts[r]+this.ttls[r]-(e||t())},this.isStale=n=>0!==this.ttls[n]&&0!==this.starts[n]&&(e||t())-this.starts[n]>this.ttls[n]}updateItemAge(e){}setItemTTL(e,t,n){}isStale(e){return!1}initializeSizeTracking(){this.calculatedSize=0,this.sizes=new v(this.max),this.removeItemSize=e=>{this.calculatedSize-=this.sizes[e],this.sizes[e]=0},this.requireSize=(e,t,n,r)=>{if(this.isBackgroundFetch(t))return 0;if(!b(n)){if(!r)throw new TypeError("invalid size value (must be positive integer)");if("function"!=typeof r)throw new TypeError("sizeCalculation must be a function");if(n=r(t,e),!b(n))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}return n},this.addItemSize=(e,t)=>{if(this.sizes[e]=t,this.maxSize){const t=this.maxSize-this.sizes[e];for(;this.calculatedSize>t;)this.evict(!0)}this.calculatedSize+=this.sizes[e]}}removeItemSize(e){}addItemSize(e,t){}requireSize(e,t,n,r){if(n||r)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache")}*indexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.tail;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.head);)t=this.prev[t]}*rindexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.head;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.tail);)t=this.next[t]}isValidIndex(e){return this.keyMap.get(this.keyList[e])===e}*entries(){for(const e of this.indexes())yield[this.keyList[e],this.valList[e]]}*rentries(){for(const e of this.rindexes())yield[this.keyList[e],this.valList[e]]}*keys(){for(const e of this.indexes())yield this.keyList[e]}*rkeys(){for(const e of this.rindexes())yield this.keyList[e]}*values(){for(const e of this.indexes())yield this.valList[e]}*rvalues(){for(const e of this.rindexes())yield this.valList[e]}[Symbol.iterator](){return this.entries()}find(e,t={}){for(const n of this.indexes())if(e(this.valList[n],this.keyList[n],this))return this.get(this.keyList[n],t)}forEach(e,t=this){for(const n of this.indexes())e.call(t,this.valList[n],this.keyList[n],this)}rforEach(e,t=this){for(const n of this.rindexes())e.call(t,this.valList[n],this.keyList[n],this)}get prune(){return l("prune","purgeStale"),this.purgeStale}purgeStale(){let e=!1;for(const t of this.rindexes({allowStale:!0}))this.isStale(t)&&(this.delete(this.keyList[t]),e=!0);return e}dump(){const e=[];for(const t of this.indexes({allowStale:!0})){const n=this.keyList[t],i=this.valList[t],o=this.isBackgroundFetch(i)?i.__staleWhileFetching:i,s={value:o};if(this.ttls){s.ttl=this.ttls[t];const e=r.now()-this.starts[t];s.start=Math.floor(Date.now()-e)}this.sizes&&(s.size=this.sizes[t]),e.unshift([n,s])}return e}load(e){this.clear();for(const[t,n]of e){if(n.start){const e=Date.now()-n.start;n.start=r.now()-e}this.set(t,n.value,n)}}dispose(e,t,n){}set(e,t,{ttl:n=this.ttl,start:r,noDisposeOnSet:i=this.noDisposeOnSet,size:o=0,sizeCalculation:s=this.sizeCalculation,noUpdateTTL:a=this.noUpdateTTL}={}){if(o=this.requireSize(e,t,o,s),this.maxEntrySize&&o>this.maxEntrySize)return this.delete(e),this;let u=0===this.size?void 0:this.keyMap.get(e);if(void 0===u)u=this.newIndex(),this.keyList[u]=e,this.valList[u]=t,this.keyMap.set(e,u),this.next[this.tail]=u,this.prev[u]=this.tail,this.tail=u,this.size++,this.addItemSize(u,o),a=!1;else{const n=this.valList[u];t!==n&&(this.isBackgroundFetch(n)?n.__abortController.abort():i||(this.dispose(n,e,"set"),this.disposeAfter&&this.disposed.push([n,e,"set"])),this.removeItemSize(u),this.valList[u]=t,this.addItemSize(u,o)),this.moveToTail(u)}if(0===n||0!==this.ttl||this.ttls||this.initializeTTLTracking(),a||this.setItemTTL(u,n,r),this.disposeAfter)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return this}newIndex(){return 0===this.size?this.tail:this.size===this.max&&0!==this.max?this.evict(!1):0!==this.free.length?this.free.pop():this.initialFill++}pop(){if(this.size){const e=this.valList[this.head];return this.evict(!0),e}}evict(e){const t=this.head,n=this.keyList[t],r=this.valList[t];return this.isBackgroundFetch(r)?r.__abortController.abort():(this.dispose(r,n,"evict"),this.disposeAfter&&this.disposed.push([r,n,"evict"])),this.removeItemSize(t),e&&(this.keyList[t]=null,this.valList[t]=null,this.free.push(t)),this.head=this.next[t],this.keyMap.delete(n),this.size--,t}has(e,{updateAgeOnHas:t=this.updateAgeOnHas}={}){const n=this.keyMap.get(e);return void 0!==n&&!this.isStale(n)&&(t&&this.updateItemAge(n),!0)}peek(e,{allowStale:t=this.allowStale}={}){const n=this.keyMap.get(e);if(void 0!==n&&(t||!this.isStale(n))){const e=this.valList[n];return this.isBackgroundFetch(e)?e.__staleWhileFetching:e}}backgroundFetch(e,t,n,r){const i=void 0===t?void 0:this.valList[t];if(this.isBackgroundFetch(i))return i;const s=new o,a={signal:s.signal,options:n,context:r},u=t=>(s.signal.aborted||this.set(e,t,a.options),t),f=r=>{if(this.valList[t]===l){const r=!n.noDeleteOnFetchRejection||void 0===l.__staleWhileFetching;r?this.delete(e):this.valList[t]=l.__staleWhileFetching}if(l.__returned===l)throw r},c=t=>t(this.fetchMethod(e,i,a)),l=new Promise(c).then(u,f);return l.__abortController=s,l.__staleWhileFetching=i,l.__returned=null,void 0===t?(this.set(e,l,a.options),t=this.keyMap.get(e)):this.valList[t]=l,l}isBackgroundFetch(e){return e&&"object"==typeof e&&"function"==typeof e.then&&Object.prototype.hasOwnProperty.call(e,"__staleWhileFetching")&&Object.prototype.hasOwnProperty.call(e,"__returned")&&(e.__returned===e||null===e.__returned)}async fetch(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet,ttl:i=this.ttl,noDisposeOnSet:o=this.noDisposeOnSet,size:s=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:u=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,fetchContext:c=this.fetchContext,forceRefresh:l=!1}={}){if(!this.fetchMethod)return this.get(e,{allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r});const h={allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r,ttl:i,noDisposeOnSet:o,size:s,sizeCalculation:a,noUpdateTTL:u,noDeleteOnFetchRejection:f};let d=this.keyMap.get(e);if(void 0===d){const t=this.backgroundFetch(e,d,h,c);return t.__returned=t}{const r=this.valList[d];if(this.isBackgroundFetch(r))return t&&void 0!==r.__staleWhileFetching?r.__staleWhileFetching:r.__returned=r;if(!l&&!this.isStale(d))return this.moveToTail(d),n&&this.updateItemAge(d),r;const i=this.backgroundFetch(e,d,h,c);return t&&void 0!==i.__staleWhileFetching?i.__staleWhileFetching:i.__returned=i}}get(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet}={}){const i=this.keyMap.get(e);if(void 0!==i){const o=this.valList[i],s=this.isBackgroundFetch(o);if(this.isStale(i))return s?t?o.__staleWhileFetching:void 0:(r||this.delete(e),t?o:void 0);if(s)return;return this.moveToTail(i),n&&this.updateItemAge(i),o}}connect(e,t){this.prev[t]=e,this.next[e]=t}moveToTail(e){e!==this.tail&&(e===this.head?this.head=this.next[e]:this.connect(this.prev[e],this.next[e]),this.connect(this.tail,e),this.tail=e)}get del(){return l("del","delete"),this.delete}delete(e){let t=!1;if(0!==this.size){const n=this.keyMap.get(e);if(void 0!==n)if(t=!0,1===this.size)this.clear();else{this.removeItemSize(n);const t=this.valList[n];this.isBackgroundFetch(t)?t.__abortController.abort():(this.dispose(t,e,"delete"),this.disposeAfter&&this.disposed.push([t,e,"delete"])),this.keyMap.delete(e),this.keyList[n]=null,this.valList[n]=null,n===this.tail?this.tail=this.prev[n]:n===this.head?this.head=this.next[n]:(this.next[this.prev[n]]=this.next[n],this.prev[this.next[n]]=this.prev[n]),this.size--,this.free.push(n)}}if(this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return t}clear(){for(const e of this.rindexes({allowStale:!0})){const t=this.valList[e];if(this.isBackgroundFetch(t))t.__abortController.abort();else{const n=this.keyList[e];this.dispose(t,n,"delete"),this.disposeAfter&&this.disposed.push([t,n,"delete"])}}if(this.keyMap.clear(),this.valList.fill(null),this.keyList.fill(null),this.ttls&&(this.ttls.fill(0),this.starts.fill(0)),this.sizes&&this.sizes.fill(0),this.head=0,this.tail=0,this.initialFill=1,this.free.length=0,this.calculatedSize=0,this.size=0,this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift())}get reset(){return l("reset","clear"),this.clear}get length(){return h("length","size"),this.size}static get AbortController(){return o}static get AbortSignal(){return u}}e.exports=_}}}},"form-builder":{"package.json":function e(t,n,e){e.exports={name:"@steedos/form-builder",version:"3.6.2-patch.5",private:!1,publishConfig:{access:"public"},main:"dist/form-builder.min.js",homepage:"https://formbuilder.online/",repository:{url:"https://github.com/kevinchappell/formBuilder.git",type:"git"},files:["dist/**/*","docs/**/*","src/**/*"],author:"Kevin Chappell ",contributors:[],bugs:"https://github.com/kevinchappell/formBuilder/issues",description:"A jQuery plugin for drag and drop form building",keywords:["jquery-plugin","forms","drag and drop","form builder","form create"],license:"MIT",ignore:["**/*","node_modules","test"],config:{files:{test:["test/**/*.spec.js"],pluginsDir:"src/js/control_plugins/",fonts:"src/fonts",sass:"src/sass",formBuilder:{js:"src/js/form-builder.js",sass:["src/sass/form-builder.scss"]},formRender:{js:"src/js/form-render.js",sass:["src/sass/form-render.scss"]},site:["demo/assets/sass/site.scss"]},fontServer:"http://fontello.com",fontelloToken:"09d648f01d6c57cb9f9b8cc55043e0c0"},babel:{presets:[["@babel/preset-env",{targets:{browsers:["> 1%"]},loose:!0}]],comments:!1,plugins:["@babel/plugin-proposal-object-rest-spread","@babel/plugin-proposal-class-properties"]},scripts:{"build:analyze":"webpack --mode production -p --progress --config tools/webpack.config --analyze","build:plugins":"webpack --mode production -p --display-entrypoints --progress --config tools/webpack.plugins.config","build:vendor":"babel-node tools/build-vendor",build:"webpack --mode production -p --progress --config tools/webpack.config","build:all":"npm-run-all build:plugins build:vendor build copy",copy:"cp -a dist/* demo/assets/js/ && cp CONTRIBUTING.md docs/contributing.md && cp LICENSE docs/license.md && npm run copy:lang","copy:lang":"babel-node tools/copy-language-files","deploy:all":"npm-run-all deploy:demo deploy:site","deploy:demo":"node tools/deploy-demo.js","deploy:site":"node tools/deploy-site.js",docs:"mkdocs build",font:"babel-node tools/icon-font",lint:"eslint ./src --ext .js || true","semantic-release":"semantic-release","start:devServer":"webpack-dev-server --mode development --config tools/webpack.config",prestart:"npm-run-all -p build:vendor copy:lang",start:"npm run start:devServer",test:"npm run-script build"},dependencies:{jquery:">=3.4.1","jquery-ui-sortable":"*"},devDependencies:{"@babel/cli":"^7.10.5","@babel/core":"^7.11.4","@babel/node":"^7.10.5","@babel/plugin-proposal-class-properties":"^7.10.4","@babel/plugin-proposal-object-rest-spread":"^7.11.0","@babel/plugin-syntax-object-rest-spread":"^7.8.3","@babel/plugin-transform-destructuring":"^7.10.4","@babel/preset-env":"^7.11.0","@semantic-release/changelog":"^5.0.1","@semantic-release/git":"^9.0.0","@semantic-release/npm":"^7.0.5",autoprefixer:"^9.8.6","babel-eslint":"^10.1.0","babel-loader":"^8.1.0","clean-webpack-plugin":"^3.0.0",clui:"^0.3.6","compression-webpack-plugin":"^5.0.1","concat-files":"^0.1.1","cross-env":"^7.0.2","css-loader":"^4.2.1",eslint:"^7.7.0","eslint-loader":"^4.0.2","formbuilder-languages":"latest","fs-extra":"^9.0.1","html-webpack-harddisk-plugin":"^1.0.2","html-webpack-plugin":"^4.3.0",inquirer:"^7.3.3",mi18n:"^0.4.8","node-sass":"6.0.1","npm-run-all":"^4.1.5",opener:"^1.5.1","postcss-loader":"^3.0.0","replace-in-file":"^6.1.0",request:"^2.88.2","sass-loader":"10.5.2","semantic-release":"^17.1.1",semver:"^7.3.2","style-loader":"^1.2.1",unzipper:"^0.10.11",webpack:"^4.44.1","webpack-bundle-analyzer":"^3.8.0","webpack-cli":"^3.3.12","webpack-dev-server":"^3.11.0","wrapper-webpack-plugin":"^2.1.0"},prettier:{singleQuote:!0,trailingComma:"all",printWidth:120,semi:!1,arrowParens:"avoid",spaceAfterFunction:!1},engines:{},release:{branch:"master",verifyConditions:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"],prepare:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"]},browserslist:["> 1%"]}},dist:{"form-builder.min.js":[]}}},tslib:{"package.json":function e(t,n,e){e.exports={name:"tslib",version:"2.3.1",module:"tslib.es6.js",main:"tslib.js"}},"tslib.es6.js":function e(t,n,e){e.export({__extends:()=>i,__assign:()=>o,__rest:()=>s,__decorate:()=>a,__param:()=>u,__metadata:()=>f,__awaiter:()=>c,__generator:()=>l,__createBinding:()=>h,__exportStar:()=>d,__values:()=>p,__read:()=>g,__spread:()=>b,__spreadArrays:()=>m,__spreadArray:()=>v,__await:()=>y,__asyncGenerator:()=>_,__asyncDelegator:()=>w,__asyncValues:()=>k,__makeTemplateObject:()=>j,__importStar:()=>S,__importDefault:()=>D,__classPrivateFieldGet:()=>E,__classPrivateFieldSet:()=>A}); +if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(jQuery),function(e){"use strict";function t(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var n in t)if(void 0!==e.style[n])return{end:t[n]};return!1}e.fn.emulateTransitionEnd=function(t){var n=!1,r=this,i;return e(this).one("bsTransitionEnd",(function(){n=!0})),setTimeout((function(){n||e(r).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=t(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(jQuery),function(e){"use strict";var t='[data-dismiss="alert"]',n=function(n){e(n).on("click",t,this.close)};function r(t){return this.each((function(){var r=e(this),i=r.data("bs.alert");i||r.data("bs.alert",i=new n(this)),"string"==typeof t&&i[t].call(r)}))}n.VERSION="3.4.1",n.TRANSITION_DURATION=150,n.prototype.close=function(t){var r=e(this),i=r.attr("data-target");i||(i=(i=r.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=e(document).find(i);function s(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=r.closest(".alert")),o.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),e.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",s).emulateTransitionEnd(n.TRANSITION_DURATION):s())};var i=e.fn.alert;e.fn.alert=r,e.fn.alert.Constructor=n,e.fn.alert.noConflict=function(){return e.fn.alert=i,this},e(document).on("click.bs.alert.data-api",t,n.prototype.close)}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.isLoading=!1};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.button"),o="object"==typeof n&&n;i||r.data("bs.button",i=new t(this,o)),"toggle"==n?i.toggle():n&&i.setState(n)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var n="disabled",r=this.$element,i=r.is("input")?"val":"html",o=r.data();t+="Text",null==o.resetText&&r.data("resetText",r[i]()),setTimeout(e.proxy((function(){r[i](null==o[t]?this.options[t]:o[t]),"loadingText"==t?(this.isLoading=!0,r.addClass(n).attr(n,n).prop(n,!0)):this.isLoading&&(this.isLoading=!1,r.removeClass(n).removeAttr(n).prop(n,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var n=this.$element.find("input");"radio"==n.prop("type")?(n.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==n.prop("type")&&(n.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),n.prop("checked",this.$element.hasClass("active")),e&&n.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var r=e.fn.button;e.fn.button=n,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=r,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var r=e(t.target).closest(".btn");n.call(r,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),r.is("input,button")?r.trigger("focus"):r.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(jQuery),function(e){"use strict";var t=function(t,n){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=n,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.carousel"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n),s="string"==typeof n?n:o.slide;i||r.data("bs.carousel",i=new t(this,o)),"number"==typeof n?i.to(n):s?i[s]():o.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var n=this.getItemIndex(t),r;if(("prev"==e&&0===n||"next"==e&&n==this.$items.length-1)&&!this.options.wrap)return t;var i,o=(n+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(o)},t.prototype.to=function(e){var t=this,n=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):n==e?this.pause().cycle():this.slide(e>n?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(n,r){var i=this.$element.find(".item.active"),o=r||this.getItemForDirection(n,i),s=this.interval,a="next"==n?"left":"right",u=this;if(o.hasClass("active"))return this.sliding=!1;var f=o[0],c=e.Event("slide.bs.carousel",{relatedTarget:f,direction:a});if(this.$element.trigger(c),!c.isDefaultPrevented()){if(this.sliding=!0,s&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var l=e(this.$indicators.children()[this.getItemIndex(o)]);l&&l.addClass("active")}var h=e.Event("slid.bs.carousel",{relatedTarget:f,direction:a});return e.support.transition&&this.$element.hasClass("slide")?(o.addClass(n),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(a),o.addClass(a),i.one("bsTransitionEnd",(function(){o.removeClass([n,a].join(" ")).addClass("active"),i.removeClass(["active",a].join(" ")),u.sliding=!1,setTimeout((function(){u.$element.trigger(h)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(h)),s&&this.cycle(),this}};var r=e.fn.carousel;e.fn.carousel=n,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=r,this};var i=function(t){var r=e(this),i=r.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=r.attr("data-target")||i,s=e(document).find(o);if(s.hasClass("carousel")){var a=e.extend({},s.data(),r.data()),u=r.attr("data-slide-to");u&&(a.interval=!1),n.call(s,a),u&&s.data("bs.carousel").to(u),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);n.call(t,t.data())}))}))}(jQuery),function(e){"use strict";var t=function(n,r){this.$element=e(n),this.options=e.extend({},t.DEFAULTS,r),this.$trigger=e('[data-toggle="collapse"][href="#'+n.id+'"],[data-toggle="collapse"][data-target="#'+n.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function n(t){var n,r=t.attr("data-target")||(n=t.attr("href"))&&n.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(r)}function r(n){return this.each((function(){var r=e(this),i=r.data("bs.collapse"),o=e.extend({},t.DEFAULTS,r.data(),"object"==typeof n&&n);!i&&o.toggle&&/show|hide/.test(n)&&(o.toggle=!1),i||r.data("bs.collapse",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){var e;return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var n,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(n=i.data("bs.collapse"))&&n.transitioning)){var o=e.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){i&&i.length&&(r.call(i,"hide"),n||i.data("bs.collapse",null));var s=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[s](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var a=function(){this.$element.removeClass("collapsing").addClass("collapse in")[s](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return a.call(this);var u=e.camelCase(["scroll",s].join("-"));this.$element.one("bsTransitionEnd",e.proxy(a,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[s](this.$element[0][u])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var n=e.Event("hide.bs.collapse");if(this.$element.trigger(n),!n.isDefaultPrevented()){var r=this.dimension();this.$element[r](this.$element[r]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[r](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,r){var i=e(r);this.addAriaAndCollapsedClass(n(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var n=e.hasClass("in");e.attr("aria-expanded",n),t.toggleClass("collapsed",!n).attr("aria-expanded",n)};var i=e.fn.collapse;e.fn.collapse=r,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var o=n(i),s,a=o.data("bs.collapse")?"toggle":i.data();r.call(o,a)}))}(jQuery),function(e){"use strict";var t=".dropdown-backdrop",n='[data-toggle="dropdown"]',r=function(t){e(t).on("click.bs.dropdown",this.toggle)};function i(t){var n=t.attr("data-target");n||(n=(n=t.attr("href"))&&/#[A-Za-z]/.test(n)&&n.replace(/.*(?=#[^\s]*$)/,""));var r="#"!==n?e(document).find(n):null;return r&&r.length?r:t.parent()}function o(r){r&&3===r.which||(e(t).remove(),e(n).each((function(){var t=e(this),n=i(t),o={relatedTarget:this};n.hasClass("open")&&(r&&"click"==r.type&&/input|textarea/i.test(r.target.tagName)&&e.contains(n[0],r.target)||(n.trigger(r=e.Event("hide.bs.dropdown",o)),r.isDefaultPrevented()||(t.attr("aria-expanded","false"),n.removeClass("open").trigger(e.Event("hidden.bs.dropdown",o)))))})))}function s(t){return this.each((function(){var n=e(this),i=n.data("bs.dropdown");i||n.data("bs.dropdown",i=new r(this)),"string"==typeof t&&i[t].call(n)}))}r.VERSION="3.4.1",r.prototype.toggle=function(t){var n=e(this);if(!n.is(".disabled, :disabled")){var r=i(n),s=r.hasClass("open");if(o(),!s){"ontouchstart"in document.documentElement&&!r.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",o);var a={relatedTarget:this};if(r.trigger(t=e.Event("show.bs.dropdown",a)),t.isDefaultPrevented())return;n.trigger("focus").attr("aria-expanded","true"),r.toggleClass("open").trigger(e.Event("shown.bs.dropdown",a))}return!1}},r.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var r=e(this);if(t.preventDefault(),t.stopPropagation(),!r.is(".disabled, :disabled")){var o=i(r),s=o.hasClass("open");if(!s&&27!=t.which||s&&27==t.which)return 27==t.which&&o.find(n).trigger("focus"),r.trigger("click");var a=" li:not(.disabled):visible a",u=o.find(".dropdown-menu"+a);if(u.length){var f=u.index(t.target);38==t.which&&f>0&&f--,40==t.which&&fdocument.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},f.prototype.init=function(t,n,r){if(this.enabled=!0,this.type=t,this.$element=e(n),this.options=this.getOptions(r),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),o=i.length;o--;){var s=i[o];if("click"==s)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=s){var a="hover"==s?"mouseenter":"focusin",u="hover"==s?"mouseleave":"focusout";this.$element.on(a+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(u+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},f.prototype.getDefaults=function(){return f.DEFAULTS},f.prototype.getOptions=function(n){var r=this.$element.data();for(var i in r)r.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete r[i];return(n=e.extend({},this.getDefaults(),r,n)).delay&&"number"==typeof n.delay&&(n.delay={show:n.delay,hide:n.delay}),n.sanitize&&(n.template=u(n.template,n.whiteList,n.sanitizeFn)),n},f.prototype.getDelegateOptions=function(){var t={},n=this.getDefaults();return this._options&&e.each(this._options,(function(e,r){n[e]!=r&&(t[e]=r)})),t},f.prototype.enter=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusin"==t.type?"focus":"hover"]=!0),n.tip().hasClass("in")||"in"==n.hoverState)n.hoverState="in";else{if(clearTimeout(n.timeout),n.hoverState="in",!n.options.delay||!n.options.delay.show)return n.show();n.timeout=setTimeout((function(){"in"==n.hoverState&&n.show()}),n.options.delay.show)}},f.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},f.prototype.leave=function(t){var n=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(n||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n)),t instanceof e.Event&&(n.inState["focusout"==t.type?"focus":"hover"]=!1),!n.isInStateTrue()){if(clearTimeout(n.timeout),n.hoverState="out",!n.options.delay||!n.options.delay.hide)return n.hide();n.timeout=setTimeout((function(){"out"==n.hoverState&&n.hide()}),n.options.delay.hide)}},f.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var n=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!n)return;var r=this,i=this.tip(),o=this.getUID(this.type);this.setContent(),i.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&i.addClass("fade");var s="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,a=/\s?auto?\s?/i,u=a.test(s);u&&(s=s.replace(a,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(s).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var c=this.getPosition(),l=i[0].offsetWidth,h=i[0].offsetHeight;if(u){var d=s,p=this.getPosition(this.$viewport);s="bottom"==s&&c.bottom+h>p.bottom?"top":"top"==s&&c.top-hp.width?"left":"left"==s&&c.left-ls.top+s.height&&(i.top=s.top+s.height-u)}else{var f=t.left-o,c=t.left+o+n;fs.right&&(i.left=s.left+s.width-c)}return i},f.prototype.getTitle=function(){var e,t=this.$element,n=this.options;return e=t.attr("data-original-title")||("function"==typeof n.title?n.title.call(t[0]):n.title)},f.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},f.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},f.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},f.prototype.enable=function(){this.enabled=!0},f.prototype.disable=function(){this.enabled=!1},f.prototype.toggleEnabled=function(){this.enabled=!this.enabled},f.prototype.toggle=function(t){var n=this;t&&((n=e(t.currentTarget).data("bs."+this.type))||(n=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,n))),t?(n.inState.click=!n.inState.click,n.isInStateTrue()?n.enter(n):n.leave(n)):n.tip().hasClass("in")?n.leave(n):n.enter(n)},f.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},f.prototype.sanitizeHtml=function(e){return u(e,this.options.whiteList,this.options.sanitizeFn)};var l=e.fn.tooltip;e.fn.tooltip=c,e.fn.tooltip.Constructor=f,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=l,this}}(jQuery),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");function n(n){return this.each((function(){var r=e(this),i=r.data("bs.popover"),o="object"==typeof n&&n;!i&&/destroy|hide/.test(n)||(i||r.data("bs.popover",i=new t(this,o)),"string"==typeof n&&i[n]())}))}t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:''}),t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype),t.prototype.constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),n=this.getContent();if(this.options.html){var r=typeof n;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===r&&(n=this.sanitizeHtml(n))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===r?"html":"append"](n)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(n);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var r=e.fn.popover;e.fn.popover=n,e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=r,this}}(jQuery),function(e){"use strict";function t(n,r){this.$body=e(document.body),this.$scrollElement=e(n).is(document.body)?e(window):e(n),this.options=e.extend({},t.DEFAULTS,r),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function n(n){return this.each((function(){var r=e(this),i=r.data("bs.scrollspy"),o="object"==typeof n&&n;i||r.data("bs.scrollspy",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,n="offset",r=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(n="position",r=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),o=/^#./.test(i)&&e(i);return o&&o.length&&o.is(":visible")&&[[o[n]().top+r,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.getScrollHeight(),n=this.options.offset+t-this.$scrollElement.height(),r=this.offsets,i=this.targets,o=this.activeTarget,s;if(this.scrollHeight!=t&&this.refresh(),e>=n)return o!=(s=i[i.length-1])&&this.activate(s);if(o&&e=r[s]&&(void 0===r[s+1]||e .active"),s=i&&e.support.transition&&(o.length&&o.hasClass("fade")||!!r.find("> .fade").length);function a(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),n.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),s?(n[0].offsetWidth,n.addClass("in")):n.removeClass("fade"),n.parent(".dropdown-menu").length&&n.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&s?o.one("bsTransitionEnd",a).emulateTransitionEnd(t.TRANSITION_DURATION):a(),o.removeClass("in")};var r=e.fn.tab;e.fn.tab=n,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=r,this};var i=function(t){t.preventDefault(),n.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(e){"use strict";var t=function(n,r){this.options=e.extend({},t.DEFAULTS,r);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(n),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function n(n){return this.each((function(){var r=e(this),i=r.data("bs.affix"),o="object"==typeof n&&n;i||r.data("bs.affix",i=new t(this,o)),"string"==typeof n&&i[n]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,n,r){var i=this.$target.scrollTop(),o=this.$element.offset(),s=this.$target.height();if(null!=n&&"top"==this.affixed)return i=e-r&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),n=this.$element.offset();return this.pinnedOffset=n.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var n=this.$element.height(),r=this.options.offset,i=r.top,o=r.bottom,s=Math.max(e(document).height(),e(document.body).height());"object"!=typeof r&&(o=i=r),"function"==typeof i&&(i=r.top(this.$element)),"function"==typeof o&&(o=r.bottom(this.$element));var a=this.getState(s,n,i,o);if(this.affixed!=a){null!=this.unpin&&this.$element.css("top","");var u="affix"+(a?"-"+a:""),f=e.Event(u+".bs.affix");if(this.$element.trigger(f),f.isDefaultPrevented())return;this.affixed=a,this.unpin="bottom"==a?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(u).trigger(u.replace("affix","affixed")+".bs.affix")}"bottom"==a&&this.$element.offset({top:s-n-o})}};var r=e.fn.affix;e.fn.affix=n,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=r,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),r=t.data();r.offset=r.offset||{},null!=r.offsetBottom&&(r.offset.bottom=r.offsetBottom),null!=r.offsetTop&&(r.offset.top=r.offsetTop),n.call(t,r)}))}))}(jQuery)}}}},fibers:{"package.json":function e(t,n,e){e.exports={name:"fibers",version:"5.0.3",main:"fibers"}},"fibers.js":function e(t,n,e,r,i){if(process.fiberLib)e.exports=process.fiberLib;else{var o=t("fs"),s=t("path"),a=t("detect-libc");Math.random();var u=s.join(i,"bin",process.platform+"-"+process.arch+"-"+process.versions.modules+("linux"===process.platform?"-"+a.family:""),"fibers");try{process.fiberLib=e.exports=t(u).Fiber}catch(c){throw console.error("## There is an issue with `node-fibers` ##\n`"+u+".node` is missing.\n\nTry running this to fix the issue: "+process.execPath+" "+i.replace(" ","\\ ")+"/build"),console.error(c.stack||c.message||c),new Error("Missing binary. See message above.")}f(e.exports)}function f(e){try{var t=process.binding("async_wrap"),n;if(t.asyncIdStackSize instanceof Function)n=t.asyncIdStackSize;else{if(void 0===t.constants.kStackLength)throw new Error("Couldn't figure out how to get async stack size");l=t.constants.kStackLength,n=function(){return t.async_hook_fields[l]}}var r=t.popAsyncContext||t.popAsyncIds,i=t.pushAsyncContext||t.pushAsyncIds,o,s;if(!r||!i)throw new Error("Push/pop do not exist");o=void 0===t.constants.kExecutionAsyncId?t.constants.kCurrentAsyncId:t.constants.kExecutionAsyncId,s=void 0===t.constants.kTriggerAsyncId?t.constants.kCurrentTriggerId:t.constants.kTriggerAsyncId;var a=t.async_id_fields||t.async_uid_fields;function u(){for(var e=n(),t=new Array(e);e>0;--e){var i=a[o];t[e-1]={asyncId:i,triggerId:a[s]},r(i)}return t}function f(e){for(var t=0;t0)i.changeLanguage(e,r);else if(0!=a[u]){a[u]=0;var f=new XMLHttpRequest;f.overrideMimeType("application/json"),f.open("GET",u,!1),f.send(null),200===f.status?a[u]=1:a[u]=-1,n.addResourceBundle(e,s,JSON.parse(f.response)||{}),i.changeLanguage(e,r)}};n.changeLanguage=p;var g=function(e,t,n){return i.format(e,t,n)};n.format=g;var b=function(){return i.languages};n.getLanguages=b;var m=function(e,t){return i.loadLanguages(e,t)};n.loadLanguages=m;var v=function(e,t){return i.loadNamespaces(e,t)};n.loadNamespaces=v;var y=function(e,t){return i.on(e,t)};n.on=y;var _=function(e,t){return i.off(e,t)};n.off=_,r.__exportStar(t("./i18n/i18n"),n),r.__exportStar(t("./i18n/i18n.app"),n),r.__exportStar(t("./translations"),n)},i18n:{"i18n.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.fallbackKeys=n.getObjectI18nTemplate=n.translationI18nObjects=n.addObjectsI18n=n.translationI18nObject=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="_",a="base",u="core",f="translation",c=function(e,t){var n={lng:t,ns:f};if((0,r.exists)(e,n))return(0,r._t)(e,n)},l=function(e){return"".concat(e,"__object")},h=function(e,t){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t)},d=function(e,t){var n=h(e,t);return"".concat(n).concat("_","inlineHelpText")},p=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","group").concat("_").concat(n)},g=function(e,t,n){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t).concat("_","options").concat("_").concat(n)},b=function(e,t){return"".concat(e).concat("_","action").concat("_").concat(t)},m=function(e,t){return"".concat(e).concat("_","listview").concat("_").concat(t)},v=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},y=function(e,t,n){var r=l(t);return c(r,e)||n||""},_=function(e,t,n,r,i){var o=h(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=_(e,a,n,r,i))}return s||r||""},w=function(e,t,n,r,i){var o=d(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=w(e,a,n,r,i))}return s||r||""},k=function(e,t,n,r){var i=p(t,n);return c(i,e)||r||""},j=function(e,t,n,r,i,o){var s=g(t,n,r),a=c(s,e);if(!a){var u=v(o);u&&"base"!=t&&"core"!=t&&(a=j(e,u,n,r,i,o))}return a||i||""},x=function(e,t,n,r,i){var o=b(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=x(e,a,n,r,i))}return s||r||""},S=function(e,t,n,r,i){var o=m(t,n),s=c(o,e);if(!s){var a=v(i);a&&"base"!=t&&"core"!=t&&(s=S(e,a,n,r,i))}return s||r||""},D=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},E=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;return e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(D(e))}))):n.push(D(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},A=function(e,t,n){n.label=y(e,t,n.label),i.each(n.fields,(function(r,o){if(r.label=_(e,t,o,r.label,n.datasource),r.inlineHelpText&&(r.inlineHelpText=w(e,t,o,r.inlineHelpText,n.datasource)),r.group&&(r.group=k(e,t,r.group,r.group)),r.options){var s=[];i.each(r.options,(function(r){if(i.has(r,"value")){var a=j(e,t,o,r.value,r.label,n.datasource);s.push(i.extend({},r,{label:a}))}else s.push(r)})),r.options=s}})),i.each(n.actions,(function(r,i){r.label=x(e,t,i,r.label,n.datasource)})),i.each(n.list_views,(function(r,i){r.label=S(e,t,i,r.label,n.datasource)}))};n.translationI18nObject=A;var C=function(e){i.each(e,(function(e){(0,r.addResourceBundle)(e.lng,f,e.data,!0,!0)}))};n.addObjectsI18n=C;var M=function(e,t){i.each(t,(function(t,r){(0,n.translationI18nObject)(e,r,t)}))};n.translationI18nObjects=M;var O=function(e,t,n){var r=o(n);E(r);var s={};return s[l(t)]=y(e,t,r.label),i.each(r.fields,(function(n,o){s[h(t,o)]=_(e,t,o,n.label),n.inlineHelpText&&(s[d(t,o)]=w(e,t,o,n.inlineHelpText,r.datasource)),n.group&&(s[p(t,n.group)]=k(e,t,n.group,n.group)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[g(t,o,n.value)]=j(e,t,o,n.value,n.label))}))})),i.each(r.actions,(function(n,r){s[b(t,r)]=x(e,t,r,n.label)})),i.each(r.list_views,(function(n,r){s[m(t,r)]=S(e,t,r,n.label)})),s};n.getObjectI18nTemplate=O,n.fallbackKeys={getObjectLabelKey:l,getObjectFieldLabelKey:h,getObjectFieldInlineHelpTextLabelKey:d,getObjectFieldGroupKey:p,getObjectFieldOptionsLabelKey:g,getObjectActionLabelKey:b,getObjectListviewLabelKey:m}},"i18n.app.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.appFallbackKeys=n.getAppI18nTemplate=n.translationI18nApps=n.translationI18nMenus=void 0;var r=t("../index"),i=t("underscore"),o=t("clone"),s="translation",a="_",u=function(e,t){var n={lng:t,ns:s};if((0,r.exists)(e,n))return(0,r._t)(e,n)},f=function(e){return"app".concat("_").concat(e).concat("_","name")},c=function(e){return"app".concat("_").concat(e).concat("_","description")},l=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","tab_group").concat("_").concat(n)},h=function(e){return"menu".concat("_").concat(e)},d=function(e){return"tab".concat("_").concat(e)},p=function(e,t,n){var r=f(t);return u(r,e)||n||""},g=function(e,t,n){var r=c(t);return u(r,e)||n||""},b=function(e,t,n){var r=h(t);return u(r,e)||n||""},m=function(e,t,r){r.label=p(e,t,r.label||r.name),r.description=g(e,t,r.description),(0,n.translationI18nMenus)(e,r.admin_menus)},v=function(e,t){i.each(t,(function(t){var n=b(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationI18nMenus=v;var y=function(e,t){i.each(t,(function(t,n){m(e,n,t)}))};n.translationI18nApps=y;var _=function(e,t,n){var r=o(n),s={};return s[f(t)]=p(e,t,r.label||r.name),s[c(t)]=g(e,t,r.description),i.each(r.admin_menus,(function(t){s[h(t._id)]=b(e,t._id,t.label||t.name)})),s};n.getAppI18nTemplate=_,n.appFallbackKeys={getAppLabelKey:f,getAppDescriptionKey:c,getAppGroupKey:l,getMenuLabelKey:h,getTabKey:d}}},translations:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.SteedosTranslationPrefixKeys=n.convertObject=void 0;var r=t("tslib"),i=t("underscore");r.__exportStar(t("./objectTranslation"),n),r.__exportStar(t("./translation"),n),r.__exportStar(t("./templates/objectTranslation"),n),r.__exportStar(t("./templates/translation"),n);var o=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},s=function(e){i.forEach(e.fields,(function(e,t){var n=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return n.push(o(e))}))):n.push(o(e))})),e.options=n}catch(r){console.error("convertFieldsOptions error: ",e.options,r)}else if(e.options&&i.isArray(e.options))try{i.forEach(e.options,(function(e){i.isString(e)?n.push(o(e)):n.push(e)})),e.options=n}catch(r){console.error("Creator.convertFieldsOptions",e.options,r)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return n.push({label:e,value:t})})),e.options=n)}))},a;n.convertObject=s,function(e){e.Object="CustomObject",e.Field="CustomField",e.Action="CustomAction",e.Listview="CustomListview",e.Permission="CustomPermission",e.ValidationRule="CustomValidationRule",e.Application="CustomApplication",e.Tab="CustomTabs",e.Permissionset="CustomPermissionset",e.Profile="CustomProfile",e.Report="CustomReport",e.Workflow="Workflow",e.Layout="Layout",e.Client="Client",e.Server="Server",e.Function="Function",e.Router="Router",e.Trigger="Trigger"}(a=n.SteedosTranslationPrefixKeys||(n.SteedosTranslationPrefixKeys={}))},"objectTranslation.js":function e(t,n,e,r){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addObjectsTranslation=n.getObjectTranslationTemplate=n.translationObjects=n.translationObject=n.translationObjectLabel=void 0;var i=t("underscore"),o=t("./"),s=t("../index"),a=t("./index"),u=t("../i18n/i18n"),f=t("lodash"),c=t("crypto"),l,h=(0,t("@steedos/cachers").getCacher)("lru.translations.objects");function d(e){var t;return c.createHash("md5").update(e).digest("hex")}var p=function(e,t){return"".concat(e,"_").concat(t.name,"_").concat(d(JSON.stringify(t)))},g=t("clone"),b=".",m="base",v="core",y="translation",_="object",w="field",k="listview",j="action",x=function(e,t){var n={lng:t,ns:y,keySeparator:!1};if((0,s.exists)(e,n))return(0,s._t)(e,n)},S=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},D=function(e){switch(e){case"object":return o.SteedosTranslationPrefixKeys.Object;case"field":return o.SteedosTranslationPrefixKeys.Field;case"listview":return o.SteedosTranslationPrefixKeys.Listview;case"action":return o.SteedosTranslationPrefixKeys.Action;default:return"CustomLabels"}},E=function(e){var t;return[D(),e].join(".")},A=function(e){var t;return[D("object"),e,"label"].join(".")},C=function(e){var t;return[D("object"),e,"description"].join(".")},M=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"label"].join(".")},O=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"help"].join(".")},T=function(e,t){var n;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"description"].join(".")},B=function(e,t){var n=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_"),r;return[D("field"),e,"group",n].join(".")},I=function(e,t,n){var r;return t&&(t=t.replace(/\./g,"_")),[D("field"),e,t,"options",n].join(".")},R=function(e,t){var n;return[D("action"),e,t].join(".")},F=function(e,t){var n;return[D("listview"),e,t].join(".")},P=function(e,t,n){var r,i=[A(t)],o=u.fallbackKeys.getObjectLabelKey(t);return o&&i.push(o),x(i,e)||n||""};n.translationObjectLabel=P;var N=function(e,t,n){var r=C(t);return x(r,e)||n||""},L=function(e,t,n,r,i,o){var s,a=[M(t,n)],f=u.fallbackKeys.getObjectFieldLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=L(e,l,n,r,i))}return c||r||""},z=function(e,t,n,r,i,o){var s,a=[O(t,n)],f=u.fallbackKeys.getObjectFieldInlineHelpTextLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=z(e,l,n,r,i))}return c||r||""},U=function(e,t,n,r,i,o){var s=T(t,n),a,u=x([s],e);if(1!=o&&!u){var f=S(i);f&&"base"!=t&&"core"!=t&&(u=U(e,f,n,r,i))}return u||r||""},q=function(e,t,n,r,i,o){var s,a=[B(t,n)],f=u.fallbackKeys.getObjectFieldGroupKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=q(e,l,n,r,i))}return c||r||""},$=function(e,t,n,r,i,o,s){var a,f=[I(t,n,r)],c=u.fallbackKeys.getObjectFieldOptionsLabelKey(t,n,r);c&&f.push(c);var l=x(f,e);if(1!=s&&!l){var h=S(o);h&&"base"!=t&&"core"!=t&&(l=$(e,h,n,r,i,o))}return l||i||""},W=function(e,t,n,r,i,o){var s,a=[R(t,n)],f=u.fallbackKeys.getObjectActionLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=W(e,l,n,r,i))}return c||r||""},H=function(e,t,n,r,i,o){var s,a=[F(t,n)],f=u.fallbackKeys.getObjectListviewLabelKey(t,n);f&&a.push(f);var c=x(a,e);if(1!=o&&!c){var l=S(i);l&&"base"!=t&&"core"!=t&&(c=H(e,l,n,r,i))}return c||r||""},Y=function(e,t,r,o,s){void 0===s&&(s=!1);var u=p(e,r),c=h.get(u);if(c)return Object.assign(r,(0,f.cloneDeep)(c));o&&(0,a.convertObject)(r),r.label=(0,n.translationObjectLabel)(e,t,r.label),r.description=N(e,t,r.description),i.each(r.fields,(function(n,o){if(n.label=L(e,t,o,n.label,r.datasource,s),n.inlineHelpText=z(e,t,o,n.inlineHelpText,r.datasource,s),n.description=U(e,t,o,n.description,r.datasource,s),n.group&&(n.group=q(e,t,n.group,n.group,r.datasource,s)),n.options){var a=[];i.each(n.options,(function(n){if(i.has(n,"value")){var u=$(e,t,o,n.value,n.label,r.datasource,s);a.push(i.extend({},n,{label:u}))}else a.push(n)})),n.options=a}})),i.each(r.actions,(function(n,i){n.label=W(e,t,i,n.label,r.datasource,s)})),i.each(r.list_views,(function(n,i){n.label=H(e,t,i,n.label,r.datasource,s)})),h.set(u,(0,f.cloneDeep)(r))};n.translationObject=Y;var V=function(e,t){i.each(t,(function(t,r){(0,n.translationObject)(e,r,t)}))};n.translationObjects=V;var K=function(e,t,r){var o=g(r);(0,a.convertObject)(o);var s={};return s[A(t)]=(0,n.translationObjectLabel)(e,t,o.label),s[C(t)]=N(e,t,o.description),i.each(o.fields,(function(n,r){s[M(t,r)]=L(e,t,r,n.label),n.inlineHelpText&&(s[O(t,r)]=z(e,t,r,n.inlineHelpText,o.datasource)),n.description&&(s[T(t,r)]=U(e,t,r,n.description,o.datasource)),n.group&&(s[B(t,n.group)]=q(e,t,n.group,n.group,o.datasource)),n.options&&i.each(n.options,(function(n){i.has(n,"value")&&(s[I(t,r,n.value)]=$(e,t,r,n.value,n.label))}))})),i.each(o.actions,(function(n,r){s[R(t,r)]=W(e,t,r,n.label)})),i.each(o.list_views,(function(n,r){s[F(t,r)]=H(e,t,r,n.label)})),s};function G(e,t){var n=g(e);(0,a.convertObject)(n);var r={},o=n.name;return o||console.error("Error: Invalid objectTranslation:"+t),r[A(o)]=n.label,r[C(o)]=n.description,i.each(n.fields,(function(e,t){r[M(o,t)]=e.label,e.help&&(r[O(o,t)]=e.help),e.description&&(r[T(o,t)]=e.description),e.options&&i.each(e.options,(function(e){i.has(e,"value")&&(r[I(o,t,e.value)]=e.label)}))})),i.each(n.groups,(function(e,t){r[B(o,t)]=e})),i.each(n.actions,(function(e,t){r[R(o,t)]=e.label})),i.each(n.listviews,(function(e,t){r[F(o,t)]=e.label})),i.each(n.CustomLabels,(function(e,t){r[E(t)]=e})),r}n.getObjectTranslationTemplate=K;var X=function(e){i.each(e,(function(e){var t=G(e.data,e.__filename);(0,s.addResourceBundle)(e.lng,y,t,!0,!0)}))};n.addObjectsTranslation=X},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.addTranslations=n.convertTranslation=n.convertTranslationData=n.getAppTranslationTemplate=n.translationApps=n.translationMenus=n.translationApp=n.translationTabLabel=n.translationTabGroup=void 0;var r=t("../index"),i=t("underscore"),o=t("./"),s=t("../i18n/i18n.app"),a=t("clone"),u="translation",f=".",c="app",l="menu",h="tab",d=function(e){switch(e){case"app":return o.SteedosTranslationPrefixKeys.Application;case"tab":return o.SteedosTranslationPrefixKeys.Tab;default:return"CustomLabels"}},p=function(e){var t;return[d(),e].join(".")},g=function(e,t){var n={lng:t,ns:u,keySeparator:!1};if((0,r.exists)(e,n))return(0,r._t)(e,n)},b=function(e){var t;return[d("app"),e,"name"].join(".")},m=function(e){var t;return[d("app"),e,"description"].join(".")},v=function(e,t){var n,r;return[d("app"),e,"groups",t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_")].join(".")},y=function(e){var t;return[d("menu"),"menu_".concat(e)].join(".")},_=function(e){var t;return[d("tab"),e].join(".")},w=function(e,t,n){var r,i=[b(t)],o=s.appFallbackKeys.getAppLabelKey(t);return o&&i.push(o),g(i,e)||n||""},k=function(e,t,n){var r,i=[m(t)],o=s.appFallbackKeys.getAppDescriptionKey(t);return o&&i.push(o),g(i,e)||n||""},j=function(e,t,n,r){var i,o=[v(t,n)],a=s.appFallbackKeys.getAppGroupKey(t,n);return a&&o.push(a),g(o,e)||r||""};n.translationTabGroup=j;var x=function(e,t,n){var r,i=[y(t)],o=s.appFallbackKeys.getMenuLabelKey(t);return o&&i.push(o),g(i,e)||n||""},S=function(e,t,n){var r,i=[_(t)],o=s.appFallbackKeys.getTabKey(t);return o&&i.push(o),g(i,e)||n||""};n.translationTabLabel=S;var D=function(e,t,r){r.label=w(e,t,r.label||r.name),r.description=k(e,t,r.description),i.each(r.tab_groups,(function(i,o){r.tab_groups[o].id=i.id||i.group_name,r.tab_groups[o].group_name=(0,n.translationTabGroup)(e,t,i.group_name,i.group_name)})),(0,n.translationMenus)(e,r.admin_menus)};n.translationApp=D;var E=function(e,t){i.each(t,(function(t){var n=x(e,t._id,t.label||t.name);t.label=n,t.name=n}))};n.translationMenus=E;var A=function(e,t){i.each(t,(function(t,r){(0,n.translationApp)(e,r,t)}))};n.translationApps=A;var C=function(e,t,n){var r=a(n),o={};return o[b(t)]=w(e,t,r.label||r.name),o[m(t)]=k(e,t,r.description),i.each(r.admin_menus,(function(t){o[y(t._id)]=x(e,t._id,t.label||t.name)})),o};n.getAppTranslationTemplate=C;var M=function(e,t,n){i.isArray(n)?i.each(n,(function(e){M(e,"",e)})):n&&i.each(i.keys(n),(function(r){var o=t?"".concat(t,".").concat(r):r,s=n[r];"object"==typeof s?i.isArray(s)?i.each(s,(function(e){M(e,o,s)})):M(e,o,s):e[o]=s}))};function O(e){for(var t in e)"object"==typeof e[t]&&M(e,t,e[t]);return e}n.convertTranslationData=O;var T=function(e){var t=a(e),n={};return i.each(t.CustomApplications,(function(e,t){n[b(t)]=e.name,n[m(t)]=e.description,i.each(e.groups,(function(e,r){n[v(t,r)]=e}))})),i.each(t.CustomTabs,(function(e,t){n[_(t)]=e})),i.each(t.CustomLabels,(function(e,t){var r;if("simpleschema"!=t&&i.isObject(e)){var o=O(((r={})[t]=e,r));i.each(o,(function(e,t){i.isObject(e)||(n[p(t)]=e)}))}else n[p(t)]=e})),n};n.convertTranslation=T;var B=function(e){i.each(e,(function(e){var t=(0,n.convertTranslation)(e.data);(0,r.addResourceBundle)(e.lng,u,t,!0,!0)}))};n.addTranslations=B},templates:{"objectTranslation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getObjectMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]="help"===e?t.inlineHelpText||"":t[e]||""})),n}function a(e){return s(["label","description"],e)}function u(e){switch(e.type){case"select":return s(["label","help","options","description"],e);default:return s(["label","help","description"],e)}}function f(e){return s(["label"],e)}function c(e){return s(["label"],e)}function l(e){var t={};return r.each(e,(function(e,n){t[n]=u(e)})),t}function h(e){var t={};return r.each(e,(function(e,n){t[n]=c(e)})),t}function d(e){var t={};return r.each(e,(function(e,n){t[n]=f(e)})),t}function p(e,t){var n={};return r.each(e,(function(e,r){if(e.group){var i=e.group.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");n[i]=t[r].group}})),n}var g=function(e,t,n,s){void 0===s&&(s=!1);var u=o(n);1!=s&&(0,i.translationObject)(e,t,u,!0,s);var f=Object.assign({},a(u));f=Object.assign({},f,{fields:l(u.fields)});var c=p(n.fields,u.fields);r.isEmpty(c)||(f=Object.assign({},f,{groups:c}));var g=d(u.list_views);r.isEmpty(g)||(f=Object.assign({},f,{listviews:g}));var b=h(u.actions);return r.isEmpty(b)||(f=Object.assign({},f,{actions:b})),Object.assign({name:t},f)};n.getObjectMetadataTranslationTemplate=g},"translation.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getAppMetadataTranslationTemplate=void 0;var r=t("underscore"),i=t("../index"),o=t("clone");function s(e,t){var n={};return r.each(e,(function(e){n[e]=t[e]||""})),n}function a(e){var t={groups:{}};return e?(r.each(e,(function(e){var n=e.group_name.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t.groups[n]=e.group_name})),t):{}}var u=function(e){return Object.assign({},s(["name","description"],e),a(e.tab_groups))},f=function(e){var t={};return r.each(e,(function(e,n){t[n]=n})),t},c=function(e){var t={};return r.each(e,(function(e){var n=e.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t[n]=e})),t},l=function(e,t,n){var r,s=o(n);(0,i.translationApp)(e,t,s);var a={},l;return s.tab_items?a=f(s.tab_items):s.tabs&&(a=c(s.tabs)),Object.assign({},{CustomApplications:(r={},r[t]=u(s),r)},{CustomTabs:a})};n.getAppMetadataTranslationTemplate=l}}}},node_modules:{i18next:{"package.json":function e(t,n,e){e.exports={name:"i18next",version:"19.9.2",module:"./dist/esm/i18next.js",main:"./dist/cjs/i18next.js"}},dist:{esm:{"i18next.js":function e(t,n,e){let r,i,o,s,a,u,f,c;e.link("@babel/runtime/helpers/esm/typeof",{default(e){r=e}},0),e.link("@babel/runtime/helpers/esm/objectSpread",{default(e){i=e}},1),e.link("@babel/runtime/helpers/esm/classCallCheck",{default(e){o=e}},2),e.link("@babel/runtime/helpers/esm/createClass",{default(e){s=e}},3),e.link("@babel/runtime/helpers/esm/possibleConstructorReturn",{default(e){a=e}},4),e.link("@babel/runtime/helpers/esm/getPrototypeOf",{default(e){u=e}},5),e.link("@babel/runtime/helpers/esm/assertThisInitialized",{default(e){f=e}},6),e.link("@babel/runtime/helpers/esm/inherits",{default(e){c=e}},7);var l={type:"logger",log:function e(t){this.output("log",t)},warn:function e(t){this.output("warn",t)},error:function e(t){this.output("error",t)},output:function e(t,n){console&&console[t]&&console[t].apply(console,n)}},h,d=new(function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.init(t,n)}return s(e,[{key:"init",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=n.prefix||"i18next:",this.logger=t||l,this.options=n,this.debug=n.debug}},{key:"setDebug",value:function e(t){this.debug=t}},{key:"log",value:function e(){for(var t=arguments.length,n=new Array(t),r=0;r1?n-1:0),i=1;i-1?e.replace(/###/g,"."):e}function i(){return!e||"string"==typeof e}for(var o="string"!=typeof t?[].concat(t):t.split(".");o.length>1;){if(i())return{};var s=r(o.shift());!e[s]&&n&&(e[s]=new n),e=Object.prototype.hasOwnProperty.call(e,s)?e[s]:{}}return i()?{}:{obj:e,k:r(o.shift())}}function y(e,t,n){var r=v(e,t,Object),i,o;r.obj[r.k]=n}function _(e,t,n,r){var i=v(e,t,Object),o=i.obj,s=i.k;o[s]=o[s]||[],r&&(o[s]=o[s].concat(n)),r||o[s].push(n)}function w(e,t){var n=v(e,t),r=n.obj,i=n.k;if(r)return r[i]}function k(e,t,n){var r=w(e,n);return void 0!==r?r:w(t,n)}function j(e,t,n){for(var r in t)"__proto__"!==r&&"constructor"!==r&&(r in e?"string"==typeof e[r]||e[r]instanceof String||"string"==typeof t[r]||t[r]instanceof String?n&&(e[r]=t[r]):j(e[r],t[r],n):e[r]=t[r]);return e}function x(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var S={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};function D(e){return"string"==typeof e?e.replace(/[&<>"'\/]/g,(function(e){return S[e]})):e}var E="undefined"!=typeof window&&window.navigator&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,A=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),n.data=e||{},n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n}return c(t,e),s(t,[{key:"addNamespaces",value:function e(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function e(t){var n=this.options.ns.indexOf(t);n>-1&&this.options.ns.splice(n,1)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==i.keySeparator?i.keySeparator:this.options.keySeparator,s=[t,n];return r&&"string"!=typeof r&&(s=s.concat(r)),r&&"string"==typeof r&&(s=s.concat(o?r.split(o):r)),t.indexOf(".")>-1&&(s=t.split(".")),w(this.data,s)}},{key:"addResource",value:function e(t,n,r,i){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},s=this.options.keySeparator;void 0===s&&(s=".");var a=[t,n];r&&(a=a.concat(s?r.split(s):r)),t.indexOf(".")>-1&&(i=n,n=(a=t.split("."))[1]),this.addNamespaces(n),y(this.data,a,i),o.silent||this.emit("added",t,n,r,i)}},{key:"addResources",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in r)"string"!=typeof r[o]&&"[object Array]"!==Object.prototype.toString.apply(r[o])||this.addResource(t,n,o,r[o],{silent:!0});i.silent||this.emit("added",t,n,r)}},{key:"addResourceBundle",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},u=[t,n];t.indexOf(".")>-1&&(o=r,r=n,n=(u=t.split("."))[1]),this.addNamespaces(n);var f=w(this.data,u)||{};o?j(f,r,s):f=i({},f,r),y(this.data,u,f),a.silent||this.emit("added",t,n,r)}},{key:"removeResourceBundle",value:function e(t,n){this.hasResourceBundle(t,n)&&delete this.data[t][n],this.removeNamespaces(n),this.emit("removed",t,n)}},{key:"hasResourceBundle",value:function e(t,n){return void 0!==this.getResource(t,n)}},{key:"getResourceBundle",value:function e(t,n){return n||(n=this.options.defaultNS),"v1"===this.options.compatibilityAPI?i({},{},this.getResource(t,n)):this.getResource(t,n)}},{key:"getDataByLanguage",value:function e(t){return this.data[t]}},{key:"toJSON",value:function e(){return this.data}}]),t}(p),C={processors:{},addPostProcessor:function e(t){this.processors[t.name]=t},handle:function e(t,n,r,i,o){var s=this;return t.forEach((function(e){s.processors[e]&&(n=s.processors[e].process(n,r,i,o))})),n}},M={},O=function(e){function t(e){var n,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return o(this,t),n=a(this,u(t).call(this)),E&&p.call(f(n)),m(["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],e,f(n)),n.options=r,void 0===n.options.keySeparator&&(n.options.keySeparator="."),n.logger=d.create("translator"),n}return c(t,e),s(t,[{key:"changeLanguage",value:function e(t){t&&(this.language=t)}},{key:"exists",value:function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}},r=this.resolve(t,n);return r&&void 0!==r.res}},{key:"extractFromKey",value:function e(t,n){var r=void 0!==n.nsSeparator?n.nsSeparator:this.options.nsSeparator;void 0===r&&(r=":");var i=void 0!==n.keySeparator?n.keySeparator:this.options.keySeparator,o=n.ns||this.options.defaultNS;if(r&&t.indexOf(r)>-1){var s=t.match(this.interpolator.nestingRegexp);if(s&&s.length>0)return{key:t,namespaces:o};var a=t.split(r);(r!==i||r===i&&this.options.ns.indexOf(a[0])>-1)&&(o=a.shift()),t=a.join(i)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function e(n,o,s){var a=this;if("object"!==r(o)&&this.options.overloadTranslationOptionHandler&&(o=this.options.overloadTranslationOptionHandler(arguments)),o||(o={}),null==n)return"";Array.isArray(n)||(n=[String(n)]);var u=void 0!==o.keySeparator?o.keySeparator:this.options.keySeparator,f=this.extractFromKey(n[n.length-1],o),c=f.key,l=f.namespaces,h=l[l.length-1],d=o.lng||this.language,p=o.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(d&&"cimode"===d.toLowerCase()){if(p){var g=o.nsSeparator||this.options.nsSeparator;return h+g+c}return c}var b=this.resolve(n,o),m=b&&b.res,v=b&&b.usedKey||c,y=b&&b.exactUsedKey||c,_=Object.prototype.toString.apply(m),w=["[object Number]","[object Function]","[object RegExp]"],k=void 0!==o.joinArrays?o.joinArrays:this.options.joinArrays,j=!this.i18nFormat||this.i18nFormat.handleAsObject,x="string"!=typeof m&&"boolean"!=typeof m&&"number"!=typeof m;if(j&&m&&x&&w.indexOf(_)<0&&("string"!=typeof k||"[object Array]"!==_)){if(!o.returnObjects&&!this.options.returnObjects)return this.logger.warn("accessing an object - but returnObjects options is not enabled!"),this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,m,o):"key '".concat(c," (").concat(this.language,")' returned an object instead of string.");if(u){var S="[object Array]"===_,D=S?[]:{},E=S?y:v;for(var A in m)if(Object.prototype.hasOwnProperty.call(m,A)){var C="".concat(E).concat(u).concat(A);D[A]=this.translate(C,i({},o,{joinArrays:!1,ns:l})),D[A]===C&&(D[A]=m[A])}m=D}}else if(j&&"string"==typeof k&&"[object Array]"===_)(m=m.join(k))&&(m=this.extendTranslation(m,n,o,s));else{var M=!1,O=!1,T=void 0!==o.count&&"string"!=typeof o.count,B=t.hasDefaultValue(o),I=T?this.pluralResolver.getSuffix(d,o.count):"",R=o["defaultValue".concat(I)]||o.defaultValue;!this.isValidLookup(m)&&B&&(M=!0,m=R),this.isValidLookup(m)||(O=!0,m=c);var F=B&&R!==m&&this.options.updateMissing;if(O||M||F){if(this.logger.log(F?"updateKey":"missingKey",d,h,c,F?R:m),u){var P=this.resolve(c,i({},o,{keySeparator:!1}));P&&P.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var N=[],L=this.languageUtils.getFallbackCodes(this.options.fallbackLng,o.lng||this.language);if("fallback"===this.options.saveMissingTo&&L&&L[0])for(var z=0;z1&&void 0!==arguments[1]?arguments[1]:{},i,o,s,a,u;return"string"==typeof t&&(t=[t]),t.forEach((function(e){if(!n.isValidLookup(i)){var t=n.extractFromKey(e,r),f=t.key;o=f;var c=t.namespaces;n.options.fallbackNS&&(c=c.concat(n.options.fallbackNS));var l=void 0!==r.count&&"string"!=typeof r.count,h=void 0!==r.context&&"string"==typeof r.context&&""!==r.context,d=r.lngs?r.lngs:n.languageUtils.toResolveHierarchy(r.lng||n.language,r.fallbackLng);c.forEach((function(e){n.isValidLookup(i)||(u=e,!M["".concat(d[0],"-").concat(e)]&&n.utils&&n.utils.hasLoadedNamespace&&!n.utils.hasLoadedNamespace(u)&&(M["".concat(d[0],"-").concat(e)]=!0,n.logger.warn('key "'.concat(o,'" for languages "').concat(d.join(", "),'" won\'t get resolved as namespace "').concat(u,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),d.forEach((function(t){if(!n.isValidLookup(i)){a=t;var o=f,u=[o],c,d;if(n.i18nFormat&&n.i18nFormat.addLookupKeys)n.i18nFormat.addLookupKeys(u,f,t,e,r);else l&&(c=n.pluralResolver.getSuffix(t,r.count)),l&&h&&u.push(o+c),h&&u.push(o+="".concat(n.options.contextSeparator).concat(r.context)),l&&u.push(o+=c);for(;d=u.pop();)n.isValidLookup(i)||(s=d,i=n.getResource(t,e,d,r))}})))}))}})),{res:i,usedKey:o,exactUsedKey:s,usedLng:a,usedNS:u}}},{key:"isValidLookup",value:function e(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function e(t,n,r){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,n,r,i):this.resourceStore.getResource(t,n,r,i)}}],[{key:"hasDefaultValue",value:function e(t){var n="defaultValue";for(var r in t)if(Object.prototype.hasOwnProperty.call(t,r)&&n===r.substring(0,n.length)&&void 0!==t[r])return!0;return!1}}]),t}(p);function T(e){return e.charAt(0).toUpperCase()+e.slice(1)}var B=function(){function e(t){o(this,e),this.options=t,this.whitelist=this.options.supportedLngs||!1,this.supportedLngs=this.options.supportedLngs||!1,this.logger=d.create("languageUtils")}return s(e,[{key:"getScriptPartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return null;var n=t.split("-");return 2===n.length?null:(n.pop(),"x"===n[n.length-1].toLowerCase()?null:this.formatLanguageCode(n.join("-")))}},{key:"getLanguagePartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return t;var n=t.split("-");return this.formatLanguageCode(n[0])}},{key:"formatLanguageCode",value:function e(t){if("string"==typeof t&&t.indexOf("-")>-1){var n=["hans","hant","latn","cyrl","cans","mong","arab"],r=t.split("-");return this.options.lowerCaseLng?r=r.map((function(e){return e.toLowerCase()})):2===r.length?(r[0]=r[0].toLowerCase(),r[1]=r[1].toUpperCase(),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase()))):3===r.length&&(r[0]=r[0].toLowerCase(),2===r[1].length&&(r[1]=r[1].toUpperCase()),"sgn"!==r[0]&&2===r[2].length&&(r[2]=r[2].toUpperCase()),n.indexOf(r[1].toLowerCase())>-1&&(r[1]=T(r[1].toLowerCase())),n.indexOf(r[2].toLowerCase())>-1&&(r[2]=T(r[2].toLowerCase()))),r.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isWhitelisted",value:function e(t){return this.logger.deprecate("languageUtils.isWhitelisted",'function "isWhitelisted" will be renamed to "isSupportedCode" in the next major - please make sure to rename it\'s usage asap.'),this.isSupportedCode(t)}},{key:"isSupportedCode",value:function e(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function e(t){var n=this,r;return t?(t.forEach((function(e){if(!r){var t=n.formatLanguageCode(e);n.options.supportedLngs&&!n.isSupportedCode(t)||(r=t)}})),!r&&this.options.supportedLngs&&t.forEach((function(e){if(!r){var t=n.getLanguagePartFromCode(e);if(n.isSupportedCode(t))return r=t;r=n.options.supportedLngs.find((function(e){if(0===e.indexOf(t))return e}))}})),r||(r=this.getFallbackCodes(this.options.fallbackLng)[0]),r):null}},{key:"getFallbackCodes",value:function e(t,n){if(!t)return[];if("function"==typeof t&&(t=t(n)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!n)return t.default||[];var r=t[n];return r||(r=t[this.getScriptPartFromCode(n)]),r||(r=t[this.formatLanguageCode(n)]),r||(r=t[this.getLanguagePartFromCode(n)]),r||(r=t.default),r||[]}},{key:"toResolveHierarchy",value:function e(t,n){var r=this,i=this.getFallbackCodes(n||this.options.fallbackLng||[],t),o=[],s=function e(t){t&&(r.isSupportedCode(t)?o.push(t):r.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&s(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&s(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&s(this.getLanguagePartFromCode(t))):"string"==typeof t&&s(this.formatLanguageCode(t)),i.forEach((function(e){o.indexOf(e)<0&&s(r.formatLanguageCode(e))})),o}}]),e}(),I=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","kk","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],R={1:function e(t){return Number(t>1)},2:function e(t){return Number(1!=t)},3:function e(t){return 0},4:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function e(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function e(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function e(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function e(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function e(t){return Number(t>=2)},10:function e(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function e(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function e(t){return Number(t%10!=1||t%100==11)},13:function e(t){return Number(0!==t)},14:function e(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function e(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function e(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function e(t){return Number(0==t?0:1==t?1:2)},19:function e(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function e(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function e(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function e(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}};function F(){var e={};return I.forEach((function(t){t.lngs.forEach((function(n){e[n]={numbers:t.nr,plurals:R[t.fc]}}))})),e}var P=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};o(this,e),this.languageUtils=t,this.options=n,this.logger=d.create("pluralResolver"),this.rules=F()}return s(e,[{key:"addRule",value:function e(t,n){this.rules[t]=n}},{key:"getRule",value:function e(t){return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function e(t){var n=this.getRule(t);return n&&n.numbers.length>1}},{key:"getPluralFormsOfKey",value:function e(t,n){return this.getSuffixes(t).map((function(e){return n+e}))}},{key:"getSuffixes",value:function e(t){var n=this,r=this.getRule(t);return r?r.numbers.map((function(e){return n.getSuffix(t,e)})):[]}},{key:"getSuffix",value:function e(t,n){var r=this,i=this.getRule(t);if(i){var o=i.noAbs?i.plurals(n):i.plurals(Math.abs(n)),s=i.numbers[o];this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]&&(2===s?s="plural":1===s&&(s=""));var a=function e(){return r.options.prepend&&s.toString()?r.options.prepend+s.toString():s.toString()};return"v1"===this.options.compatibilityJSON?1===s?"":"number"==typeof s?"_plural_".concat(s.toString()):a():"v2"===this.options.compatibilityJSON?a():this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]?a():this.options.prepend&&o.toString()?this.options.prepend+o.toString():o.toString()}return this.logger.warn("no plural rule found for: ".concat(t)),""}}]),e}(),N=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};o(this,e),this.logger=d.create("interpolator"),this.options=t,this.format=t.interpolation&&t.interpolation.format||function(e){return e},this.init(t)}return s(e,[{key:"init",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var n=t.interpolation;this.escape=void 0!==n.escape?n.escape:D,this.escapeValue=void 0===n.escapeValue||n.escapeValue,this.useRawValueToEscape=void 0!==n.useRawValueToEscape&&n.useRawValueToEscape,this.prefix=n.prefix?x(n.prefix):n.prefixEscaped||"{{",this.suffix=n.suffix?x(n.suffix):n.suffixEscaped||"}}",this.formatSeparator=n.formatSeparator?n.formatSeparator:n.formatSeparator||",",this.unescapePrefix=n.unescapeSuffix?"":n.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":n.unescapeSuffix||"",this.nestingPrefix=n.nestingPrefix?x(n.nestingPrefix):n.nestingPrefixEscaped||x("$t("),this.nestingSuffix=n.nestingSuffix?x(n.nestingSuffix):n.nestingSuffixEscaped||x(")"),this.nestingOptionsSeparator=n.nestingOptionsSeparator?n.nestingOptionsSeparator:n.nestingOptionsSeparator||",",this.maxReplaces=n.maxReplaces?n.maxReplaces:1e3,this.alwaysFormat=void 0!==n.alwaysFormat&&n.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function e(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function e(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var n="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(n,"g");var r="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(r,"g")}},{key:"interpolate",value:function e(t,n,r,i){var o=this,s,a,u,f=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function c(e){return e.replace(/\$/g,"$$$$")}var l=function e(t){if(t.indexOf(o.formatSeparator)<0){var s=k(n,f,t);return o.alwaysFormat?o.format(s,void 0,r):s}var a=t.split(o.formatSeparator),u=a.shift().trim(),c=a.join(o.formatSeparator).trim();return o.format(k(n,f,u),c,r,i)};this.resetRegExp();var h=i&&i.missingInterpolationHandler||this.options.missingInterpolationHandler,d=i&&i.interpolation&&i.interpolation.skipOnVariables||this.options.interpolation.skipOnVariables,p;return[{regex:this.regexpUnescape,safeValue:function e(t){return c(t)}},{regex:this.regexp,safeValue:function e(t){return o.escapeValue?c(o.escape(t)):c(t)}}].forEach((function(e){for(u=0;s=e.regex.exec(t);){if(void 0===(a=l(s[1].trim())))if("function"==typeof h){var n=h(t,s,i);a="string"==typeof n?n:""}else{if(d){a=s[0];continue}o.logger.warn("missed to pass in variable ".concat(s[1]," for interpolating ").concat(t)),a=""}else"string"==typeof a||o.useRawValueToEscape||(a=b(a));if(t=t.replace(s[0],e.safeValue(a)),e.regex.lastIndex=0,++u>=o.maxReplaces)break}})),t}},{key:"nest",value:function e(t,n){var r=this,o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},s,a,u=i({},o);function f(e,t){var n=this.nestingOptionsSeparator;if(e.indexOf(n)<0)return e;var r=e.split(new RegExp("".concat(n,"[ ]*{"))),o="{".concat(r[1]);e=r[0],o=(o=this.interpolate(o,u)).replace(/'/g,'"');try{u=JSON.parse(o),t&&(u=i({},t,u))}catch(s){return this.logger.warn("failed parsing options string in nesting for key ".concat(e),s),"".concat(e).concat(n).concat(o)}return delete u.defaultValue,e}for(u.applyPostProcessor=!1,delete u.defaultValue;s=this.nestingRegexp.exec(t);){var c=[],l=!1;if(s[0].includes(this.formatSeparator)&&!/{.*}/.test(s[1])){var h=s[1].split(this.formatSeparator).map((function(e){return e.trim()}));s[1]=h.shift(),c=h,l=!0}if((a=n(f.call(this,s[1].trim(),u),u))&&s[0]===t&&"string"!=typeof a)return a;"string"!=typeof a&&(a=b(a)),a||(this.logger.warn("missed to resolve ".concat(s[1]," for nesting ").concat(t)),a=""),l&&(a=c.reduce((function(e,t){return r.format(e,t,o.lng,o)}),a.trim())),t=t.replace(s[0],a),this.regexp.lastIndex=0}return t}}]),e}();function L(e,t){for(var n=e.indexOf(t);-1!==n;)e.splice(n,1),n=e.indexOf(t)}var z=function(e){function t(e,n,r){var i,s=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return o(this,t),i=a(this,u(t).call(this)),E&&p.call(f(i)),i.backend=e,i.store=n,i.services=r,i.languageUtils=r.languageUtils,i.options=s,i.logger=d.create("backendConnector"),i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(r,s.backend,s),i}return c(t,e),s(t,[{key:"queueLoad",value:function e(t,n,r,i){var o=this,s=[],a=[],u=[],f=[];return t.forEach((function(e){var t=!0;n.forEach((function(n){var i="".concat(e,"|").concat(n);!r.reload&&o.store.hasResourceBundle(e,n)?o.state[i]=2:o.state[i]<0||(1===o.state[i]?a.indexOf(i)<0&&a.push(i):(o.state[i]=1,t=!1,a.indexOf(i)<0&&a.push(i),s.indexOf(i)<0&&s.push(i),f.indexOf(n)<0&&f.push(n)))})),t||u.push(e)})),(s.length||a.length)&&this.queue.push({pending:a,loaded:{},errors:[],callback:i}),{toLoad:s,pending:a,toLoadLanguages:u,toLoadNamespaces:f}}},{key:"loaded",value:function e(t,n,r){var i=t.split("|"),o=i[0],s=i[1];n&&this.emit("failedLoading",o,s,n),r&&this.store.addResourceBundle(o,s,r),this.state[t]=n?-1:2;var e={};this.queue.forEach((function(r){_(r.loaded,[o],s),L(r.pending,t),n&&r.errors.push(n),0!==r.pending.length||r.done||(Object.keys(r.loaded).forEach((function(t){e[t]||(e[t]=[]),r.loaded[t].length&&r.loaded[t].forEach((function(n){e[t].indexOf(n)<0&&e[t].push(n)}))})),r.done=!0,r.errors.length?r.callback(r.errors):r.callback())})),this.emit("loaded",e),this.queue=this.queue.filter((function(e){return!e.done}))}},{key:"read",value:function e(t,n,r){var i=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,s=arguments.length>4&&void 0!==arguments[4]?arguments[4]:350,a=arguments.length>5?arguments[5]:void 0;return t.length?this.backend[r](t,n,(function(e,u){e&&u&&o<5?setTimeout((function(){i.read.call(i,t,n,r,o+1,2*s,a)}),s):a(e,u)})):a(null,{})}},{key:"prepareLoading",value:function e(t,n){var r=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof n&&(n=[n]);var s=this.queueLoad(t,n,i,o);if(!s.toLoad.length)return s.pending.length||o(),null;s.toLoad.forEach((function(e){r.loadOne(e)}))}},{key:"load",value:function e(t,n,r){this.prepareLoading(t,n,{},r)}},{key:"reload",value:function e(t,n,r){this.prepareLoading(t,n,{reload:!0},r)}},{key:"loadOne",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=t.split("|"),o=i[0],s=i[1];this.read(o,s,"read",void 0,void 0,(function(e,i){e&&n.logger.warn("".concat(r,"loading namespace ").concat(s," for language ").concat(o," failed"),e),!e&&i&&n.logger.log("".concat(r,"loaded namespace ").concat(s," for language ").concat(o),i),n.loaded(t,e,i)}))}},{key:"saveMissing",value:function e(t,n,r,o,s){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(n)?this.logger.warn('did not save key "'.concat(r,'" as the namespace "').concat(n,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=r&&""!==r&&(this.backend&&this.backend.create&&this.backend.create(t,n,r,o,null,i({},a,{isUpdate:s})),t&&t[0]&&this.store.addResource(t[0],n,r,o))}}]),t}(p);function U(){return{debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,whitelist:!1,nonExplicitWhitelist:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function e(t){var n={};if("object"===r(t[1])&&(n=t[1]),"string"==typeof t[1]&&(n.defaultValue=t[1]),"string"==typeof t[2]&&(n.tDescription=t[2]),"object"===r(t[2])||"object"===r(t[3])){var i=t[3]||t[2];Object.keys(i).forEach((function(e){n[e]=i[e]}))}return n},interpolation:{escapeValue:!0,format:function e(t,n,r,i){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!1}}}function q(e){return"string"==typeof e.ns&&(e.ns=[e.ns]),"string"==typeof e.fallbackLng&&(e.fallbackLng=[e.fallbackLng]),"string"==typeof e.fallbackNS&&(e.fallbackNS=[e.fallbackNS]),e.whitelist&&(e.whitelist&&e.whitelist.indexOf("cimode")<0&&(e.whitelist=e.whitelist.concat(["cimode"])),e.supportedLngs=e.whitelist),e.nonExplicitWhitelist&&(e.nonExplicitSupportedLngs=e.nonExplicitWhitelist),e.supportedLngs&&e.supportedLngs.indexOf("cimode")<0&&(e.supportedLngs=e.supportedLngs.concat(["cimode"])),e}function $(){}var W,H=new(function(e){function t(){var e,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;if(o(this,t),e=a(this,u(t).call(this)),E&&p.call(f(e)),e.options=q(n),e.services={},e.logger=d,e.modules={external:[]},r&&!e.isInitialized&&!n.isClone){if(!e.options.initImmediate)return e.init(n,r),a(e,f(e));setTimeout((function(){e.init(n,r)}),0)}return e}return c(t,e),s(t,[{key:"init",value:function e(){var t=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;function o(e){return e?"function"==typeof e?new e:e:null}if("function"==typeof n&&(r=n,n={}),n.whitelist&&!n.supportedLngs&&this.logger.deprecate("whitelist",'option "whitelist" will be renamed to "supportedLngs" in the next major - please make sure to rename this option asap.'),n.nonExplicitWhitelist&&!n.nonExplicitSupportedLngs&&this.logger.deprecate("whitelist",'options "nonExplicitWhitelist" will be renamed to "nonExplicitSupportedLngs" in the next major - please make sure to rename this option asap.'),this.options=i({},U(),this.options,q(n)),this.format=this.options.interpolation.format,r||(r=$),!this.options.isClone){this.modules.logger?d.init(o(this.modules.logger),this.options):d.init(null,this.options);var s=new B(this.options);this.store=new A(this.options.resources,this.options);var a=this.services;a.logger=d,a.resourceStore=this.store,a.languageUtils=s,a.pluralResolver=new P(s,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),a.interpolator=new N(this.options),a.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},a.backendConnector=new z(o(this.modules.backend),a.resourceStore,a,this.options),a.backendConnector.on("*",(function(e){for(var n=arguments.length,r=new Array(n>1?n-1:0),i=1;i1?n-1:0),i=1;i0&&"dev"!==u[0]&&(this.options.lng=u[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined");var f=["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"];f.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments)}}));var c=["addResource","addResources","addResourceBundle","removeResourceBundle"];c.forEach((function(e){t[e]=function(){var n;return(n=t.store)[e].apply(n,arguments),t}}));var l=g(),h=function e(){var n=function e(n,i){t.isInitialized&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),l.resolve(i),r(n,i)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return n(null,t.t.bind(t));t.changeLanguage(t.options.lng,n)};return this.options.resources||!this.options.initImmediate?h():setTimeout(h,0),l}},{key:"loadResources",value:function e(t){var n=this,r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,i=r,o="string"==typeof t?t:this.language;if("function"==typeof t&&(i=t),!this.options.resources||this.options.partialBundledLanguages){if(o&&"cimode"===o.toLowerCase())return i();var s=[],a=function e(t){var r;t&&n.services.languageUtils.toResolveHierarchy(t).forEach((function(e){s.indexOf(e)<0&&s.push(e)}))};if(o)a(o);else{var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.forEach((function(e){return a(e)}))}this.options.preload&&this.options.preload.forEach((function(e){return a(e)})),this.services.backendConnector.load(s,this.options.ns,i)}else i(null)}},{key:"reloadResources",value:function e(t,n,r){var i=g();return t||(t=this.languages),n||(n=this.options.ns),r||(r=$),this.services.backendConnector.reload(t,n,(function(e){i.resolve(),r(e)})),i}},{key:"use",value:function e(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&C.addPostProcessor(t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"changeLanguage",value:function e(t,n){var r=this;this.isLanguageChangingTo=t;var i=g();this.emit("languageChanging",t);var o=function e(t,o){o?(r.language=o,r.languages=r.services.languageUtils.toResolveHierarchy(o),r.translator.changeLanguage(o),r.isLanguageChangingTo=void 0,r.emit("languageChanged",o),r.logger.log("languageChanged",o)):r.isLanguageChangingTo=void 0,i.resolve((function(){return r.t.apply(r,arguments)})),n&&n(t,(function(){return r.t.apply(r,arguments)}))},s=function e(t){var n="string"==typeof t?t:r.services.languageUtils.getBestMatchFromCodes(t);n&&(r.language||(r.language=n,r.languages=r.services.languageUtils.toResolveHierarchy(n)),r.translator.language||r.translator.changeLanguage(n),r.services.languageDetector&&r.services.languageDetector.cacheUserLanguage(n)),r.loadResources(n,(function(e){o(e,n)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(s):s(t):s(this.services.languageDetector.detect()),i}},{key:"getFixedT",value:function e(t,n){var o=this,s=function e(t,n){var s;if("object"!==r(n)){for(var a=arguments.length,u=new Array(a>2?a-2:0),f=2;f1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var i=this.languages[0],o=!!this.options&&this.options.fallbackLng,s=this.languages[this.languages.length-1];if("cimode"===i.toLowerCase())return!0;var a=function e(t,r){var i=n.services.backendConnector.state["".concat(t,"|").concat(r)];return-1===i||2===i};if(r.precheck){var u=r.precheck(this,a);if(void 0!==u)return u}return!!this.hasResourceBundle(i,t)||(!this.services.backendConnector.backend||!(!a(i,t)||o&&!a(s,t)))}},{key:"loadNamespaces",value:function e(t,n){var r=this,i=g();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(e){r.options.ns.indexOf(e)<0&&r.options.ns.push(e)})),this.loadResources((function(e){i.resolve(),n&&n(e)})),i):(n&&n(),Promise.resolve())}},{key:"loadLanguages",value:function e(t,n){var r=g();"string"==typeof t&&(t=[t]);var i=this.options.preload||[],o=t.filter((function(e){return i.indexOf(e)<0}));return o.length?(this.options.preload=i.concat(o),this.loadResources((function(e){r.resolve(),n&&n(e)})),r):(n&&n(),Promise.resolve())}},{key:"dir",value:function e(t){return t||(t=this.languages&&this.languages.length>0?this.languages[0]:this.language),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>=0?"rtl":"ltr":"rtl";var n}},{key:"createInstance",value:function e(){var n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},r=arguments.length>1?arguments[1]:void 0;return new t(n,r)}},{key:"cloneInstance",value:function e(){var n=this,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:$,s=i({},this.options,r,{isClone:!0}),a=new t(s),u=["store","services","language"];return u.forEach((function(e){a[e]=n[e]})),a.services=i({},this.services),a.services.utils={hasLoadedNamespace:a.hasLoadedNamespace.bind(a)},a.translator=new O(a.services,a.options),a.translator.on("*",(function(e){for(var t=arguments.length,n=new Array(t>1?t-1:0),r=1;rr,root:()=>i,ArrayProto:()=>o,ObjProto:()=>s,SymbolProto:()=>a,push:()=>u,slice:()=>f,toString:()=>c,hasOwnProperty:()=>l,supportsArrayBuffer:()=>h,supportsDataView:()=>d,nativeIsArray:()=>p,nativeKeys:()=>g,nativeCreate:()=>b,nativeIsView:()=>m,_isNaN:()=>v,_isFinite:()=>y,hasEnumBug:()=>_,nonEnumerableProps:()=>w,MAX_ARRAY_INDEX:()=>k});var r="1.13.4",i="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||Function("return this")()||{},o=Array.prototype,s=Object.prototype,a="undefined"!=typeof Symbol?Symbol.prototype:null,u=o.push,f=o.slice,c=s.toString,l=s.hasOwnProperty,h="undefined"!=typeof ArrayBuffer,d="undefined"!=typeof DataView,p=Array.isArray,g=Object.keys,b=Object.create,m=h&&ArrayBuffer.isView,v=isNaN,y=isFinite,_=!{toString:null}.propertyIsEnumerable("toString"),w=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"],k=Math.pow(2,53)-1},"restArguments.js":function e(t,n,e){function r(e,t){return t=null==t?e.length-1:+t,function(){for(var n=Math.max(arguments.length-t,0),r=Array(n),i=0;ir})},"isObject.js":function e(t,n,e){function r(e){var t=typeof e;return"function"===t||"object"===t&&!!e}e.export({default:()=>r})},"isNull.js":function e(t,n,e){function r(e){return null===e}e.export({default:()=>r})},"isUndefined.js":function e(t,n,e){function r(e){return void 0===e}e.export({default:()=>r})},"isBoolean.js":function e(t,n,e){let r;function i(e){return!0===e||!1===e||"[object Boolean]"===r.call(e)}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isElement.js":function e(t,n,e){function r(e){return!(!e||1!==e.nodeType)}e.export({default:()=>r})},"isString.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("String"))},"_tagTester.js":function e(t,n,e){let r;function i(e){var t="[object "+e+"]";return function(e){return r.call(e)===t}}e.export({default:()=>i}),e.link("./_setup.js",{toString(e){r=e}},0)},"isNumber.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Number"))},"isDate.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Date"))},"isRegExp.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("RegExp"))},"isError.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Error"))},"isSymbol.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Symbol"))},"isArrayBuffer.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("ArrayBuffer"))},"isDataView.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isArrayBuffer.js",{default(e){o=e}},2),e.link("./_stringTagBug.js",{hasStringTagBug(e){s=e}},3);var a=r("DataView");function u(e){return null!=e&&i(e.getInt8)&&o(e.buffer)}e.exportDefault(s?u:a)},"isFunction.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_setup.js",{root(e){i=e}},1);var o=r("Function"),s=i.document&&i.document.childNodes;"function"!=typeof/./&&"object"!=typeof Int8Array&&"function"!=typeof s&&(o=function(e){return"function"==typeof e||!1}),e.exportDefault(o)},"_stringTagBug.js":function e(t,n,e){let r,i;e.export({hasStringTagBug:()=>o,isIE11:()=>s}),e.link("./_setup.js",{supportsDataView(e){r=e}},0),e.link("./_hasObjectTag.js",{default(e){i=e}},1);var o=r&&i(new DataView(new ArrayBuffer(8))),s="undefined"!=typeof Map&&i(new Map)},"_hasObjectTag.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("Object"))},"isArray.js":function e(t,n,e){let r,i;e.link("./_setup.js",{nativeIsArray(e){r=e}},0),e.link("./_tagTester.js",{default(e){i=e}},1),e.exportDefault(r||i("Array"))},"isArguments.js":function e(t,n,e){let r,i;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1);var o=r("Arguments");!function(){o(arguments)||(o=function(e){return i(e,"callee")})}(),e.exportDefault(o)},"_has.js":function e(t,n,e){let r;function i(e,t){return null!=e&&r.call(e,t)}e.export({default:()=>i}),e.link("./_setup.js",{hasOwnProperty(e){r=e}},0)},"isFinite.js":function e(t,n,e){let r,i;function o(e){return!i(e)&&r(e)&&!isNaN(parseFloat(e))}e.export({default:()=>o}),e.link("./_setup.js",{_isFinite(e){r=e}},0),e.link("./isSymbol.js",{default(e){i=e}},1)},"isNaN.js":function e(t,n,e){let r,i;function o(e){return i(e)&&r(e)}e.export({default:()=>o}),e.link("./_setup.js",{_isNaN(e){r=e}},0),e.link("./isNumber.js",{default(e){i=e}},1)},"isTypedArray.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./_setup.js",{supportsArrayBuffer(e){r=e},nativeIsView(e){i=e},toString(e){o=e}},0),e.link("./isDataView.js",{default(e){s=e}},1),e.link("./constant.js",{default(e){a=e}},2),e.link("./_isBufferLike.js",{default(e){u=e}},3);var f=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;function c(e){return i?i(e)&&!s(e):u(e)&&f.test(o.call(e))}e.exportDefault(r?c:a(!1))},"constant.js":function e(t,n,e){function r(e){return function(){return e}}e.export({default:()=>r})},"_isBufferLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getByteLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createSizePropertyCheck.js":function e(t,n,e){let r;function i(e){return function(t){var n=e(t);return"number"==typeof n&&n>=0&&n<=r}}e.export({default:()=>i}),e.link("./_setup.js",{MAX_ARRAY_INDEX(e){r=e}},0)},"_getByteLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("byteLength"))},"_shallowProperty.js":function e(t,n,e){function r(e){return function(t){return null==t?void 0:t[e]}}e.export({default:()=>r})},"isEmpty.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(null==e)return!0;var t=r(e);return"number"==typeof t&&(i(e)||o(e)||s(e))?0===t:0===r(a(e))}e.export({default:()=>u}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3),e.link("./keys.js",{default(e){a=e}},4)},"_getLength.js":function e(t,n,e){let r;e.link("./_shallowProperty.js",{default(e){r=e}},0),e.exportDefault(r("length"))},"keys.js":function e(t,n,e){let r,i,o,s,a;function u(e){if(!r(e))return[];if(i)return i(e);var t=[];for(var n in e)s(e,n)&&t.push(n);return o&&a(e,t),t}e.export({default:()=>u}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeKeys(e){i=e},hasEnumBug(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2),e.link("./_collectNonEnumProps.js",{default(e){a=e}},3)},"_collectNonEnumProps.js":function e(t,n,e){let r,i,o,s;function a(e){for(var t={},n=e.length,r=0;ru}),e.link("./_setup.js",{nonEnumerableProps(e){r=e},ObjProto(e){i=e}},0),e.link("./isFunction.js",{default(e){o=e}},1),e.link("./_has.js",{default(e){s=e}},2)},"isMatch.js":function e(t,n,e){let r;function i(e,t){var n=r(t),i=n.length;if(null==e)return!i;for(var o=Object(e),s=0;si}),e.link("./keys.js",{default(e){r=e}},0)},"isEqual.js":function e(t,n,e){let r,i,o,s,a,u,f,c,l,h,d;e.export({default:()=>m}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_setup.js",{toString(e){i=e},SymbolProto(e){o=e}},1),e.link("./_getByteLength.js",{default(e){s=e}},2),e.link("./isTypedArray.js",{default(e){a=e}},3),e.link("./isFunction.js",{default(e){u=e}},4),e.link("./_stringTagBug.js",{hasStringTagBug(e){f=e}},5),e.link("./isDataView.js",{default(e){c=e}},6),e.link("./keys.js",{default(e){l=e}},7),e.link("./_has.js",{default(e){h=e}},8),e.link("./_toBufferView.js",{default(e){d=e}},9);var p="[object DataView]";function g(e,t,n,r){if(e===t)return 0!==e||1/e==1/t;if(null==e||null==t)return!1;if(e!=e)return t!=t;var i=typeof e;return("function"===i||"object"===i||"object"==typeof t)&&b(e,t,n,r)}function b(e,t,n,m){e instanceof r&&(e=e._wrapped),t instanceof r&&(t=t._wrapped);var v=i.call(e);if(v!==i.call(t))return!1;if(f&&"[object Object]"==v&&c(e)){if(!c(t))return!1;v=p}switch(v){case"[object RegExp]":case"[object String]":return""+e==""+t;case"[object Number]":return+e!=+e?+t!=+t:0==+e?1/+e==1/t:+e==+t;case"[object Date]":case"[object Boolean]":return+e==+t;case"[object Symbol]":return o.valueOf.call(e)===o.valueOf.call(t);case"[object ArrayBuffer]":case p:return b(d(e),d(t),n,m)}var y="[object Array]"===v;if(!y&&a(e)){var _;if(s(e)!==s(t))return!1;if(e.buffer===t.buffer&&e.byteOffset===t.byteOffset)return!0;y=!0}if(!y){if("object"!=typeof e||"object"!=typeof t)return!1;var w=e.constructor,k=t.constructor;if(w!==k&&!(u(w)&&w instanceof w&&u(k)&&k instanceof k)&&"constructor"in e&&"constructor"in t)return!1}m=m||[];for(var j=(n=n||[]).length;j--;)if(n[j]===e)return m[j]===t;if(n.push(e),m.push(t),y){if((j=e.length)!==t.length)return!1;for(;j--;)if(!g(e[j],t[j],n,m))return!1}else{var x=l(e),S;if(j=x.length,l(t).length!==j)return!1;for(;j--;)if(S=x[j],!h(t,S)||!g(e[S],t[S],n,m))return!1}return n.pop(),m.pop(),!0}function m(e,t){return g(e,t)}},"underscore.js":function e(t,n,e){let r;function i(e){return e instanceof i?e:this instanceof i?void(this._wrapped=e):new i(e)}e.export({default:()=>i}),e.link("./_setup.js",{VERSION(e){r=e}},0),i.VERSION=r,i.prototype.value=function(){return this._wrapped},i.prototype.valueOf=i.prototype.toJSON=i.prototype.value,i.prototype.toString=function(){return String(this._wrapped)}},"_toBufferView.js":function e(t,n,e){let r;function i(e){return new Uint8Array(e.buffer||e,e.byteOffset||0,r(e))}e.export({default:()=>i}),e.link("./_getByteLength.js",{default(e){r=e}},0)},"isMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},mapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Map"))},"_methodFingerprint.js":function e(t,n,e){let r,i,o;function s(e){var t=r(e);return function(n){if(null==n)return!1;var s=o(n);if(r(s))return!1;for(var u=0;us,mapMethods:()=>l,weakMapMethods:()=>h,setMethods:()=>d}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./allKeys.js",{default(e){o=e}},2);var a="forEach",u="has",f=["clear","delete"],c=["get","has","set"],l=f.concat(a,c),h=f.concat(c),d=["add"].concat(f,a,"has")},"allKeys.js":function e(t,n,e){let r,i,o;function s(e){if(!r(e))return[];var t=[];for(var n in e)t.push(n);return i&&o(e,t),t}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{hasEnumBug(e){i=e}},1),e.link("./_collectNonEnumProps.js",{default(e){o=e}},2)},"isWeakMap.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},weakMapMethods(e){s=e}},2),e.exportDefault(i?o(s):r("WeakMap"))},"isSet.js":function e(t,n,e){let r,i,o,s;e.link("./_tagTester.js",{default(e){r=e}},0),e.link("./_stringTagBug.js",{isIE11(e){i=e}},1),e.link("./_methodFingerprint.js",{ie11fingerprint(e){o=e},setMethods(e){s=e}},2),e.exportDefault(i?o(s):r("Set"))},"isWeakSet.js":function e(t,n,e){let r;e.link("./_tagTester.js",{default(e){r=e}},0),e.exportDefault(r("WeakSet"))},"values.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"pairs.js":function e(t,n,e){let r;function i(e){for(var t=r(e),n=t.length,i=Array(n),o=0;oi}),e.link("./keys.js",{default(e){r=e}},0)},"invert.js":function e(t,n,e){let r;function i(e){for(var t={},n=r(e),i=0,o=n.length;ii}),e.link("./keys.js",{default(e){r=e}},0)},"functions.js":function e(t,n,e){let r;function i(e){var t=[];for(var n in e)r(e[n])&&t.push(n);return t.sort()}e.export({default:()=>i}),e.link("./isFunction.js",{default(e){r=e}},0)},"extend.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createAssigner.js":function e(t,n,e){function r(e,t){return function(n){var r=arguments.length;if(t&&(n=Object(n)),r<2||null==n)return n;for(var i=1;ir})},"extendOwn.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.exportDefault(r(i))},"defaults.js":function e(t,n,e){let r,i;e.link("./_createAssigner.js",{default(e){r=e}},0),e.link("./allKeys.js",{default(e){i=e}},1),e.exportDefault(r(i,!0))},"create.js":function e(t,n,e){let r,i;function o(e,t){var n=r(e);return t&&i(n,t),n}e.export({default:()=>o}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./extendOwn.js",{default(e){i=e}},1)},"_baseCreate.js":function e(t,n,e){let r,i;function o(){return function(){}}function s(e){if(!r(e))return{};if(i)return i(e);var t=function(){};t.prototype=e;var n=new t;return t.prototype=null,n}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./_setup.js",{nativeCreate(e){i=e}},1)},"clone.js":function e(t,n,e){let r,i,o;function s(e){return r(e)?i(e)?e.slice():o({},e):e}e.export({default:()=>s}),e.link("./isObject.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),e.link("./extend.js",{default(e){o=e}},2)},"tap.js":function e(t,n,e){function r(e,t){return t(e),e}e.export({default:()=>r})},"get.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=i(e,r(t));return o(s)?n:s}e.export({default:()=>s}),e.link("./_toPath.js",{default(e){r=e}},0),e.link("./_deepGet.js",{default(e){i=e}},1),e.link("./isUndefined.js",{default(e){o=e}},2)},"_toPath.js":function e(t,n,e){let r;function i(e){return r.toPath(e)}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./toPath.js")},"toPath.js":function e(t,n,e){let r,i;function o(e){return i(e)?e:[e]}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./isArray.js",{default(e){i=e}},1),r.toPath=o},"_deepGet.js":function e(t,n,e){function r(e,t){for(var n=t.length,r=0;rr})},"has.js":function e(t,n,e){let r,i;function o(e,t){for(var n=(t=i(t)).length,o=0;oo}),e.link("./_has.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"mapObject.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s=o.length,a={},u=0;uo}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"_cb.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r.iteratee!==o?r.iteratee(e,t):i(e,t,n)}e.export({default:()=>s}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),e.link("./iteratee.js",{default(e){o=e}},2)},"_baseIteratee.js":function e(t,n,e){let r,i,o,s,a,u,f;function c(e,t,n){return null==e?r:i(e)?f(e,t,n):o(e)&&!s(e)?a(e):u(e)}e.export({default:()=>c}),e.link("./identity.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./isObject.js",{default(e){o=e}},2),e.link("./isArray.js",{default(e){s=e}},3),e.link("./matcher.js",{default(e){a=e}},4),e.link("./property.js",{default(e){u=e}},5),e.link("./_optimizeCb.js",{default(e){f=e}},6)},"identity.js":function e(t,n,e){function r(e){return e}e.export({default:()=>r})},"matcher.js":function e(t,n,e){let r,i;function o(e){return e=r({},e),function(t){return i(t,e)}}e.export({default:()=>o}),e.link("./extendOwn.js",{default(e){r=e}},0),e.link("./isMatch.js",{default(e){i=e}},1)},"property.js":function e(t,n,e){let r,i;function o(e){return e=i(e),function(t){return r(t,e)}}e.export({default:()=>o}),e.link("./_deepGet.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"_optimizeCb.js":function e(t,n,e){function r(e,t,n){if(void 0===t)return e;switch(null==n?3:n){case 1:return function(n){return e.call(t,n)};case 3:return function(n,r,i){return e.call(t,n,r,i)};case 4:return function(n,r,i,o){return e.call(t,n,r,i,o)}}return function(){return e.apply(t,arguments)}}e.export({default:()=>r})},"iteratee.js":function e(t,n,e){let r,i;function o(e,t){return i(e,t,1/0)}e.export({default:()=>o}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./_baseIteratee.js",{default(e){i=e}},1),r.iteratee=o},"noop.js":function e(t,n,e){function r(){}e.export({default:()=>r})},"propertyOf.js":function e(t,n,e){let r,i;function o(e){return null==e?r:function(t){return i(e,t)}}e.export({default:()=>o}),e.link("./noop.js",{default(e){r=e}},0),e.link("./get.js",{default(e){i=e}},1)},"times.js":function e(t,n,e){let r;function i(e,t,n){var i=Array(Math.max(0,e));t=r(t,n,1);for(var o=0;oi}),e.link("./_optimizeCb.js",{default(e){r=e}},0)},"random.js":function e(t,n,e){function r(e,t){return null==t&&(t=e,e=0),e+Math.floor(Math.random()*(t-e+1))}e.export({default:()=>r})},"now.js":function e(t,n,e){e.exportDefault(Date.now||function(){return(new Date).getTime()})},"escape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_createEscaper.js":function e(t,n,e){let r;function i(e){var t=function(t){return e[t]},n="(?:"+r(e).join("|")+")",i=RegExp(n),o=RegExp(n,"g");return function(e){return e=null==e?"":""+e,i.test(e)?e.replace(o,t):e}}e.export({default:()=>i}),e.link("./keys.js",{default(e){r=e}},0)},"_escapeMap.js":function e(t,n,e){e.exportDefault({"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"})},"unescape.js":function e(t,n,e){let r,i;e.link("./_createEscaper.js",{default(e){r=e}},0),e.link("./_unescapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"_unescapeMap.js":function e(t,n,e){let r,i;e.link("./invert.js",{default(e){r=e}},0),e.link("./_escapeMap.js",{default(e){i=e}},1),e.exportDefault(r(i))},"templateSettings.js":function e(t,n,e){let r;e.link("./underscore.js",{default(e){r=e}},0),e.exportDefault(r.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g})},"template.js":function e(t,n,e){let r,i;e.export({default:()=>c}),e.link("./defaults.js",{default(e){r=e}},0),e.link("./underscore.js",{default(e){i=e}},1),e.link("./templateSettings.js");var o=/(.)^/,s={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},a=/\\|'|\r|\n|\u2028|\u2029/g;function u(e){return"\\"+s[e]}var f=/^\s*(\w|\$)+\s*$/;function c(e,t,n){!t&&n&&(t=n),t=r({},t,i.templateSettings);var s=RegExp([(t.escape||o).source,(t.interpolate||o).source,(t.evaluate||o).source].join("|")+"|$","g"),c=0,l="__p+='";e.replace(s,(function(t,n,r,i,o){return l+=e.slice(c,o).replace(a,u),c=o+t.length,n?l+="'+\n((__t=("+n+"))==null?'':_.escape(__t))+\n'":r?l+="'+\n((__t=("+r+"))==null?'':__t)+\n'":i&&(l+="';\n"+i+"\n__p+='"),t})),l+="';\n";var h=t.variable,d;if(h){if(!f.test(h))throw new Error("variable is not a bare identifier: "+h)}else l="with(obj||{}){\n"+l+"}\n",h="obj";l="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+l+"return __p;\n";try{d=new Function(h,"_",l)}catch(g){throw g.source=l,g}var p=function(e){return d.call(this,e,i)};return p.source="function("+h+"){\n"+l+"}",p}},"result.js":function e(t,n,e){let r,i;function o(e,t,n){var o=(t=i(t)).length;if(!o)return r(n)?n.call(e):n;for(var s=0;so}),e.link("./isFunction.js",{default(e){r=e}},0),e.link("./_toPath.js",{default(e){i=e}},1)},"uniqueId.js":function e(t,n,e){e.export({default:()=>i});var r=0;function i(e){var t=++r+"";return e?e+t:t}},"chain.js":function e(t,n,e){let r;function i(e){var t=r(e);return t._chain=!0,t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"partial.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_executeBound.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2);var s=r((function(e,t){var n=s.placeholder,r=function(){for(var o=0,s=t.length,a=Array(s),u=0;uo}),e.link("./_baseCreate.js",{default(e){r=e}},0),e.link("./isObject.js",{default(e){i=e}},1)},"bind.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_executeBound.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t,n){if(!i(e))throw new TypeError("Bind must be called on a function");var s=r((function(r){return o(e,s,t,this,n.concat(r))}));return s})))},"bindAll.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./bind.js",{default(e){o=e}},2),e.exportDefault(r((function(e,t){var n=(t=i(t,!1,!1)).length;if(n<1)throw new Error("bindAll must be passed function names");for(;n--;){var r=t[n];e[r]=o(e[r],e)}return e})))},"_flatten.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,u){if(u=u||[],t||0===t){if(t<=0)return u.concat(e)}else t=1/0;for(var f=u.length,c=0,l=r(e);c1)a(h,t-1,n,u),f=u.length;else for(var d=0,p=h.length;da}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./isArray.js",{default(e){o=e}},2),e.link("./isArguments.js",{default(e){s=e}},3)},"_isArrayLike.js":function e(t,n,e){let r,i;e.link("./_createSizePropertyCheck.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.exportDefault(r(i))},"memoize.js":function e(t,n,e){let r;function i(e,t){var n=function(i){var o=n.cache,s=""+(t?t.apply(this,arguments):i);return r(o,s)||(o[s]=e.apply(this,arguments)),o[s]};return n.cache={},n}e.export({default:()=>i}),e.link("./_has.js",{default(e){r=e}},0)},"delay.js":function e(t,n,e){let r;e.link("./restArguments.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){return setTimeout((function(){return e.apply(null,n)}),t)})))},"defer.js":function e(t,n,e){let r,i,o;e.link("./partial.js",{default(e){r=e}},0),e.link("./delay.js",{default(e){i=e}},1),e.link("./underscore.js",{default(e){o=e}},2),e.exportDefault(r(i,o,1))},"throttle.js":function e(t,n,e){let r;function i(e,t,n){var i,o,s,a,u=0;n||(n={});var f=function(){u=!1===n.leading?0:r(),i=null,a=e.apply(o,s),i||(o=s=null)},c=function(){var c=r();u||!1!==n.leading||(u=c);var l=t-(c-u);return o=this,s=arguments,l<=0||l>t?(i&&(clearTimeout(i),i=null),u=c,a=e.apply(o,s),i||(o=s=null)):i||!1===n.trailing||(i=setTimeout(f,l)),a};return c.cancel=function(){clearTimeout(i),u=0,i=o=s=null},c}e.export({default:()=>i}),e.link("./now.js",{default(e){r=e}},0)},"debounce.js":function e(t,n,e){let r,i;function o(e,t,n){var o,s,a,u,f,c=function(){var r=i()-s;t>r?o=setTimeout(c,t-r):(o=null,n||(u=e.apply(f,a)),o||(a=f=null))},l=r((function(r){return f=this,a=r,s=i(),o||(o=setTimeout(c,t),n&&(u=e.apply(f,a))),u}));return l.cancel=function(){clearTimeout(o),o=a=f=null},l}e.export({default:()=>o}),e.link("./restArguments.js",{default(e){r=e}},0),e.link("./now.js",{default(e){i=e}},1)},"wrap.js":function e(t,n,e){let r;function i(e,t){return r(t,e)}e.export({default:()=>i}),e.link("./partial.js",{default(e){r=e}},0)},"negate.js":function e(t,n,e){function r(e){return function(){return!e.apply(this,arguments)}}e.export({default:()=>r})},"compose.js":function e(t,n,e){function r(){var e=arguments,t=e.length-1;return function(){for(var n=t,r=e[t].apply(this,arguments);n--;)r=e[n].call(this,r);return r}}e.export({default:()=>r})},"after.js":function e(t,n,e){function r(e,t){return function(){if(--e<1)return t.apply(this,arguments)}}e.export({default:()=>r})},"before.js":function e(t,n,e){function r(e,t){var n;return function(){return--e>0&&(n=t.apply(this,arguments)),e<=1&&(t=null),n}}e.export({default:()=>r})},"once.js":function e(t,n,e){let r,i;e.link("./partial.js",{default(e){r=e}},0),e.link("./before.js",{default(e){i=e}},1),e.exportDefault(r(i,2))},"findKey.js":function e(t,n,e){let r,i;function o(e,t,n){t=r(t,n);for(var o=i(e),s,a=0,u=o.length;ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"findIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createPredicateIndexFinder.js":function e(t,n,e){let r,i;function o(e){return function(t,n,o){n=r(n,o);for(var s=i(t),a=e>0?0:s-1;a>=0&&ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"findLastIndex.js":function e(t,n,e){let r;e.link("./_createPredicateIndexFinder.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"sortedIndex.js":function e(t,n,e){let r,i;function o(e,t,n,o){for(var s=(n=r(n,o,1))(t),a=0,u=i(e);ao}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1)},"indexOf.js":function e(t,n,e){let r,i,o;e.link("./sortedIndex.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./_createIndexFinder.js",{default(e){o=e}},2),e.exportDefault(o(1,i,r))},"_createIndexFinder.js":function e(t,n,e){let r,i,o;function s(e,t,n){return function(s,a,u){var f=0,c=r(s);if("number"==typeof u)e>0?f=u>=0?u:Math.max(u+c,f):c=u>=0?Math.min(u+1,c):u+c+1;else if(n&&u&&c)return s[u=n(s,a)]===a?u:-1;if(a!=a)return(u=t(i.call(s,f,c),o))>=0?u+f:-1;for(u=e>0?f:c-1;u>=0&&us}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isNaN.js",{default(e){o=e}},2)},"lastIndexOf.js":function e(t,n,e){let r,i;e.link("./findLastIndex.js",{default(e){r=e}},0),e.link("./_createIndexFinder.js",{default(e){i=e}},1),e.exportDefault(i(-1,r))},"find.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a=(r(e)?i:o)(e,t,n);if(void 0!==a&&-1!==a)return e[a]}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./findIndex.js",{default(e){i=e}},1),e.link("./findKey.js",{default(e){o=e}},2)},"findWhere.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./find.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"each.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s,a;if(t=r(t,n),i(e))for(s=0,a=e.length;ss}),e.link("./_optimizeCb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"map.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=Array(a),f=0;fs}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"reduce.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(1))},"_createReduce.js":function e(t,n,e){let r,i,o;function s(e){var t=function(t,n,o,s){var a=!r(t)&&i(t),u=(a||t).length,f=e>0?0:u-1;for(s||(o=t[a?a[f]:f],f+=e);f>=0&&f=3;return t(e,o(n,i,4),r,s)}}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2)},"reduceRight.js":function e(t,n,e){let r;e.link("./_createReduce.js",{default(e){r=e}},0),e.exportDefault(r(-1))},"filter.js":function e(t,n,e){let r,i;function o(e,t,n){var o=[];return t=r(t,n),i(e,(function(e,n,r){t(e,n,r)&&o.push(e)})),o}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"reject.js":function e(t,n,e){let r,i,o;function s(e,t,n){return r(e,i(o(t)),n)}e.export({default:()=>s}),e.link("./filter.js",{default(e){r=e}},0),e.link("./negate.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2)},"every.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"some.js":function e(t,n,e){let r,i,o;function s(e,t,n){t=r(t,n);for(var s=!i(e)&&o(e),a=(s||e).length,u=0;us}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./_isArrayLike.js",{default(e){i=e}},1),e.link("./keys.js",{default(e){o=e}},2)},"contains.js":function e(t,n,e){let r,i,o;function s(e,t,n,s){return r(e)||(e=i(e)),("number"!=typeof n||s)&&(n=0),o(e,t,n)>=0}e.export({default:()=>s}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./indexOf.js",{default(e){o=e}},2)},"invoke.js":function e(t,n,e){let r,i,o,s,a;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2),e.link("./_deepGet.js",{default(e){s=e}},3),e.link("./_toPath.js",{default(e){a=e}},4),e.exportDefault(r((function(e,t,n){var r,u;return i(t)?u=t:(t=a(t),r=t.slice(0,-1),t=t[t.length-1]),o(e,(function(e){var i=u;if(!i){if(r&&r.length&&(e=s(e,r)),null==e)return;i=e[t]}return null==i?i:i.apply(e,n)}))})))},"pluck.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./map.js",{default(e){r=e}},0),e.link("./property.js",{default(e){i=e}},1)},"where.js":function e(t,n,e){let r,i;function o(e,t){return r(e,i(t))}e.export({default:()=>o}),e.link("./filter.js",{default(e){r=e}},0),e.link("./matcher.js",{default(e){i=e}},1)},"max.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=-1/0,u=-1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la&&(a=f);else t=o(t,n),s(e,(function(e,n,r){((c=t(e,n,r))>u||c===-1/0&&a===-1/0)&&(a=e,u=c)}));return a}e.export({default:()=>a}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"min.js":function e(t,n,e){let r,i,o,s;function a(e,t,n){var a=1/0,u=1/0,f,c;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var l=0,h=(e=r(e)?e:i(e)).length;la}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_cb.js",{default(e){o=e}},2),e.link("./each.js",{default(e){s=e}},3)},"shuffle.js":function e(t,n,e){let r;function i(e){return r(e,1/0)}e.export({default:()=>i}),e.link("./sample.js",{default(e){r=e}},0)},"sample.js":function e(t,n,e){let r,i,o,s,a;function u(e,t,n){if(null==t||n)return r(e)||(e=i(e)),e[s(e.length-1)];var u=a(e),f=o(u);t=Math.max(Math.min(t,f),0);for(var c=f-1,l=0;lu}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./values.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./random.js",{default(e){s=e}},3),e.link("./toArray.js",{default(e){a=e}},4)},"toArray.js":function e(t,n,e){let r,i,o,s,a,u,f;e.export({default:()=>l}),e.link("./isArray.js",{default(e){r=e}},0),e.link("./_setup.js",{slice(e){i=e}},1),e.link("./isString.js",{default(e){o=e}},2),e.link("./_isArrayLike.js",{default(e){s=e}},3),e.link("./map.js",{default(e){a=e}},4),e.link("./identity.js",{default(e){u=e}},5),e.link("./values.js",{default(e){f=e}},6);var c=/[^\ud800-\udfff]|[\ud800-\udbff][\udc00-\udfff]|[\ud800-\udfff]/g;function l(e){return e?r(e)?i.call(e):o(e)?e.match(c):s(e)?a(e,u):f(e):[]}},"sortBy.js":function e(t,n,e){let r,i,o;function s(e,t,n){var s=0;return t=r(t,n),i(o(e,(function(e,n,r){return{value:e,index:s++,criteria:t(e,n,r)}})).sort((function(e,t){var n=e.criteria,r=t.criteria;if(n!==r){if(n>r||void 0===n)return 1;if(ns}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./pluck.js",{default(e){i=e}},1),e.link("./map.js",{default(e){o=e}},2)},"groupBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n].push(t):e[n]=[t]})))},"_group.js":function e(t,n,e){let r,i;function o(e,t){return function(n,o,s){var a=t?[[],[]]:{};return o=r(o,s),i(n,(function(t,r){var i=o(t,r,n);e(a,t,i)})),a}}e.export({default:()=>o}),e.link("./_cb.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1)},"indexBy.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n]=t})))},"countBy.js":function e(t,n,e){let r,i;e.link("./_group.js",{default(e){r=e}},0),e.link("./_has.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t,n){i(e,n)?e[n]++:e[n]=1})))},"partition.js":function e(t,n,e){let r;e.link("./_group.js",{default(e){r=e}},0),e.exportDefault(r((function(e,t,n){e[n?0:1].push(t)}),!0))},"size.js":function e(t,n,e){let r,i;function o(e){return null==e?0:r(e)?e.length:i(e).length}e.export({default:()=>o}),e.link("./_isArrayLike.js",{default(e){r=e}},0),e.link("./keys.js",{default(e){i=e}},1)},"pick.js":function e(t,n,e){let r,i,o,s,a,u;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./_optimizeCb.js",{default(e){o=e}},2),e.link("./allKeys.js",{default(e){s=e}},3),e.link("./_keyInObj.js",{default(e){a=e}},4),e.link("./_flatten.js",{default(e){u=e}},5),e.exportDefault(r((function(e,t){var n={},r=t[0];if(null==e)return n;i(r)?(t.length>1&&(r=o(r,t[1])),t=s(e)):(r=a,t=u(t,!1,!1),e=Object(e));for(var f=0,c=t.length;fr})},"omit.js":function e(t,n,e){let r,i,o,s,a,u,f;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./isFunction.js",{default(e){i=e}},1),e.link("./negate.js",{default(e){o=e}},2),e.link("./map.js",{default(e){s=e}},3),e.link("./_flatten.js",{default(e){a=e}},4),e.link("./contains.js",{default(e){u=e}},5),e.link("./pick.js",{default(e){f=e}},6),e.exportDefault(r((function(e,t){var n=t[0],r;return i(n)?(n=o(n),t.length>1&&(r=t[1])):(t=s(a(t,!1,!1),String),n=function(e,n){return!u(t,n)}),f(e,n,r)})))},"first.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[0]:r(e,e.length-t)}e.export({default:()=>i}),e.link("./initial.js",{default(e){r=e}},0)},"initial.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,0,Math.max(0,e.length-(null==t||n?1:t)))}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"last.js":function e(t,n,e){let r;function i(e,t,n){return null==e||e.length<1?null==t||n?void 0:[]:null==t||n?e[e.length-1]:r(e,Math.max(0,e.length-t))}e.export({default:()=>i}),e.link("./rest.js",{default(e){r=e}},0)},"rest.js":function e(t,n,e){let r;function i(e,t,n){return r.call(e,null==t||n?1:t)}e.export({default:()=>i}),e.link("./_setup.js",{slice(e){r=e}},0)},"compact.js":function e(t,n,e){let r;function i(e){return r(e,Boolean)}e.export({default:()=>i}),e.link("./filter.js",{default(e){r=e}},0)},"flatten.js":function e(t,n,e){let r;function i(e,t){return r(e,t,!1)}e.export({default:()=>i}),e.link("./_flatten.js",{default(e){r=e}},0)},"without.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./difference.js",{default(e){i=e}},1),e.exportDefault(r((function(e,t){return i(e,t)})))},"difference.js":function e(t,n,e){let r,i,o,s;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./_flatten.js",{default(e){i=e}},1),e.link("./filter.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3),e.exportDefault(r((function(e,t){return t=i(t,!0,!0),o(e,(function(e){return!s(t,e)}))})))},"uniq.js":function e(t,n,e){let r,i,o,s;function a(e,t,n,a){r(t)||(a=n,n=t,t=!1),null!=n&&(n=i(n,a));for(var u=[],f=[],c=0,l=o(e);ca}),e.link("./isBoolean.js",{default(e){r=e}},0),e.link("./_cb.js",{default(e){i=e}},1),e.link("./_getLength.js",{default(e){o=e}},2),e.link("./contains.js",{default(e){s=e}},3)},"union.js":function e(t,n,e){let r,i,o;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./uniq.js",{default(e){i=e}},1),e.link("./_flatten.js",{default(e){o=e}},2),e.exportDefault(r((function(e){return i(o(e,!0,!0))})))},"intersection.js":function e(t,n,e){let r,i;function o(e){for(var t=[],n=arguments.length,o=0,s=r(e);oo}),e.link("./_getLength.js",{default(e){r=e}},0),e.link("./contains.js",{default(e){i=e}},1)},"unzip.js":function e(t,n,e){let r,i,o;function s(e){for(var t=e&&r(e,i).length||0,n=Array(t),s=0;ss}),e.link("./max.js",{default(e){r=e}},0),e.link("./_getLength.js",{default(e){i=e}},1),e.link("./pluck.js",{default(e){o=e}},2)},"zip.js":function e(t,n,e){let r,i;e.link("./restArguments.js",{default(e){r=e}},0),e.link("./unzip.js",{default(e){i=e}},1),e.exportDefault(r(i))},"object.js":function e(t,n,e){let r;function i(e,t){for(var n={},i=0,o=r(e);ii}),e.link("./_getLength.js",{default(e){r=e}},0)},"range.js":function e(t,n,e){function r(e,t,n){null==t&&(t=e||0,e=0),n||(n=tr})},"chunk.js":function e(t,n,e){let r;function i(e,t){if(null==t||t<1)return[];for(var n=[],i=0,o=e.length;ii}),e.link("./_setup.js",{slice(e){r=e}},0)},"mixin.js":function e(t,n,e){let r,i,o,s,a;function u(e){return i(o(e),(function(t){var n=r[t]=e[t];r.prototype[t]=function(){var e=[this._wrapped];return s.apply(e,arguments),a(this,n.apply(r,e))}})),r}e.export({default:()=>u}),e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./functions.js",{default(e){o=e}},2),e.link("./_setup.js",{push(e){s=e}},3),e.link("./_chainResult.js",{default(e){a=e}},4)},"_chainResult.js":function e(t,n,e){let r;function i(e,t){return e._chain?r(t).chain():t}e.export({default:()=>i}),e.link("./underscore.js",{default(e){r=e}},0)},"underscore-array-methods.js":function e(t,n,e){let r,i,o,s;e.link("./underscore.js",{default(e){r=e}},0),e.link("./each.js",{default(e){i=e}},1),e.link("./_setup.js",{ArrayProto(e){o=e}},2),e.link("./_chainResult.js",{default(e){s=e}},3),i(["pop","push","reverse","shift","sort","splice","unshift"],(function(e){var t=o[e];r.prototype[e]=function(){var n=this._wrapped;return null!=n&&(t.apply(n,arguments),"shift"!==e&&"splice"!==e||0!==n.length||delete n[0]),s(this,n)}})),i(["concat","join","slice"],(function(e){var t=o[e];r.prototype[e]=function(){var e=this._wrapped;return null!=e&&(e=t.apply(e,arguments)),s(this,e)}})),e.exportDefault(r)}}}}},cachers:{"package.json":function e(t,n,e){e.exports={name:"@steedos/cachers",version:"2.7.4-beta.2",main:"lib/index.js"}},lib:{"index.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.getCacherNames=n.clearCacher=n.getCacher=void 0;var r={},i=t("./memory"),o=t("./memory-lru"),s=function(e,t){return r[e]||(e.startsWith("lru.")?r[e]=new o.MemoryLRUCacher(t):r[e]=new i.MemoryCacher),r[e]};n.getCacher=s;var a=function(e){r[e]&&r[e].clear()};n.clearCacher=a;var u=function(){return Object.keys(r)};n.getCacherNames=u},"memory.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryCacher=void 0;var r=t("lodash"),i=function(){function e(){this.cache={}}return e.prototype.get=function(e){return this.cache[e]},e.prototype.delete=function(e){delete this.cache[e]},e.prototype.set=function(e,t){this.cache[e]=t},e.prototype.clear=function(){this.cache={}},e.prototype.keys=function(){return(0,r.keys)(this.cache)},e.prototype.values=function(){return(0,r.values)(this.cache)},e}();n.MemoryCacher=i},"memory-lru.js":function e(t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.MemoryLRUCacher=void 0;var r=t("lodash"),i=t("lru-cache"),o={max:5e3,ttl:null,keygen:null,maxParamsLength:null},s=function(){function e(e){this.opts=(0,r.defaultsDeep)(e,o),this.cache=new i({max:this.opts.max,maxAge:this.opts.ttl?1e3*this.opts.ttl:null,updateAgeOnGet:!!this.opts.ttl})}return e.prototype.get=function(e){return this.cache.get(e)},e.prototype.set=function(e,t,n){return this.cache.set(e,t,n)},e.prototype.delete=function(e){return this.cache.delete(e)},e.prototype.clear=function(){return this.cache.clear()},e.prototype.keys=function(){return this.cache.keys()},e.prototype.values=function(){return this.cache.values()},e}();n.MemoryLRUCacher=s}},node_modules:{"lru-cache":{"package.json":function e(t,n,e){e.exports={name:"lru-cache",version:"7.14.1",main:"index.js"}},"index.js":function e(t,n,e){const r="object"==typeof performance&&performance&&"function"==typeof performance.now?performance:Date,i="function"==typeof AbortController,o=i?AbortController:class e{constructor(){this.signal=new u}abort(){this.signal.dispatchEvent("abort")}},s="function"==typeof AbortSignal,a="function"==typeof o.AbortSignal,u=s?AbortSignal:a?o.AbortController:class e{constructor(){this.aborted=!1,this._listeners=[]}dispatchEvent(e){if("abort"===e){this.aborted=!0;const t={type:e,target:this};this.onabort(t),this._listeners.forEach(e=>e(t),this)}}onabort(){}addEventListener(e,t){"abort"===e&&this._listeners.push(t)}removeEventListener(e,t){"abort"===e&&(this._listeners=this._listeners.filter(e=>e!==t))}},f=new Set,c=(e,t)=>{const n=`LRU_CACHE_OPTION_${e}`;p(n)&&g(n,`${e} option`,`options.${t}`,_)},l=(e,t)=>{const n=`LRU_CACHE_METHOD_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} method`,`cache.${t}()`,i)}},h=(e,t)=>{const n=`LRU_CACHE_PROPERTY_${e}`;if(p(n)){const{prototype:r}=_,{get:i}=Object.getOwnPropertyDescriptor(r,e);g(n,`${e} property`,`cache.${t}`,i)}},d=(...e)=>{"object"==typeof process&&process&&"function"==typeof process.emitWarning?process.emitWarning(...e):console.error(...e)},p=e=>!f.has(e),g=(e,t,n,r)=>{f.add(e);const i=`The ${t} is deprecated. Please use ${n} instead.`;d(i,"DeprecationWarning",e,r)},b=e=>e&&e===Math.floor(e)&&e>0&&isFinite(e),m=e=>b(e)?e<=Math.pow(2,8)?Uint8Array:e<=Math.pow(2,16)?Uint16Array:e<=Math.pow(2,32)?Uint32Array:e<=Number.MAX_SAFE_INTEGER?v:null:null;class v extends Array{constructor(e){super(e),this.fill(0)}}class y{constructor(e){if(0===e)return[];const t=m(e);this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}}class _{constructor(e={}){const{max:t=0,ttl:n,ttlResolution:r=1,ttlAutopurge:i,updateAgeOnGet:o,updateAgeOnHas:s,allowStale:a,dispose:u,disposeAfter:l,noDisposeOnSet:h,noUpdateTTL:g,maxSize:v=0,maxEntrySize:w=0,sizeCalculation:k,fetchMethod:j,fetchContext:x,noDeleteOnFetchRejection:S,noDeleteOnStaleGet:D}=e,{length:E,maxAge:A,stale:C}=e instanceof _?{}:e;if(0!==t&&!b(t))throw new TypeError("max option must be a nonnegative integer");const M=t?m(t):Array;if(!M)throw new Error("invalid max value: "+t);if(this.max=t,this.maxSize=v,this.maxEntrySize=w||this.maxSize,this.sizeCalculation=k||E,this.sizeCalculation){if(!this.maxSize&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if("function"!=typeof this.sizeCalculation)throw new TypeError("sizeCalculation set to non-function")}if(this.fetchMethod=j||null,this.fetchMethod&&"function"!=typeof this.fetchMethod)throw new TypeError("fetchMethod must be a function if specified");if(this.fetchContext=x,!this.fetchMethod&&void 0!==x)throw new TypeError("cannot set fetchContext without fetchMethod");if(this.keyMap=new Map,this.keyList=new Array(t).fill(null),this.valList=new Array(t).fill(null),this.next=new M(t),this.prev=new M(t),this.head=0,this.tail=0,this.free=new y(t),this.initialFill=1,this.size=0,"function"==typeof u&&(this.dispose=u),"function"==typeof l?(this.disposeAfter=l,this.disposed=[]):(this.disposeAfter=null,this.disposed=null),this.noDisposeOnSet=!!h,this.noUpdateTTL=!!g,this.noDeleteOnFetchRejection=!!S,0!==this.maxEntrySize){if(0!==this.maxSize&&!b(this.maxSize))throw new TypeError("maxSize must be a positive integer if specified");if(!b(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.initializeSizeTracking()}if(this.allowStale=!!a||!!C,this.noDeleteOnStaleGet=!!D,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!s,this.ttlResolution=b(r)||0===r?r:1,this.ttlAutopurge=!!i,this.ttl=n||A||0,this.ttl){if(!b(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.initializeTTLTracking()}if(0===this.max&&0===this.ttl&&0===this.maxSize)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.max&&!this.maxSize){const e="LRU_CACHE_UNBOUNDED";if(p(e)){f.add(e);const t="TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";d(t,"UnboundedCacheWarning",e,_)}}C&&c("stale","allowStale"),A&&c("maxAge","ttl"),E&&c("length","sizeCalculation")}getRemainingTTL(e){return this.has(e,{updateAgeOnHas:!1})?1/0:0}initializeTTLTracking(){this.ttls=new v(this.max),this.starts=new v(this.max),this.setItemTTL=(e,t,n=r.now())=>{if(this.starts[e]=0!==t?n:0,this.ttls[e]=t,0!==t&&this.ttlAutopurge){const n=setTimeout(()=>{this.isStale(e)&&this.delete(this.keyList[e])},t+1);n.unref&&n.unref()}},this.updateItemAge=e=>{this.starts[e]=0!==this.ttls[e]?r.now():0};let e=0;const t=()=>{const t=r.now();if(this.ttlResolution>0){e=t;const n=setTimeout(()=>e=0,this.ttlResolution);n.unref&&n.unref()}return t};this.getRemainingTTL=n=>{const r=this.keyMap.get(n);return void 0===r?0:0===this.ttls[r]||0===this.starts[r]?1/0:this.starts[r]+this.ttls[r]-(e||t())},this.isStale=n=>0!==this.ttls[n]&&0!==this.starts[n]&&(e||t())-this.starts[n]>this.ttls[n]}updateItemAge(e){}setItemTTL(e,t,n){}isStale(e){return!1}initializeSizeTracking(){this.calculatedSize=0,this.sizes=new v(this.max),this.removeItemSize=e=>{this.calculatedSize-=this.sizes[e],this.sizes[e]=0},this.requireSize=(e,t,n,r)=>{if(this.isBackgroundFetch(t))return 0;if(!b(n)){if(!r)throw new TypeError("invalid size value (must be positive integer)");if("function"!=typeof r)throw new TypeError("sizeCalculation must be a function");if(n=r(t,e),!b(n))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}return n},this.addItemSize=(e,t)=>{if(this.sizes[e]=t,this.maxSize){const t=this.maxSize-this.sizes[e];for(;this.calculatedSize>t;)this.evict(!0)}this.calculatedSize+=this.sizes[e]}}removeItemSize(e){}addItemSize(e,t){}requireSize(e,t,n,r){if(n||r)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache")}*indexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.tail;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.head);)t=this.prev[t]}*rindexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.head;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.tail);)t=this.next[t]}isValidIndex(e){return this.keyMap.get(this.keyList[e])===e}*entries(){for(const e of this.indexes())yield[this.keyList[e],this.valList[e]]}*rentries(){for(const e of this.rindexes())yield[this.keyList[e],this.valList[e]]}*keys(){for(const e of this.indexes())yield this.keyList[e]}*rkeys(){for(const e of this.rindexes())yield this.keyList[e]}*values(){for(const e of this.indexes())yield this.valList[e]}*rvalues(){for(const e of this.rindexes())yield this.valList[e]}[Symbol.iterator](){return this.entries()}find(e,t={}){for(const n of this.indexes())if(e(this.valList[n],this.keyList[n],this))return this.get(this.keyList[n],t)}forEach(e,t=this){for(const n of this.indexes())e.call(t,this.valList[n],this.keyList[n],this)}rforEach(e,t=this){for(const n of this.rindexes())e.call(t,this.valList[n],this.keyList[n],this)}get prune(){return l("prune","purgeStale"),this.purgeStale}purgeStale(){let e=!1;for(const t of this.rindexes({allowStale:!0}))this.isStale(t)&&(this.delete(this.keyList[t]),e=!0);return e}dump(){const e=[];for(const t of this.indexes({allowStale:!0})){const n=this.keyList[t],i=this.valList[t],o=this.isBackgroundFetch(i)?i.__staleWhileFetching:i,s={value:o};if(this.ttls){s.ttl=this.ttls[t];const e=r.now()-this.starts[t];s.start=Math.floor(Date.now()-e)}this.sizes&&(s.size=this.sizes[t]),e.unshift([n,s])}return e}load(e){this.clear();for(const[t,n]of e){if(n.start){const e=Date.now()-n.start;n.start=r.now()-e}this.set(t,n.value,n)}}dispose(e,t,n){}set(e,t,{ttl:n=this.ttl,start:r,noDisposeOnSet:i=this.noDisposeOnSet,size:o=0,sizeCalculation:s=this.sizeCalculation,noUpdateTTL:a=this.noUpdateTTL}={}){if(o=this.requireSize(e,t,o,s),this.maxEntrySize&&o>this.maxEntrySize)return this.delete(e),this;let u=0===this.size?void 0:this.keyMap.get(e);if(void 0===u)u=this.newIndex(),this.keyList[u]=e,this.valList[u]=t,this.keyMap.set(e,u),this.next[this.tail]=u,this.prev[u]=this.tail,this.tail=u,this.size++,this.addItemSize(u,o),a=!1;else{const n=this.valList[u];t!==n&&(this.isBackgroundFetch(n)?n.__abortController.abort():i||(this.dispose(n,e,"set"),this.disposeAfter&&this.disposed.push([n,e,"set"])),this.removeItemSize(u),this.valList[u]=t,this.addItemSize(u,o)),this.moveToTail(u)}if(0===n||0!==this.ttl||this.ttls||this.initializeTTLTracking(),a||this.setItemTTL(u,n,r),this.disposeAfter)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return this}newIndex(){return 0===this.size?this.tail:this.size===this.max&&0!==this.max?this.evict(!1):0!==this.free.length?this.free.pop():this.initialFill++}pop(){if(this.size){const e=this.valList[this.head];return this.evict(!0),e}}evict(e){const t=this.head,n=this.keyList[t],r=this.valList[t];return this.isBackgroundFetch(r)?r.__abortController.abort():(this.dispose(r,n,"evict"),this.disposeAfter&&this.disposed.push([r,n,"evict"])),this.removeItemSize(t),e&&(this.keyList[t]=null,this.valList[t]=null,this.free.push(t)),this.head=this.next[t],this.keyMap.delete(n),this.size--,t}has(e,{updateAgeOnHas:t=this.updateAgeOnHas}={}){const n=this.keyMap.get(e);return void 0!==n&&!this.isStale(n)&&(t&&this.updateItemAge(n),!0)}peek(e,{allowStale:t=this.allowStale}={}){const n=this.keyMap.get(e);if(void 0!==n&&(t||!this.isStale(n))){const e=this.valList[n];return this.isBackgroundFetch(e)?e.__staleWhileFetching:e}}backgroundFetch(e,t,n,r){const i=void 0===t?void 0:this.valList[t];if(this.isBackgroundFetch(i))return i;const s=new o,a={signal:s.signal,options:n,context:r},u=t=>(s.signal.aborted||this.set(e,t,a.options),t),f=r=>{if(this.valList[t]===l){const r=!n.noDeleteOnFetchRejection||void 0===l.__staleWhileFetching;r?this.delete(e):this.valList[t]=l.__staleWhileFetching}if(l.__returned===l)throw r},c=t=>t(this.fetchMethod(e,i,a)),l=new Promise(c).then(u,f);return l.__abortController=s,l.__staleWhileFetching=i,l.__returned=null,void 0===t?(this.set(e,l,a.options),t=this.keyMap.get(e)):this.valList[t]=l,l}isBackgroundFetch(e){return e&&"object"==typeof e&&"function"==typeof e.then&&Object.prototype.hasOwnProperty.call(e,"__staleWhileFetching")&&Object.prototype.hasOwnProperty.call(e,"__returned")&&(e.__returned===e||null===e.__returned)}async fetch(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet,ttl:i=this.ttl,noDisposeOnSet:o=this.noDisposeOnSet,size:s=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:u=this.noUpdateTTL,noDeleteOnFetchRejection:f=this.noDeleteOnFetchRejection,fetchContext:c=this.fetchContext,forceRefresh:l=!1}={}){if(!this.fetchMethod)return this.get(e,{allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r});const h={allowStale:t,updateAgeOnGet:n,noDeleteOnStaleGet:r,ttl:i,noDisposeOnSet:o,size:s,sizeCalculation:a,noUpdateTTL:u,noDeleteOnFetchRejection:f};let d=this.keyMap.get(e);if(void 0===d){const t=this.backgroundFetch(e,d,h,c);return t.__returned=t}{const r=this.valList[d];if(this.isBackgroundFetch(r))return t&&void 0!==r.__staleWhileFetching?r.__staleWhileFetching:r.__returned=r;if(!l&&!this.isStale(d))return this.moveToTail(d),n&&this.updateItemAge(d),r;const i=this.backgroundFetch(e,d,h,c);return t&&void 0!==i.__staleWhileFetching?i.__staleWhileFetching:i.__returned=i}}get(e,{allowStale:t=this.allowStale,updateAgeOnGet:n=this.updateAgeOnGet,noDeleteOnStaleGet:r=this.noDeleteOnStaleGet}={}){const i=this.keyMap.get(e);if(void 0!==i){const o=this.valList[i],s=this.isBackgroundFetch(o);if(this.isStale(i))return s?t?o.__staleWhileFetching:void 0:(r||this.delete(e),t?o:void 0);if(s)return;return this.moveToTail(i),n&&this.updateItemAge(i),o}}connect(e,t){this.prev[t]=e,this.next[e]=t}moveToTail(e){e!==this.tail&&(e===this.head?this.head=this.next[e]:this.connect(this.prev[e],this.next[e]),this.connect(this.tail,e),this.tail=e)}get del(){return l("del","delete"),this.delete}delete(e){let t=!1;if(0!==this.size){const n=this.keyMap.get(e);if(void 0!==n)if(t=!0,1===this.size)this.clear();else{this.removeItemSize(n);const t=this.valList[n];this.isBackgroundFetch(t)?t.__abortController.abort():(this.dispose(t,e,"delete"),this.disposeAfter&&this.disposed.push([t,e,"delete"])),this.keyMap.delete(e),this.keyList[n]=null,this.valList[n]=null,n===this.tail?this.tail=this.prev[n]:n===this.head?this.head=this.next[n]:(this.next[this.prev[n]]=this.next[n],this.prev[this.next[n]]=this.prev[n]),this.size--,this.free.push(n)}}if(this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return t}clear(){for(const e of this.rindexes({allowStale:!0})){const t=this.valList[e];if(this.isBackgroundFetch(t))t.__abortController.abort();else{const n=this.keyList[e];this.dispose(t,n,"delete"),this.disposeAfter&&this.disposed.push([t,n,"delete"])}}if(this.keyMap.clear(),this.valList.fill(null),this.keyList.fill(null),this.ttls&&(this.ttls.fill(0),this.starts.fill(0)),this.sizes&&this.sizes.fill(0),this.head=0,this.tail=0,this.initialFill=1,this.free.length=0,this.calculatedSize=0,this.size=0,this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift())}get reset(){return l("reset","clear"),this.clear}get length(){return h("length","size"),this.size}static get AbortController(){return o}static get AbortSignal(){return u}}e.exports=_}}}},"form-builder":{"package.json":function e(t,n,e){e.exports={name:"@steedos/form-builder",version:"3.6.2-patch.5",private:!1,publishConfig:{access:"public"},main:"dist/form-builder.min.js",homepage:"https://formbuilder.online/",repository:{url:"https://github.com/kevinchappell/formBuilder.git",type:"git"},files:["dist/**/*","docs/**/*","src/**/*"],author:"Kevin Chappell ",contributors:[],bugs:"https://github.com/kevinchappell/formBuilder/issues",description:"A jQuery plugin for drag and drop form building",keywords:["jquery-plugin","forms","drag and drop","form builder","form create"],license:"MIT",ignore:["**/*","node_modules","test"],config:{files:{test:["test/**/*.spec.js"],pluginsDir:"src/js/control_plugins/",fonts:"src/fonts",sass:"src/sass",formBuilder:{js:"src/js/form-builder.js",sass:["src/sass/form-builder.scss"]},formRender:{js:"src/js/form-render.js",sass:["src/sass/form-render.scss"]},site:["demo/assets/sass/site.scss"]},fontServer:"http://fontello.com",fontelloToken:"09d648f01d6c57cb9f9b8cc55043e0c0"},babel:{presets:[["@babel/preset-env",{targets:{browsers:["> 1%"]},loose:!0}]],comments:!1,plugins:["@babel/plugin-proposal-object-rest-spread","@babel/plugin-proposal-class-properties"]},scripts:{"build:analyze":"webpack --mode production -p --progress --config tools/webpack.config --analyze","build:plugins":"webpack --mode production -p --display-entrypoints --progress --config tools/webpack.plugins.config","build:vendor":"babel-node tools/build-vendor",build:"webpack --mode production -p --progress --config tools/webpack.config","build:all":"npm-run-all build:plugins build:vendor build copy",copy:"cp -a dist/* demo/assets/js/ && cp CONTRIBUTING.md docs/contributing.md && cp LICENSE docs/license.md && npm run copy:lang","copy:lang":"babel-node tools/copy-language-files","deploy:all":"npm-run-all deploy:demo deploy:site","deploy:demo":"node tools/deploy-demo.js","deploy:site":"node tools/deploy-site.js",docs:"mkdocs build",font:"babel-node tools/icon-font",lint:"eslint ./src --ext .js || true","semantic-release":"semantic-release","start:devServer":"webpack-dev-server --mode development --config tools/webpack.config",prestart:"npm-run-all -p build:vendor copy:lang",start:"npm run start:devServer",test:"npm run-script build"},dependencies:{jquery:">=3.4.1","jquery-ui-sortable":"*"},devDependencies:{"@babel/cli":"^7.10.5","@babel/core":"^7.11.4","@babel/node":"^7.10.5","@babel/plugin-proposal-class-properties":"^7.10.4","@babel/plugin-proposal-object-rest-spread":"^7.11.0","@babel/plugin-syntax-object-rest-spread":"^7.8.3","@babel/plugin-transform-destructuring":"^7.10.4","@babel/preset-env":"^7.11.0","@semantic-release/changelog":"^5.0.1","@semantic-release/git":"^9.0.0","@semantic-release/npm":"^7.0.5",autoprefixer:"^9.8.6","babel-eslint":"^10.1.0","babel-loader":"^8.1.0","clean-webpack-plugin":"^3.0.0",clui:"^0.3.6","compression-webpack-plugin":"^5.0.1","concat-files":"^0.1.1","cross-env":"^7.0.2","css-loader":"^4.2.1",eslint:"^7.7.0","eslint-loader":"^4.0.2","formbuilder-languages":"latest","fs-extra":"^9.0.1","html-webpack-harddisk-plugin":"^1.0.2","html-webpack-plugin":"^4.3.0",inquirer:"^7.3.3",mi18n:"^0.4.8","node-sass":"6.0.1","npm-run-all":"^4.1.5",opener:"^1.5.1","postcss-loader":"^3.0.0","replace-in-file":"^6.1.0",request:"^2.88.2","sass-loader":"10.5.2","semantic-release":"^17.1.1",semver:"^7.3.2","style-loader":"^1.2.1",unzipper:"^0.10.11",webpack:"^4.44.1","webpack-bundle-analyzer":"^3.8.0","webpack-cli":"^3.3.12","webpack-dev-server":"^3.11.0","wrapper-webpack-plugin":"^2.1.0"},prettier:{singleQuote:!0,trailingComma:"all",printWidth:120,semi:!1,arrowParens:"avoid",spaceAfterFunction:!1},engines:{},release:{branch:"master",verifyConditions:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"],prepare:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"]},browserslist:["> 1%"]}},dist:{"form-builder.min.js":[]}}},tslib:{"package.json":function e(t,n,e){e.exports={name:"tslib",version:"2.3.1",module:"tslib.es6.js",main:"tslib.js"}},"tslib.es6.js":function e(t,n,e){e.export({__extends:()=>i,__assign:()=>o,__rest:()=>s,__decorate:()=>a,__param:()=>u,__metadata:()=>f,__awaiter:()=>c,__generator:()=>l,__createBinding:()=>h,__exportStar:()=>d,__values:()=>p,__read:()=>g,__spread:()=>b,__spreadArrays:()=>m,__spreadArray:()=>v,__await:()=>y,__asyncGenerator:()=>_,__asyncDelegator:()=>w,__asyncValues:()=>k,__makeTemplateObject:()=>j,__importStar:()=>S,__importDefault:()=>D,__classPrivateFieldGet:()=>E,__classPrivateFieldSet:()=>A}); /*! ***************************************************************************** Copyright (c) Microsoft Corporation. @@ -249,7 +249,7 @@ Package._define("mobile-experience"); !function(){var a=Package["ddp-client"].DDP;Package._define("ddp",{DDP:a})}(); -Package._define("ddp-server"); +!function(){var e,a,d;Package._define("ddp-server")}(); !function(){var e=Package.meteor.Meteor,t=Package.meteor.global,o=Package.meteor.meteorEnv,n=Package.minimongo.LocalCollection,r=Package.minimongo.Minimongo,i=Package.check.check,c=Package.check.Match,s=Package.ejson.EJSON,l=Package["ddp-client"].DDP,a=Package.modules.meteorInstall,d=Package.promise.Promise,f,u;a({node_modules:{meteor:{"allow-deny":{"allow-deny.js":function t(){const o=Object.prototype.hasOwnProperty,r=(f={CollectionPrototype:{}}).CollectionPrototype;r.allow=function(e){h(this,"allow",e)},r.deny=function(e){h(this,"deny",e)},r._defineMutationMethods=function(t){const n=this;if(t=t||{},n._restricted=!1,n._insecure=void 0,n._validators={insert:{allow:[],deny:[]},update:{allow:[],deny:[]},remove:{allow:[],deny:[]},upsert:{allow:[],deny:[]},fetch:[],fetchAllFields:!1},n._name&&(n._prefix="/"+n._name+"/",n._connection&&(n._connection===e.server||e.isClient))){const r={};["insert","update","remove"].forEach(s=>{const l=n._prefix+s;if(t.useExisting){const t=e.isClient?"_methodHandlers":"method_handlers";if(n._connection[t]&&"function"==typeof n._connection[t][l])return}r[l]=function(){i(arguments,[c.Any]);const t=Array.from(arguments);try{let r=null;if("insert"!==s||o.call(t[0],"_id")||(r=n._makeNewID()),this.isSimulation)return null!==r&&(t[0]._id=r),n._collection[s].apply(n._collection,t);if("insert"!==s&&_(t[0],s),n._restricted){if(0===n._validators[s].allow.length)throw new e.Error(403,"Access denied. No allow validators set on restricted collection for method '"+s+"'.");const o="_validated"+s.charAt(0).toUpperCase()+s.slice(1);return t.unshift(this.userId),"insert"===s&&t.push(r),n[o].apply(n,t)}if(n._isInsecure())return null!==r&&(t[0]._id=r),n._collection[s].apply(n._collection,t);throw new e.Error(403,"Access denied")}catch(r){throw"MongoError"===r.name||"MinimongoError"===r.name?new e.Error(409,r.toString()):r}}}),n._connection.methods(r)}},r._updateFetch=function(e){const t=this;if(!t._validators.fetchAllFields)if(e){const o=Object.create(null),n=e=>e&&e.forEach(e=>o[e]=1);n(t._validators.fetch),n(e),t._validators.fetch=Object.keys(o)}else t._validators.fetchAllFields=!0,t._validators.fetch=null},r._isInsecure=function(){const e=this;return void 0===this._insecure?!!Package.insecure:this._insecure},r._validatedInsert=function(t,o,n){const r=this;if(this._validators.insert.deny.some(e=>e(t,u(e,o,n))))throw new e.Error(403,"Access denied");if(this._validators.insert.allow.every(e=>!e(t,u(e,o,n))))throw new e.Error(403,"Access denied");null!==n&&(o._id=n),this._collection.insert.call(this._collection,o)},r._validatedUpdate=function(t,r,c,s){const l=this;if(i(c,Object),s=Object.assign(Object.create(null),s),!n._selectorIsIdPerhapsAsObject(r))throw new Error("validated update should be of a single ID");if(s.upsert)throw new e.Error(403,"Access denied. Upserts not allowed in a restricted collection.");const f="Access denied. In a restricted collection you can only update documents, not replace them. Use a Mongo update operator, such as '$set'.",u=Object.keys(c),h={};if(0===u.length)throw new e.Error(403,f);u.forEach(t=>{const n=c[t];if("$"!==t.charAt(0))throw new e.Error(403,f);if(!o.call(a,t))throw new e.Error(403,"Access denied. Operator "+t+" not allowed in a restricted collection.");Object.keys(n).forEach(e=>{-1!==e.indexOf(".")&&(e=e.substring(0,e.indexOf("."))),h[e]=!0})});const _=Object.keys(h),m={transform:null};l._validators.fetchAllFields||(m.fields={},l._validators.fetch.forEach(e=>{m.fields[e]=1}));const w=l._collection.findOne(r,m);if(!w)return 0;if(l._validators.update.deny.some(e=>{const o=d(e,w);return e(t,o,_,c)}))throw new e.Error(403,"Access denied");if(l._validators.update.allow.every(e=>{const o=d(e,w);return!e(t,o,_,c)}))throw new e.Error(403,"Access denied");return s._forbidReplace=!0,l._collection.update.call(l._collection,r,c,s)};const a={$inc:1,$set:1,$unset:1,$addToSet:1,$pop:1,$pullAll:1,$pull:1,$pushAll:1,$push:1,$bit:1};function d(e,t){return e.transform?e.transform(t):t}function u(e,t,o){let n=t;return e.transform&&(n=s.clone(t),null!==o&&(n._id=o),n=e.transform(n)),n}function h(e,t,r){const i=/^(?:insert|update|remove|fetch|transform)$/;if(Object.keys(r).forEach(e=>{if(!i.test(e))throw new Error(t+": Invalid key: "+e)}),e._restricted=!0,["insert","update","remove"].forEach(i=>{if(o.call(r,i)){if(!(r[i]instanceof Function))throw new Error(t+": Value for `"+i+"` must be a function");void 0===r.transform?r[i].transform=e._transform:r[i].transform=n.wrapTransform(r.transform),e._validators[i][t].push(r[i])}}),r.update||r.remove||r.fetch){if(r.fetch&&!(r.fetch instanceof Array))throw new Error(t+": Value for `fetch` must be an array");e._updateFetch(r.fetch)}}function _(t,o){if(!n._selectorIsIdPerhapsAsObject(t))throw new e.Error(403,"Not permitted. Untrusted code may only "+o+" documents by ID.")}function m(){var e;const t=(l._CurrentMethodInvocation||l._CurrentInvocation).get();return t&&t.isSimulation}r._validatedRemove=function(t,o){const n=this,r={transform:null};n._validators.fetchAllFields||(r.fields={},n._validators.fetch.forEach(e=>{r.fields[e]=1}));const i=n._collection.findOne(o,r);if(!i)return 0;if(n._validators.remove.deny.some(e=>e(t,d(e,i))))throw new e.Error(403,"Access denied");if(n._validators.remove.allow.every(e=>!e(t,d(e,i))))throw new e.Error(403,"Access denied");return n._collection.remove.call(n._collection,o)},r._callMutatorMethod=function t(o,n,r){!e.isClient||r||m()||(r=function(t){t&&e._debug(o+" failed: "+(t.reason||t.stack))});const i="update"===o||"remove"===o;i&&!m()&&_(n[0],o);const c=this._prefix+o;return this._connection.apply(c,n,{returnStubValue:!0},r)}}}}}},{extensions:[".js",".json"]})("/node_modules/meteor/allow-deny/allow-deny.js"),Package._define("allow-deny",{AllowDeny:f})}(); diff --git a/server/bundle/programs/web.browser/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json b/server/bundle/programs/web.browser/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json similarity index 99% rename from server/bundle/programs/web.browser/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json rename to server/bundle/programs/web.browser/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json index f421ff5a81..32cdd99b94 100644 --- a/server/bundle/programs/web.browser/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json +++ b/server/bundle/programs/web.browser/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json @@ -3,8 +3,8 @@ "name": "standard-minifier-js", "version": "2.6.0" }, - "totalMinifiedBytes": 4306712, - "totalMinifiedGzipBytes": 1085048, + "totalMinifiedBytes": 4306737, + "totalMinifiedGzipBytes": 1085046, "minifiedBytesByPackage": { "packages/meteor.js": 9504, "packages/coffeescript.js": 32, @@ -1584,7 +1584,7 @@ } ], "packages/ddp.js": 78, - "packages/ddp-server.js": 30, + "packages/ddp-server.js": 55, "packages/allow-deny.js": [ 5767, { diff --git a/server/bundle/programs/web.browser/program.json b/server/bundle/programs/web.browser/program.json index ebba1ab57a..8dc087892f 100644 --- a/server/bundle/programs/web.browser/program.json +++ b/server/bundle/programs/web.browser/program.json @@ -2,24 +2,24 @@ "format": "web-program-pre1", "manifest": [ { - "path": "79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js", + "path": "7d27de16d6eab9175efa4d52871e8cc6588f4811.js", "where": "client", "type": "js", "cacheable": true, - "url": "/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.js?meteor_js_resource=true", - "size": 4306712, - "hash": "79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9", - "sri": "8V1LAdKwQ3YDuCf6NLWIc8ANTjyPPal4eMgPcDSh7DgxhEPYKlU6Ng1mUyFf41upRtf3cWipGUF8Bks86cK3Xg==" + "url": "/7d27de16d6eab9175efa4d52871e8cc6588f4811.js?meteor_js_resource=true", + "size": 4306737, + "hash": "7d27de16d6eab9175efa4d52871e8cc6588f4811", + "sri": "mQJ9d8Y1Rd2yLC9UkYFqc8DKdWTK+EbdVcXzlUriN9g92KUMPH+VnggxIBgtYFspWYpGlxV7xGxOIieDJ5ACcg==" }, { - "path": "79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json", + "path": "7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json", "where": "client", "type": "json", "cacheable": true, - "url": "/79fb74cf3ad35589f4166b0c4d9fd0aa7ffa21a9.stats.json?meteor_js_resource=true", + "url": "/7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json?meteor_js_resource=true", "size": 92684, - "hash": "84b3c49ed8cbcc47c24972dbe109f0a26e1c615f", - "sri": "9TD3noiNc7n1kIu/MLlA5a+iI7Zw7X3uqMMLIepNxhm2titxz91fBgCPj5bpXr60mvkrz+5WmQd7JBkRh5M8PQ==" + "hash": "09ae6c73b3f27edc9130f5c46771c9c45954f508", + "sri": "zVvOLAKlxGGT0HM1ez3LJh6n8LNY7HTZ23MTiXz0eUEOUNiG6OYB/AID6bCJaDNjWU9eKCk3WsYO5YL6W6Tiaw==" }, { "path": "dynamic/node_modules/@steedos/form-builder/dist/form-builder.min.js", diff --git a/server/bundle/programs/web.cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.js b/server/bundle/programs/web.cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js similarity index 99% rename from server/bundle/programs/web.cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.js rename to server/bundle/programs/web.cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js index a0f7c67d9c..85735847d9 100644 --- a/server/bundle/programs/web.cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.js +++ b/server/bundle/programs/web.cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js @@ -68,7 +68,7 @@ object-assign * Copyright 2011-2019 Twitter, Inc. * Licensed under the MIT license */ -if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(jQuery),function(e){"use strict";function t(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var r in t)if(void 0!==e.style[r])return{end:t[r]};return!1}e.fn.emulateTransitionEnd=function(t){var r=!1,n=this,i;return e(this).one("bsTransitionEnd",(function(){r=!0})),setTimeout((function(){r||e(n).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=t(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(jQuery),function(e){"use strict";var t='[data-dismiss="alert"]',r=function(r){e(r).on("click",t,this.close)};function n(t){return this.each((function(){var n=e(this),i=n.data("bs.alert");i||n.data("bs.alert",i=new r(this)),"string"==typeof t&&i[t].call(n)}))}r.VERSION="3.4.1",r.TRANSITION_DURATION=150,r.prototype.close=function(t){var n=e(this),i=n.attr("data-target");i||(i=(i=n.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=e(document).find(i);function a(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=n.closest(".alert")),o.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),e.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",a).emulateTransitionEnd(r.TRANSITION_DURATION):a())};var i=e.fn.alert;e.fn.alert=n,e.fn.alert.Constructor=r,e.fn.alert.noConflict=function(){return e.fn.alert=i,this},e(document).on("click.bs.alert.data-api",t,r.prototype.close)}(jQuery),function(e){"use strict";var t=function(r,n){this.$element=e(r),this.options=e.extend({},t.DEFAULTS,n),this.isLoading=!1};function r(r){return this.each((function(){var n=e(this),i=n.data("bs.button"),o="object"==typeof r&&r;i||n.data("bs.button",i=new t(this,o)),"toggle"==r?i.toggle():r&&i.setState(r)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var r="disabled",n=this.$element,i=n.is("input")?"val":"html",o=n.data();t+="Text",null==o.resetText&&n.data("resetText",n[i]()),setTimeout(e.proxy((function(){n[i](null==o[t]?this.options[t]:o[t]),"loadingText"==t?(this.isLoading=!0,n.addClass(r).attr(r,r).prop(r,!0)):this.isLoading&&(this.isLoading=!1,n.removeClass(r).removeAttr(r).prop(r,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var r=this.$element.find("input");"radio"==r.prop("type")?(r.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==r.prop("type")&&(r.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),r.prop("checked",this.$element.hasClass("active")),e&&r.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var n=e.fn.button;e.fn.button=r,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=n,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var n=e(t.target).closest(".btn");r.call(n,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),n.is("input,button")?n.trigger("focus"):n.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(jQuery),function(e){"use strict";var t=function(t,r){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=r,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function r(r){return this.each((function(){var n=e(this),i=n.data("bs.carousel"),o=e.extend({},t.DEFAULTS,n.data(),"object"==typeof r&&r),a="string"==typeof r?r:o.slide;i||n.data("bs.carousel",i=new t(this,o)),"number"==typeof r?i.to(r):a?i[a]():o.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var r=this.getItemIndex(t),n;if(("prev"==e&&0===r||"next"==e&&r==this.$items.length-1)&&!this.options.wrap)return t;var i,o=(r+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(o)},t.prototype.to=function(e){var t=this,r=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):r==e?this.pause().cycle():this.slide(e>r?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(r,n){var i=this.$element.find(".item.active"),o=n||this.getItemForDirection(r,i),a=this.interval,s="next"==r?"left":"right",u=this;if(o.hasClass("active"))return this.sliding=!1;var c=o[0],l=e.Event("slide.bs.carousel",{relatedTarget:c,direction:s});if(this.$element.trigger(l),!l.isDefaultPrevented()){if(this.sliding=!0,a&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var f=e(this.$indicators.children()[this.getItemIndex(o)]);f&&f.addClass("active")}var d=e.Event("slid.bs.carousel",{relatedTarget:c,direction:s});return e.support.transition&&this.$element.hasClass("slide")?(o.addClass(r),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(s),o.addClass(s),i.one("bsTransitionEnd",(function(){o.removeClass([r,s].join(" ")).addClass("active"),i.removeClass(["active",s].join(" ")),u.sliding=!1,setTimeout((function(){u.$element.trigger(d)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(d)),a&&this.cycle(),this}};var n=e.fn.carousel;e.fn.carousel=r,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=n,this};var i=function(t){var n=e(this),i=n.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=n.attr("data-target")||i,a=e(document).find(o);if(a.hasClass("carousel")){var s=e.extend({},a.data(),n.data()),u=n.attr("data-slide-to");u&&(s.interval=!1),r.call(a,s),u&&a.data("bs.carousel").to(u),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);r.call(t,t.data())}))}))}(jQuery),function(e){"use strict";var t=function(r,n){this.$element=e(r),this.options=e.extend({},t.DEFAULTS,n),this.$trigger=e('[data-toggle="collapse"][href="#'+r.id+'"],[data-toggle="collapse"][data-target="#'+r.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function r(t){var r,n=t.attr("data-target")||(r=t.attr("href"))&&r.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(n)}function n(r){return this.each((function(){var n=e(this),i=n.data("bs.collapse"),o=e.extend({},t.DEFAULTS,n.data(),"object"==typeof r&&r);!i&&o.toggle&&/show|hide/.test(r)&&(o.toggle=!1),i||n.data("bs.collapse",i=new t(this,o)),"string"==typeof r&&i[r]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){var e;return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var r,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(r=i.data("bs.collapse"))&&r.transitioning)){var o=e.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){i&&i.length&&(n.call(i,"hide"),r||i.data("bs.collapse",null));var a=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[a](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var s=function(){this.$element.removeClass("collapsing").addClass("collapse in")[a](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return s.call(this);var u=e.camelCase(["scroll",a].join("-"));this.$element.one("bsTransitionEnd",e.proxy(s,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[a](this.$element[0][u])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var r=e.Event("hide.bs.collapse");if(this.$element.trigger(r),!r.isDefaultPrevented()){var n=this.dimension();this.$element[n](this.$element[n]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[n](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,n){var i=e(n);this.addAriaAndCollapsedClass(r(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var r=e.hasClass("in");e.attr("aria-expanded",r),t.toggleClass("collapsed",!r).attr("aria-expanded",r)};var i=e.fn.collapse;e.fn.collapse=n,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var o=r(i),a,s=o.data("bs.collapse")?"toggle":i.data();n.call(o,s)}))}(jQuery),function(e){"use strict";var t=".dropdown-backdrop",r='[data-toggle="dropdown"]',n=function(t){e(t).on("click.bs.dropdown",this.toggle)};function i(t){var r=t.attr("data-target");r||(r=(r=t.attr("href"))&&/#[A-Za-z]/.test(r)&&r.replace(/.*(?=#[^\s]*$)/,""));var n="#"!==r?e(document).find(r):null;return n&&n.length?n:t.parent()}function o(n){n&&3===n.which||(e(t).remove(),e(r).each((function(){var t=e(this),r=i(t),o={relatedTarget:this};r.hasClass("open")&&(n&&"click"==n.type&&/input|textarea/i.test(n.target.tagName)&&e.contains(r[0],n.target)||(r.trigger(n=e.Event("hide.bs.dropdown",o)),n.isDefaultPrevented()||(t.attr("aria-expanded","false"),r.removeClass("open").trigger(e.Event("hidden.bs.dropdown",o)))))})))}function a(t){return this.each((function(){var r=e(this),i=r.data("bs.dropdown");i||r.data("bs.dropdown",i=new n(this)),"string"==typeof t&&i[t].call(r)}))}n.VERSION="3.4.1",n.prototype.toggle=function(t){var r=e(this);if(!r.is(".disabled, :disabled")){var n=i(r),a=n.hasClass("open");if(o(),!a){"ontouchstart"in document.documentElement&&!n.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",o);var s={relatedTarget:this};if(n.trigger(t=e.Event("show.bs.dropdown",s)),t.isDefaultPrevented())return;r.trigger("focus").attr("aria-expanded","true"),n.toggleClass("open").trigger(e.Event("shown.bs.dropdown",s))}return!1}},n.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var n=e(this);if(t.preventDefault(),t.stopPropagation(),!n.is(".disabled, :disabled")){var o=i(n),a=o.hasClass("open");if(!a&&27!=t.which||a&&27==t.which)return 27==t.which&&o.find(r).trigger("focus"),n.trigger("click");var s=" li:not(.disabled):visible a",u=o.find(".dropdown-menu"+s);if(u.length){var c=u.index(t.target);38==t.which&&c>0&&c--,40==t.which&&cdocument.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},c.prototype.init=function(t,r,n){if(this.enabled=!0,this.type=t,this.$element=e(r),this.options=this.getOptions(n),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),o=i.length;o--;){var a=i[o];if("click"==a)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=a){var s="hover"==a?"mouseenter":"focusin",u="hover"==a?"mouseleave":"focusout";this.$element.on(s+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(u+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},c.prototype.getDefaults=function(){return c.DEFAULTS},c.prototype.getOptions=function(r){var n=this.$element.data();for(var i in n)n.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete n[i];return(r=e.extend({},this.getDefaults(),n,r)).delay&&"number"==typeof r.delay&&(r.delay={show:r.delay,hide:r.delay}),r.sanitize&&(r.template=u(r.template,r.whiteList,r.sanitizeFn)),r},c.prototype.getDelegateOptions=function(){var t={},r=this.getDefaults();return this._options&&e.each(this._options,(function(e,n){r[e]!=n&&(t[e]=n)})),t},c.prototype.enter=function(t){var r=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(r||(r=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,r)),t instanceof e.Event&&(r.inState["focusin"==t.type?"focus":"hover"]=!0),r.tip().hasClass("in")||"in"==r.hoverState)r.hoverState="in";else{if(clearTimeout(r.timeout),r.hoverState="in",!r.options.delay||!r.options.delay.show)return r.show();r.timeout=setTimeout((function(){"in"==r.hoverState&&r.show()}),r.options.delay.show)}},c.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},c.prototype.leave=function(t){var r=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(r||(r=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,r)),t instanceof e.Event&&(r.inState["focusout"==t.type?"focus":"hover"]=!1),!r.isInStateTrue()){if(clearTimeout(r.timeout),r.hoverState="out",!r.options.delay||!r.options.delay.hide)return r.hide();r.timeout=setTimeout((function(){"out"==r.hoverState&&r.hide()}),r.options.delay.hide)}},c.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var r=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!r)return;var n=this,i=this.tip(),o=this.getUID(this.type);this.setContent(),i.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&i.addClass("fade");var a="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,s=/\s?auto?\s?/i,u=s.test(a);u&&(a=a.replace(s,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(a).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var l=this.getPosition(),f=i[0].offsetWidth,d=i[0].offsetHeight;if(u){var h=a,p=this.getPosition(this.$viewport);a="bottom"==a&&l.bottom+d>p.bottom?"top":"top"==a&&l.top-dp.width?"left":"left"==a&&l.left-fa.top+a.height&&(i.top=a.top+a.height-u)}else{var c=t.left-o,l=t.left+o+r;ca.right&&(i.left=a.left+a.width-l)}return i},c.prototype.getTitle=function(){var e,t=this.$element,r=this.options;return e=t.attr("data-original-title")||("function"==typeof r.title?r.title.call(t[0]):r.title)},c.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},c.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},c.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},c.prototype.enable=function(){this.enabled=!0},c.prototype.disable=function(){this.enabled=!1},c.prototype.toggleEnabled=function(){this.enabled=!this.enabled},c.prototype.toggle=function(t){var r=this;t&&((r=e(t.currentTarget).data("bs."+this.type))||(r=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,r))),t?(r.inState.click=!r.inState.click,r.isInStateTrue()?r.enter(r):r.leave(r)):r.tip().hasClass("in")?r.leave(r):r.enter(r)},c.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},c.prototype.sanitizeHtml=function(e){return u(e,this.options.whiteList,this.options.sanitizeFn)};var f=e.fn.tooltip;e.fn.tooltip=l,e.fn.tooltip.Constructor=c,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=f,this}}(jQuery),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");function r(r){return this.each((function(){var n=e(this),i=n.data("bs.popover"),o="object"==typeof r&&r;!i&&/destroy|hide/.test(r)||(i||n.data("bs.popover",i=new t(this,o)),"string"==typeof r&&i[r]())}))}t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:''}),t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype),t.prototype.constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),r=this.getContent();if(this.options.html){var n=typeof r;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===n&&(r=this.sanitizeHtml(r))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===n?"html":"append"](r)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(r);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var n=e.fn.popover;e.fn.popover=r,e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=n,this}}(jQuery),function(e){"use strict";function t(r,n){this.$body=e(document.body),this.$scrollElement=e(r).is(document.body)?e(window):e(r),this.options=e.extend({},t.DEFAULTS,n),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function r(r){return this.each((function(){var n=e(this),i=n.data("bs.scrollspy"),o="object"==typeof r&&r;i||n.data("bs.scrollspy",i=new t(this,o)),"string"==typeof r&&i[r]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,r="offset",n=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(r="position",n=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),o=/^#./.test(i)&&e(i);return o&&o.length&&o.is(":visible")&&[[o[r]().top+n,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.getScrollHeight(),r=this.options.offset+t-this.$scrollElement.height(),n=this.offsets,i=this.targets,o=this.activeTarget,a;if(this.scrollHeight!=t&&this.refresh(),e>=r)return o!=(a=i[i.length-1])&&this.activate(a);if(o&&e=n[a]&&(void 0===n[a+1]||e .active"),a=i&&e.support.transition&&(o.length&&o.hasClass("fade")||!!n.find("> .fade").length);function s(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),r.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),a?(r[0].offsetWidth,r.addClass("in")):r.removeClass("fade"),r.parent(".dropdown-menu").length&&r.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&a?o.one("bsTransitionEnd",s).emulateTransitionEnd(t.TRANSITION_DURATION):s(),o.removeClass("in")};var n=e.fn.tab;e.fn.tab=r,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=n,this};var i=function(t){t.preventDefault(),r.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(e){"use strict";var t=function(r,n){this.options=e.extend({},t.DEFAULTS,n);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(r),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function r(r){return this.each((function(){var n=e(this),i=n.data("bs.affix"),o="object"==typeof r&&r;i||n.data("bs.affix",i=new t(this,o)),"string"==typeof r&&i[r]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,r,n){var i=this.$target.scrollTop(),o=this.$element.offset(),a=this.$target.height();if(null!=r&&"top"==this.affixed)return i=e-n&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),r=this.$element.offset();return this.pinnedOffset=r.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var r=this.$element.height(),n=this.options.offset,i=n.top,o=n.bottom,a=Math.max(e(document).height(),e(document.body).height());"object"!=typeof n&&(o=i=n),"function"==typeof i&&(i=n.top(this.$element)),"function"==typeof o&&(o=n.bottom(this.$element));var s=this.getState(a,r,i,o);if(this.affixed!=s){null!=this.unpin&&this.$element.css("top","");var u="affix"+(s?"-"+s:""),c=e.Event(u+".bs.affix");if(this.$element.trigger(c),c.isDefaultPrevented())return;this.affixed=s,this.unpin="bottom"==s?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(u).trigger(u.replace("affix","affixed")+".bs.affix")}"bottom"==s&&this.$element.offset({top:a-r-o})}};var n=e.fn.affix;e.fn.affix=r,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=n,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),n=t.data();n.offset=n.offset||{},null!=n.offsetBottom&&(n.offset.bottom=n.offsetBottom),null!=n.offsetTop&&(n.offset.top=n.offsetTop),r.call(t,n)}))}))}(jQuery)}}}},fibers:{"package.json":function e(t,r,e){e.exports={name:"fibers",version:"5.0.3",main:"fibers"}},"fibers.js":function e(t,r,e,n,i){if(process.fiberLib)e.exports=process.fiberLib;else{var o=t("fs"),a=t("path"),s=t("detect-libc");Math.random();var u=a.join(i,"bin",process.platform+"-"+process.arch+"-"+process.versions.modules+("linux"===process.platform?"-"+s.family:""),"fibers");try{process.fiberLib=e.exports=t(u).Fiber}catch(l){throw console.error("## There is an issue with `node-fibers` ##\n`"+u+".node` is missing.\n\nTry running this to fix the issue: "+process.execPath+" "+i.replace(" ","\\ ")+"/build"),console.error(l.stack||l.message||l),new Error("Missing binary. See message above.")}c(e.exports)}function c(e){try{var t=process.binding("async_wrap"),r;if(t.asyncIdStackSize instanceof Function)r=t.asyncIdStackSize;else{if(void 0===t.constants.kStackLength)throw new Error("Couldn't figure out how to get async stack size");f=t.constants.kStackLength,r=function(){return t.async_hook_fields[f]}}var n=t.popAsyncContext||t.popAsyncIds,i=t.pushAsyncContext||t.pushAsyncIds,o,a;if(!n||!i)throw new Error("Push/pop do not exist");o=void 0===t.constants.kExecutionAsyncId?t.constants.kCurrentAsyncId:t.constants.kExecutionAsyncId,a=void 0===t.constants.kTriggerAsyncId?t.constants.kCurrentTriggerId:t.constants.kTriggerAsyncId;var s=t.async_id_fields||t.async_uid_fields;function u(){for(var e=r(),t=new Array(e);e>0;--e){var i=s[o];t[e-1]={asyncId:i,triggerId:s[a]},n(i)}return t}function c(e){for(var t=0;t0)i.changeLanguage(e,n);else if(0!=s[u]){s[u]=0;var c=new XMLHttpRequest;c.overrideMimeType("application/json"),c.open("GET",u,!1),c.send(null),200===c.status?s[u]=1:s[u]=-1,r.addResourceBundle(e,a,JSON.parse(c.response)||{}),i.changeLanguage(e,n)}};r.changeLanguage=p;var b=function(e,t,r){return i.format(e,t,r)};r.format=b;var m=function(){return i.languages};r.getLanguages=m;var g=function(e,t){return i.loadLanguages(e,t)};r.loadLanguages=g;var v=function(e,t){return i.loadNamespaces(e,t)};r.loadNamespaces=v;var y=function(e,t){return i.on(e,t)};r.on=y;var w=function(e,t){return i.off(e,t)};r.off=w,n.__exportStar(t("./i18n/i18n"),r),n.__exportStar(t("./i18n/i18n.app"),r),n.__exportStar(t("./translations"),r)},i18n:{"i18n.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.fallbackKeys=r.getObjectI18nTemplate=r.translationI18nObjects=r.addObjectsI18n=r.translationI18nObject=void 0;var n=t("../index"),i=t("underscore"),o=t("clone"),a="_",s="base",u="core",c="translation",l=function(e,t){var r={lng:t,ns:c};if((0,n.exists)(e,r))return(0,n._t)(e,r)},f=function(e){return"".concat(e,"__object")},d=function(e,t){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t)},h=function(e,t){var r=d(e,t);return"".concat(r).concat("_","inlineHelpText")},p=function(e,t){var r=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","group").concat("_").concat(r)},b=function(e,t,r){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t).concat("_","options").concat("_").concat(r)},m=function(e,t){return"".concat(e).concat("_","action").concat("_").concat(t)},g=function(e,t){return"".concat(e).concat("_","listview").concat("_").concat(t)},v=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},y=function(e,t,r){var n=f(t);return l(n,e)||r||""},w=function(e,t,r,n,i){var o=d(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=w(e,s,r,n,i))}return a||n||""},_=function(e,t,r,n,i){var o=h(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=_(e,s,r,n,i))}return a||n||""},x=function(e,t,r,n){var i=p(t,r);return l(i,e)||n||""},k=function(e,t,r,n,i,o){var a=b(t,r,n),s=l(a,e);if(!s){var u=v(o);u&&"base"!=t&&"core"!=t&&(s=k(e,u,r,n,i,o))}return s||i||""},S=function(e,t,r,n,i){var o=m(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=S(e,s,r,n,i))}return a||n||""},j=function(e,t,r,n,i){var o=g(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=j(e,s,r,n,i))}return a||n||""},A=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},D=function(e){i.forEach(e.fields,(function(e,t){var r=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;return e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return r.push(A(e))}))):r.push(A(e))})),e.options=r}catch(n){console.error("convertFieldsOptions error: ",e.options,n)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return r.push({label:e,value:t})})),e.options=r)}))},E=function(e,t,r){r.label=y(e,t,r.label),i.each(r.fields,(function(n,o){if(n.label=w(e,t,o,n.label,r.datasource),n.inlineHelpText&&(n.inlineHelpText=_(e,t,o,n.inlineHelpText,r.datasource)),n.group&&(n.group=x(e,t,n.group,n.group)),n.options){var a=[];i.each(n.options,(function(n){if(i.has(n,"value")){var s=k(e,t,o,n.value,n.label,r.datasource);a.push(i.extend({},n,{label:s}))}else a.push(n)})),n.options=a}})),i.each(r.actions,(function(n,i){n.label=S(e,t,i,n.label,r.datasource)})),i.each(r.list_views,(function(n,i){n.label=j(e,t,i,n.label,r.datasource)}))};r.translationI18nObject=E;var O=function(e){i.each(e,(function(e){(0,n.addResourceBundle)(e.lng,c,e.data,!0,!0)}))};r.addObjectsI18n=O;var C=function(e,t){i.each(t,(function(t,n){(0,r.translationI18nObject)(e,n,t)}))};r.translationI18nObjects=C;var T=function(e,t,r){var n=o(r);D(n);var a={};return a[f(t)]=y(e,t,n.label),i.each(n.fields,(function(r,o){a[d(t,o)]=w(e,t,o,r.label),r.inlineHelpText&&(a[h(t,o)]=_(e,t,o,r.inlineHelpText,n.datasource)),r.group&&(a[p(t,r.group)]=x(e,t,r.group,r.group)),r.options&&i.each(r.options,(function(r){i.has(r,"value")&&(a[b(t,o,r.value)]=k(e,t,o,r.value,r.label))}))})),i.each(n.actions,(function(r,n){a[m(t,n)]=S(e,t,n,r.label)})),i.each(n.list_views,(function(r,n){a[g(t,n)]=j(e,t,n,r.label)})),a};r.getObjectI18nTemplate=T,r.fallbackKeys={getObjectLabelKey:f,getObjectFieldLabelKey:d,getObjectFieldInlineHelpTextLabelKey:h,getObjectFieldGroupKey:p,getObjectFieldOptionsLabelKey:b,getObjectActionLabelKey:m,getObjectListviewLabelKey:g}},"i18n.app.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.appFallbackKeys=r.getAppI18nTemplate=r.translationI18nApps=r.translationI18nMenus=void 0;var n=t("../index"),i=t("underscore"),o=t("clone"),a="translation",s="_",u=function(e,t){var r={lng:t,ns:a};if((0,n.exists)(e,r))return(0,n._t)(e,r)},c=function(e){return"app".concat("_").concat(e).concat("_","name")},l=function(e){return"app".concat("_").concat(e).concat("_","description")},f=function(e,t){var r=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","tab_group").concat("_").concat(r)},d=function(e){return"menu".concat("_").concat(e)},h=function(e){return"tab".concat("_").concat(e)},p=function(e,t,r){var n=c(t);return u(n,e)||r||""},b=function(e,t,r){var n=l(t);return u(n,e)||r||""},m=function(e,t,r){var n=d(t);return u(n,e)||r||""},g=function(e,t,n){n.label=p(e,t,n.label||n.name),n.description=b(e,t,n.description),(0,r.translationI18nMenus)(e,n.admin_menus)},v=function(e,t){i.each(t,(function(t){var r=m(e,t._id,t.label||t.name);t.label=r,t.name=r}))};r.translationI18nMenus=v;var y=function(e,t){i.each(t,(function(t,r){g(e,r,t)}))};r.translationI18nApps=y;var w=function(e,t,r){var n=o(r),a={};return a[c(t)]=p(e,t,n.label||n.name),a[l(t)]=b(e,t,n.description),i.each(n.admin_menus,(function(t){a[d(t._id)]=m(e,t._id,t.label||t.name)})),a};r.getAppI18nTemplate=w,r.appFallbackKeys={getAppLabelKey:c,getAppDescriptionKey:l,getAppGroupKey:f,getMenuLabelKey:d,getTabKey:h}}},translations:{"index.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.SteedosTranslationPrefixKeys=r.convertObject=void 0;var n=t("tslib"),i=t("underscore");n.__exportStar(t("./objectTranslation"),r),n.__exportStar(t("./translation"),r),n.__exportStar(t("./templates/objectTranslation"),r),n.__exportStar(t("./templates/translation"),r);var o=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},a=function(e){i.forEach(e.fields,(function(e,t){var r=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return r.push(o(e))}))):r.push(o(e))})),e.options=r}catch(n){console.error("convertFieldsOptions error: ",e.options,n)}else if(e.options&&i.isArray(e.options))try{i.forEach(e.options,(function(e){i.isString(e)?r.push(o(e)):r.push(e)})),e.options=r}catch(n){console.error("Creator.convertFieldsOptions",e.options,n)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return r.push({label:e,value:t})})),e.options=r)}))},s;r.convertObject=a,function(e){e.Object="CustomObject",e.Field="CustomField",e.Action="CustomAction",e.Listview="CustomListview",e.Permission="CustomPermission",e.ValidationRule="CustomValidationRule",e.Application="CustomApplication",e.Tab="CustomTabs",e.Permissionset="CustomPermissionset",e.Profile="CustomProfile",e.Report="CustomReport",e.Workflow="Workflow",e.Layout="Layout",e.Client="Client",e.Server="Server",e.Function="Function",e.Router="Router",e.Trigger="Trigger"}(s=r.SteedosTranslationPrefixKeys||(r.SteedosTranslationPrefixKeys={}))},"objectTranslation.js":function e(t,r,e,n){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.addObjectsTranslation=r.getObjectTranslationTemplate=r.translationObjects=r.translationObject=r.translationObjectLabel=void 0;var i=t("underscore"),o=t("./"),a=t("../index"),s=t("./index"),u=t("../i18n/i18n"),c=t("lodash"),l=t("crypto"),f,d=(0,t("@steedos/cachers").getCacher)("lru.translations.objects");function h(e){var t;return l.createHash("md5").update(e).digest("hex")}var p=function(e,t){return"".concat(e,"_").concat(t.name,"_").concat(h(JSON.stringify(t)))},b=t("clone"),m=".",g="base",v="core",y="translation",w="object",_="field",x="listview",k="action",S=function(e,t){var r={lng:t,ns:y,keySeparator:!1};if((0,a.exists)(e,r))return(0,a._t)(e,r)},j=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},A=function(e){switch(e){case"object":return o.SteedosTranslationPrefixKeys.Object;case"field":return o.SteedosTranslationPrefixKeys.Field;case"listview":return o.SteedosTranslationPrefixKeys.Listview;case"action":return o.SteedosTranslationPrefixKeys.Action;default:return"CustomLabels"}},D=function(e){var t;return[A(),e].join(".")},E=function(e){var t;return[A("object"),e,"label"].join(".")},O=function(e){var t;return[A("object"),e,"description"].join(".")},C=function(e,t){var r;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"label"].join(".")},T=function(e,t){var r;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"help"].join(".")},M=function(e,t){var r;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"description"].join(".")},B=function(e,t){var r=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_"),n;return[A("field"),e,"group",r].join(".")},I=function(e,t,r){var n;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"options",r].join(".")},R=function(e,t){var r;return[A("action"),e,t].join(".")},N=function(e,t){var r;return[A("listview"),e,t].join(".")},F=function(e,t,r){var n,i=[E(t)],o=u.fallbackKeys.getObjectLabelKey(t);return o&&i.push(o),S(i,e)||r||""};r.translationObjectLabel=F;var L=function(e,t,r){var n=O(t);return S(n,e)||r||""},P=function(e,t,r,n,i,o){var a,s=[C(t,r)],c=u.fallbackKeys.getObjectFieldLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=P(e,f,r,n,i))}return l||n||""},q=function(e,t,r,n,i,o){var a,s=[T(t,r)],c=u.fallbackKeys.getObjectFieldInlineHelpTextLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=q(e,f,r,n,i))}return l||n||""},z=function(e,t,r,n,i,o){var a=M(t,r),s,u=S([a],e);if(1!=o&&!u){var c=j(i);c&&"base"!=t&&"core"!=t&&(u=z(e,c,r,n,i))}return u||n||""},U=function(e,t,r,n,i,o){var a,s=[B(t,r)],c=u.fallbackKeys.getObjectFieldGroupKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=U(e,f,r,n,i))}return l||n||""},$=function(e,t,r,n,i,o,a){var s,c=[I(t,r,n)],l=u.fallbackKeys.getObjectFieldOptionsLabelKey(t,r,n);l&&c.push(l);var f=S(c,e);if(1!=a&&!f){var d=j(o);d&&"base"!=t&&"core"!=t&&(f=$(e,d,r,n,i,o))}return f||i||""},H=function(e,t,r,n,i,o){var a,s=[R(t,r)],c=u.fallbackKeys.getObjectActionLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=H(e,f,r,n,i))}return l||n||""},W=function(e,t,r,n,i,o){var a,s=[N(t,r)],c=u.fallbackKeys.getObjectListviewLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=W(e,f,r,n,i))}return l||n||""},Y=function(e,t,n,o,a){void 0===a&&(a=!1);var u=p(e,n),l=d.get(u);if(l)return Object.assign(n,(0,c.cloneDeep)(l));o&&(0,s.convertObject)(n),n.label=(0,r.translationObjectLabel)(e,t,n.label),n.description=L(e,t,n.description),i.each(n.fields,(function(r,o){if(r.label=P(e,t,o,r.label,n.datasource,a),r.inlineHelpText=q(e,t,o,r.inlineHelpText,n.datasource,a),r.description=z(e,t,o,r.description,n.datasource,a),r.group&&(r.group=U(e,t,r.group,r.group,n.datasource,a)),r.options){var s=[];i.each(r.options,(function(r){if(i.has(r,"value")){var u=$(e,t,o,r.value,r.label,n.datasource,a);s.push(i.extend({},r,{label:u}))}else s.push(r)})),r.options=s}})),i.each(n.actions,(function(r,i){r.label=H(e,t,i,r.label,n.datasource,a)})),i.each(n.list_views,(function(r,i){r.label=W(e,t,i,r.label,n.datasource,a)})),d.set(u,(0,c.cloneDeep)(n))};r.translationObject=Y;var V=function(e,t){i.each(t,(function(t,n){(0,r.translationObject)(e,n,t)}))};r.translationObjects=V;var K=function(e,t,n){var o=b(n);(0,s.convertObject)(o);var a={};return a[E(t)]=(0,r.translationObjectLabel)(e,t,o.label),a[O(t)]=L(e,t,o.description),i.each(o.fields,(function(r,n){a[C(t,n)]=P(e,t,n,r.label),r.inlineHelpText&&(a[T(t,n)]=q(e,t,n,r.inlineHelpText,o.datasource)),r.description&&(a[M(t,n)]=z(e,t,n,r.description,o.datasource)),r.group&&(a[B(t,r.group)]=U(e,t,r.group,r.group,o.datasource)),r.options&&i.each(r.options,(function(r){i.has(r,"value")&&(a[I(t,n,r.value)]=$(e,t,n,r.value,r.label))}))})),i.each(o.actions,(function(r,n){a[R(t,n)]=H(e,t,n,r.label)})),i.each(o.list_views,(function(r,n){a[N(t,n)]=W(e,t,n,r.label)})),a};function G(e,t){var r=b(e);(0,s.convertObject)(r);var n={},o=r.name;return o||console.error("Error: Invalid objectTranslation:"+t),n[E(o)]=r.label,n[O(o)]=r.description,i.each(r.fields,(function(e,t){n[C(o,t)]=e.label,e.help&&(n[T(o,t)]=e.help),e.description&&(n[M(o,t)]=e.description),e.options&&i.each(e.options,(function(e){i.has(e,"value")&&(n[I(o,t,e.value)]=e.label)}))})),i.each(r.groups,(function(e,t){n[B(o,t)]=e})),i.each(r.actions,(function(e,t){n[R(o,t)]=e.label})),i.each(r.listviews,(function(e,t){n[N(o,t)]=e.label})),i.each(r.CustomLabels,(function(e,t){n[D(t)]=e})),n}r.getObjectTranslationTemplate=K;var X=function(e){i.each(e,(function(e){var t=G(e.data,e.__filename);(0,a.addResourceBundle)(e.lng,y,t,!0,!0)}))};r.addObjectsTranslation=X},"translation.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.addTranslations=r.convertTranslation=r.convertTranslationData=r.getAppTranslationTemplate=r.translationApps=r.translationMenus=r.translationApp=r.translationTabLabel=r.translationTabGroup=void 0;var n=t("../index"),i=t("underscore"),o=t("./"),a=t("../i18n/i18n.app"),s=t("clone"),u="translation",c=".",l="app",f="menu",d="tab",h=function(e){switch(e){case"app":return o.SteedosTranslationPrefixKeys.Application;case"tab":return o.SteedosTranslationPrefixKeys.Tab;default:return"CustomLabels"}},p=function(e){var t;return[h(),e].join(".")},b=function(e,t){var r={lng:t,ns:u,keySeparator:!1};if((0,n.exists)(e,r))return(0,n._t)(e,r)},m=function(e){var t;return[h("app"),e,"name"].join(".")},g=function(e){var t;return[h("app"),e,"description"].join(".")},v=function(e,t){var r,n;return[h("app"),e,"groups",t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_")].join(".")},y=function(e){var t;return[h("menu"),"menu_".concat(e)].join(".")},w=function(e){var t;return[h("tab"),e].join(".")},_=function(e,t,r){var n,i=[m(t)],o=a.appFallbackKeys.getAppLabelKey(t);return o&&i.push(o),b(i,e)||r||""},x=function(e,t,r){var n,i=[g(t)],o=a.appFallbackKeys.getAppDescriptionKey(t);return o&&i.push(o),b(i,e)||r||""},k=function(e,t,r,n){var i,o=[v(t,r)],s=a.appFallbackKeys.getAppGroupKey(t,r);return s&&o.push(s),b(o,e)||n||""};r.translationTabGroup=k;var S=function(e,t,r){var n,i=[y(t)],o=a.appFallbackKeys.getMenuLabelKey(t);return o&&i.push(o),b(i,e)||r||""},j=function(e,t,r){var n,i=[w(t)],o=a.appFallbackKeys.getTabKey(t);return o&&i.push(o),b(i,e)||r||""};r.translationTabLabel=j;var A=function(e,t,n){n.label=_(e,t,n.label||n.name),n.description=x(e,t,n.description),i.each(n.tab_groups,(function(i,o){n.tab_groups[o].id=i.id||i.group_name,n.tab_groups[o].group_name=(0,r.translationTabGroup)(e,t,i.group_name,i.group_name)})),(0,r.translationMenus)(e,n.admin_menus)};r.translationApp=A;var D=function(e,t){i.each(t,(function(t){var r=S(e,t._id,t.label||t.name);t.label=r,t.name=r}))};r.translationMenus=D;var E=function(e,t){i.each(t,(function(t,n){(0,r.translationApp)(e,n,t)}))};r.translationApps=E;var O=function(e,t,r){var n=s(r),o={};return o[m(t)]=_(e,t,n.label||n.name),o[g(t)]=x(e,t,n.description),i.each(n.admin_menus,(function(t){o[y(t._id)]=S(e,t._id,t.label||t.name)})),o};r.getAppTranslationTemplate=O;var C=function(e,t,r){i.isArray(r)?i.each(r,(function(e){C(e,"",e)})):r&&i.each(i.keys(r),(function(n){var o=t?"".concat(t,".").concat(n):n,a=r[n];"object"==typeof a?i.isArray(a)?i.each(a,(function(e){C(e,o,a)})):C(e,o,a):e[o]=a}))};function T(e){for(var t in e)"object"==typeof e[t]&&C(e,t,e[t]);return e}r.convertTranslationData=T;var M=function(e){var t=s(e),r={};return i.each(t.CustomApplications,(function(e,t){r[m(t)]=e.name,r[g(t)]=e.description,i.each(e.groups,(function(e,n){r[v(t,n)]=e}))})),i.each(t.CustomTabs,(function(e,t){r[w(t)]=e})),i.each(t.CustomLabels,(function(e,t){var n;if("simpleschema"!=t&&i.isObject(e)){var o=T(((n={})[t]=e,n));i.each(o,(function(e,t){i.isObject(e)||(r[p(t)]=e)}))}else r[p(t)]=e})),r};r.convertTranslation=M;var B=function(e){i.each(e,(function(e){var t=(0,r.convertTranslation)(e.data);(0,n.addResourceBundle)(e.lng,u,t,!0,!0)}))};r.addTranslations=B},templates:{"objectTranslation.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.getObjectMetadataTranslationTemplate=void 0;var n=t("underscore"),i=t("../index"),o=t("clone");function a(e,t){var r={};return n.each(e,(function(e){r[e]="help"===e?t.inlineHelpText||"":t[e]||""})),r}function s(e){return a(["label","description"],e)}function u(e){switch(e.type){case"select":return a(["label","help","options","description"],e);default:return a(["label","help","description"],e)}}function c(e){return a(["label"],e)}function l(e){return a(["label"],e)}function f(e){var t={};return n.each(e,(function(e,r){t[r]=u(e)})),t}function d(e){var t={};return n.each(e,(function(e,r){t[r]=l(e)})),t}function h(e){var t={};return n.each(e,(function(e,r){t[r]=c(e)})),t}function p(e,t){var r={};return n.each(e,(function(e,n){if(e.group){var i=e.group.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");r[i]=t[n].group}})),r}var b=function(e,t,r,a){void 0===a&&(a=!1);var u=o(r);1!=a&&(0,i.translationObject)(e,t,u,!0,a);var c=Object.assign({},s(u));c=Object.assign({},c,{fields:f(u.fields)});var l=p(r.fields,u.fields);n.isEmpty(l)||(c=Object.assign({},c,{groups:l}));var b=h(u.list_views);n.isEmpty(b)||(c=Object.assign({},c,{listviews:b}));var m=d(u.actions);return n.isEmpty(m)||(c=Object.assign({},c,{actions:m})),Object.assign({name:t},c)};r.getObjectMetadataTranslationTemplate=b},"translation.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.getAppMetadataTranslationTemplate=void 0;var n=t("underscore"),i=t("../index"),o=t("clone");function a(e,t){var r={};return n.each(e,(function(e){r[e]=t[e]||""})),r}function s(e){var t={groups:{}};return e?(n.each(e,(function(e){var r=e.group_name.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t.groups[r]=e.group_name})),t):{}}var u=function(e){return Object.assign({},a(["name","description"],e),s(e.tab_groups))},c=function(e){var t={};return n.each(e,(function(e,r){t[r]=r})),t},l=function(e){var t={};return n.each(e,(function(e){var r=e.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t[r]=e})),t},f=function(e,t,r){var n,a=o(r);(0,i.translationApp)(e,t,a);var s={},f;return a.tab_items?s=c(a.tab_items):a.tabs&&(s=l(a.tabs)),Object.assign({},{CustomApplications:(n={},n[t]=u(a),n)},{CustomTabs:s})};r.getAppMetadataTranslationTemplate=f}}}},node_modules:{i18next:{"package.json":function e(t,r,e){e.exports={name:"i18next",version:"19.9.2",main:"./dist/cjs/i18next.js",module:"./dist/esm/i18next.js"}},dist:{cjs:{"i18next.js":function e(t,r,e){"use strict";var n=t("@babel/runtime/helpers/typeof"),i=t("@babel/runtime/helpers/objectSpread"),o=t("@babel/runtime/helpers/classCallCheck"),a=t("@babel/runtime/helpers/createClass"),s=t("@babel/runtime/helpers/possibleConstructorReturn"),u=t("@babel/runtime/helpers/getPrototypeOf"),c=t("@babel/runtime/helpers/assertThisInitialized"),l=t("@babel/runtime/helpers/inherits");function f(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var d=f(n),h=f(i),p=f(o),b=f(a),m=f(s),g=f(u),v=f(c),y=f(l),w={type:"logger",log:function e(t){this.output("log",t)},warn:function e(t){this.output("warn",t)},error:function e(t){this.output("error",t)},output:function e(t,r){console&&console[t]&&console[t].apply(console,r)}},_,x=new(function(){function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};p.default(this,e),this.init(t,r)}return b.default(e,[{key:"init",value:function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=r.prefix||"i18next:",this.logger=t||w,this.options=r,this.debug=r.debug}},{key:"setDebug",value:function e(t){this.debug=t}},{key:"log",value:function e(){for(var t=arguments.length,r=new Array(t),n=0;n1?r-1:0),i=1;i-1?e.replace(/###/g,"."):e}function i(){return!e||"string"==typeof e}for(var o="string"!=typeof t?[].concat(t):t.split(".");o.length>1;){if(i())return{};var a=n(o.shift());!e[a]&&r&&(e[a]=new r),e=Object.prototype.hasOwnProperty.call(e,a)?e[a]:{}}return i()?{}:{obj:e,k:n(o.shift())}}function E(e,t,r){var n=D(e,t,Object),i,o;n.obj[n.k]=r}function O(e,t,r,n){var i=D(e,t,Object),o=i.obj,a=i.k;o[a]=o[a]||[],n&&(o[a]=o[a].concat(r)),n||o[a].push(r)}function C(e,t){var r=D(e,t),n=r.obj,i=r.k;if(n)return n[i]}function T(e,t,r){var n=C(e,r);return void 0!==n?n:C(t,r)}function M(e,t,r){for(var n in t)"__proto__"!==n&&"constructor"!==n&&(n in e?"string"==typeof e[n]||e[n]instanceof String||"string"==typeof t[n]||t[n]instanceof String?r&&(e[n]=t[n]):M(e[n],t[n],r):e[n]=t[n]);return e}function B(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var I={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};function R(e){return"string"==typeof e?e.replace(/[&<>"'\/]/g,(function(e){return I[e]})):e}var N="undefined"!=typeof window&&window.navigator&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,F=function(e){function t(e){var r,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return p.default(this,t),r=m.default(this,g.default(t).call(this)),N&&k.call(v.default(r)),r.data=e||{},r.options=n,void 0===r.options.keySeparator&&(r.options.keySeparator="."),r}return y.default(t,e),b.default(t,[{key:"addNamespaces",value:function e(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function e(t){var r=this.options.ns.indexOf(t);r>-1&&this.options.ns.splice(r,1)}},{key:"getResource",value:function e(t,r,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==i.keySeparator?i.keySeparator:this.options.keySeparator,a=[t,r];return n&&"string"!=typeof n&&(a=a.concat(n)),n&&"string"==typeof n&&(a=a.concat(o?n.split(o):n)),t.indexOf(".")>-1&&(a=t.split(".")),C(this.data,a)}},{key:"addResource",value:function e(t,r,n,i){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},a=this.options.keySeparator;void 0===a&&(a=".");var s=[t,r];n&&(s=s.concat(a?n.split(a):n)),t.indexOf(".")>-1&&(i=r,r=(s=t.split("."))[1]),this.addNamespaces(r),E(this.data,s,i),o.silent||this.emit("added",t,r,n,i)}},{key:"addResources",value:function e(t,r,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in n)"string"!=typeof n[o]&&"[object Array]"!==Object.prototype.toString.apply(n[o])||this.addResource(t,r,o,n[o],{silent:!0});i.silent||this.emit("added",t,r,n)}},{key:"addResourceBundle",value:function e(t,r,n,i,o){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},s=[t,r];t.indexOf(".")>-1&&(i=n,n=r,r=(s=t.split("."))[1]),this.addNamespaces(r);var u=C(this.data,s)||{};i?M(u,n,o):u=h.default({},u,n),E(this.data,s,u),a.silent||this.emit("added",t,r,n)}},{key:"removeResourceBundle",value:function e(t,r){this.hasResourceBundle(t,r)&&delete this.data[t][r],this.removeNamespaces(r),this.emit("removed",t,r)}},{key:"hasResourceBundle",value:function e(t,r){return void 0!==this.getResource(t,r)}},{key:"getResourceBundle",value:function e(t,r){return r||(r=this.options.defaultNS),"v1"===this.options.compatibilityAPI?h.default({},{},this.getResource(t,r)):this.getResource(t,r)}},{key:"getDataByLanguage",value:function e(t){return this.data[t]}},{key:"toJSON",value:function e(){return this.data}}]),t}(k),L={processors:{},addPostProcessor:function e(t){this.processors[t.name]=t},handle:function e(t,r,n,i,o){var a=this;return t.forEach((function(e){a.processors[e]&&(r=a.processors[e].process(r,n,i,o))})),r}},P={},q=function(e){function t(e){var r,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return p.default(this,t),r=m.default(this,g.default(t).call(this)),N&&k.call(v.default(r)),A(["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],e,v.default(r)),r.options=n,void 0===r.options.keySeparator&&(r.options.keySeparator="."),r.logger=x.create("translator"),r}return y.default(t,e),b.default(t,[{key:"changeLanguage",value:function e(t){t&&(this.language=t)}},{key:"exists",value:function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}},n=this.resolve(t,r);return n&&void 0!==n.res}},{key:"extractFromKey",value:function e(t,r){var n=void 0!==r.nsSeparator?r.nsSeparator:this.options.nsSeparator;void 0===n&&(n=":");var i=void 0!==r.keySeparator?r.keySeparator:this.options.keySeparator,o=r.ns||this.options.defaultNS;if(n&&t.indexOf(n)>-1){var a=t.match(this.interpolator.nestingRegexp);if(a&&a.length>0)return{key:t,namespaces:o};var s=t.split(n);(n!==i||n===i&&this.options.ns.indexOf(s[0])>-1)&&(o=s.shift()),t=s.join(i)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function e(r,n,i){var o=this;if("object"!==d.default(n)&&this.options.overloadTranslationOptionHandler&&(n=this.options.overloadTranslationOptionHandler(arguments)),n||(n={}),null==r)return"";Array.isArray(r)||(r=[String(r)]);var a=void 0!==n.keySeparator?n.keySeparator:this.options.keySeparator,s=this.extractFromKey(r[r.length-1],n),u=s.key,c=s.namespaces,l=c[c.length-1],f=n.lng||this.language,p=n.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(f&&"cimode"===f.toLowerCase()){if(p){var b=n.nsSeparator||this.options.nsSeparator;return l+b+u}return u}var m=this.resolve(r,n),g=m&&m.res,v=m&&m.usedKey||u,y=m&&m.exactUsedKey||u,w=Object.prototype.toString.apply(g),_=["[object Number]","[object Function]","[object RegExp]"],x=void 0!==n.joinArrays?n.joinArrays:this.options.joinArrays,k=!this.i18nFormat||this.i18nFormat.handleAsObject,S="string"!=typeof g&&"boolean"!=typeof g&&"number"!=typeof g;if(k&&g&&S&&_.indexOf(w)<0&&("string"!=typeof x||"[object Array]"!==w)){if(!n.returnObjects&&!this.options.returnObjects)return this.logger.warn("accessing an object - but returnObjects options is not enabled!"),this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,g,n):"key '".concat(u," (").concat(this.language,")' returned an object instead of string.");if(a){var j="[object Array]"===w,A=j?[]:{},D=j?y:v;for(var E in g)if(Object.prototype.hasOwnProperty.call(g,E)){var O="".concat(D).concat(a).concat(E);A[E]=this.translate(O,h.default({},n,{joinArrays:!1,ns:c})),A[E]===O&&(A[E]=g[E])}g=A}}else if(k&&"string"==typeof x&&"[object Array]"===w)(g=g.join(x))&&(g=this.extendTranslation(g,r,n,i));else{var C=!1,T=!1,M=void 0!==n.count&&"string"!=typeof n.count,B=t.hasDefaultValue(n),I=M?this.pluralResolver.getSuffix(f,n.count):"",R=n["defaultValue".concat(I)]||n.defaultValue;!this.isValidLookup(g)&&B&&(C=!0,g=R),this.isValidLookup(g)||(T=!0,g=u);var N=B&&R!==g&&this.options.updateMissing;if(T||C||N){if(this.logger.log(N?"updateKey":"missingKey",f,l,u,N?R:g),a){var F=this.resolve(u,h.default({},n,{keySeparator:!1}));F&&F.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var L=[],P=this.languageUtils.getFallbackCodes(this.options.fallbackLng,n.lng||this.language);if("fallback"===this.options.saveMissingTo&&P&&P[0])for(var q=0;q1&&void 0!==arguments[1]?arguments[1]:{},i,o,a,s,u;return"string"==typeof t&&(t=[t]),t.forEach((function(e){if(!r.isValidLookup(i)){var t=r.extractFromKey(e,n),c=t.key;o=c;var l=t.namespaces;r.options.fallbackNS&&(l=l.concat(r.options.fallbackNS));var f=void 0!==n.count&&"string"!=typeof n.count,d=void 0!==n.context&&"string"==typeof n.context&&""!==n.context,h=n.lngs?n.lngs:r.languageUtils.toResolveHierarchy(n.lng||r.language,n.fallbackLng);l.forEach((function(e){r.isValidLookup(i)||(u=e,!P["".concat(h[0],"-").concat(e)]&&r.utils&&r.utils.hasLoadedNamespace&&!r.utils.hasLoadedNamespace(u)&&(P["".concat(h[0],"-").concat(e)]=!0,r.logger.warn('key "'.concat(o,'" for languages "').concat(h.join(", "),'" won\'t get resolved as namespace "').concat(u,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),h.forEach((function(t){if(!r.isValidLookup(i)){s=t;var o=c,u=[o],l,h;if(r.i18nFormat&&r.i18nFormat.addLookupKeys)r.i18nFormat.addLookupKeys(u,c,t,e,n);else f&&(l=r.pluralResolver.getSuffix(t,n.count)),f&&d&&u.push(o+l),d&&u.push(o+="".concat(r.options.contextSeparator).concat(n.context)),f&&u.push(o+=l);for(;h=u.pop();)r.isValidLookup(i)||(a=h,i=r.getResource(t,e,h,n))}})))}))}})),{res:i,usedKey:o,exactUsedKey:a,usedLng:s,usedNS:u}}},{key:"isValidLookup",value:function e(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function e(t,r,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,r,n,i):this.resourceStore.getResource(t,r,n,i)}}],[{key:"hasDefaultValue",value:function e(t){var r="defaultValue";for(var n in t)if(Object.prototype.hasOwnProperty.call(t,n)&&r===n.substring(0,r.length)&&void 0!==t[n])return!0;return!1}}]),t}(k);function z(e){return e.charAt(0).toUpperCase()+e.slice(1)}var U=function(){function e(t){p.default(this,e),this.options=t,this.whitelist=this.options.supportedLngs||!1,this.supportedLngs=this.options.supportedLngs||!1,this.logger=x.create("languageUtils")}return b.default(e,[{key:"getScriptPartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return null;var r=t.split("-");return 2===r.length?null:(r.pop(),"x"===r[r.length-1].toLowerCase()?null:this.formatLanguageCode(r.join("-")))}},{key:"getLanguagePartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return t;var r=t.split("-");return this.formatLanguageCode(r[0])}},{key:"formatLanguageCode",value:function e(t){if("string"==typeof t&&t.indexOf("-")>-1){var r=["hans","hant","latn","cyrl","cans","mong","arab"],n=t.split("-");return this.options.lowerCaseLng?n=n.map((function(e){return e.toLowerCase()})):2===n.length?(n[0]=n[0].toLowerCase(),n[1]=n[1].toUpperCase(),r.indexOf(n[1].toLowerCase())>-1&&(n[1]=z(n[1].toLowerCase()))):3===n.length&&(n[0]=n[0].toLowerCase(),2===n[1].length&&(n[1]=n[1].toUpperCase()),"sgn"!==n[0]&&2===n[2].length&&(n[2]=n[2].toUpperCase()),r.indexOf(n[1].toLowerCase())>-1&&(n[1]=z(n[1].toLowerCase())),r.indexOf(n[2].toLowerCase())>-1&&(n[2]=z(n[2].toLowerCase()))),n.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isWhitelisted",value:function e(t){return this.logger.deprecate("languageUtils.isWhitelisted",'function "isWhitelisted" will be renamed to "isSupportedCode" in the next major - please make sure to rename it\'s usage asap.'),this.isSupportedCode(t)}},{key:"isSupportedCode",value:function e(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function e(t){var r=this,n;return t?(t.forEach((function(e){if(!n){var t=r.formatLanguageCode(e);r.options.supportedLngs&&!r.isSupportedCode(t)||(n=t)}})),!n&&this.options.supportedLngs&&t.forEach((function(e){if(!n){var t=r.getLanguagePartFromCode(e);if(r.isSupportedCode(t))return n=t;n=r.options.supportedLngs.find((function(e){if(0===e.indexOf(t))return e}))}})),n||(n=this.getFallbackCodes(this.options.fallbackLng)[0]),n):null}},{key:"getFallbackCodes",value:function e(t,r){if(!t)return[];if("function"==typeof t&&(t=t(r)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!r)return t.default||[];var n=t[r];return n||(n=t[this.getScriptPartFromCode(r)]),n||(n=t[this.formatLanguageCode(r)]),n||(n=t[this.getLanguagePartFromCode(r)]),n||(n=t.default),n||[]}},{key:"toResolveHierarchy",value:function e(t,r){var n=this,i=this.getFallbackCodes(r||this.options.fallbackLng||[],t),o=[],a=function e(t){t&&(n.isSupportedCode(t)?o.push(t):n.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&a(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&a(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&a(this.getLanguagePartFromCode(t))):"string"==typeof t&&a(this.formatLanguageCode(t)),i.forEach((function(e){o.indexOf(e)<0&&a(n.formatLanguageCode(e))})),o}}]),e}(),$=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","kk","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],H={1:function e(t){return Number(t>1)},2:function e(t){return Number(1!=t)},3:function e(t){return 0},4:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function e(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function e(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function e(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function e(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function e(t){return Number(t>=2)},10:function e(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function e(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function e(t){return Number(t%10!=1||t%100==11)},13:function e(t){return Number(0!==t)},14:function e(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function e(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function e(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function e(t){return Number(0==t?0:1==t?1:2)},19:function e(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function e(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function e(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function e(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}};function W(){var e={};return $.forEach((function(t){t.lngs.forEach((function(r){e[r]={numbers:t.nr,plurals:H[t.fc]}}))})),e}var Y=function(){function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};p.default(this,e),this.languageUtils=t,this.options=r,this.logger=x.create("pluralResolver"),this.rules=W()}return b.default(e,[{key:"addRule",value:function e(t,r){this.rules[t]=r}},{key:"getRule",value:function e(t){return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function e(t){var r=this.getRule(t);return r&&r.numbers.length>1}},{key:"getPluralFormsOfKey",value:function e(t,r){return this.getSuffixes(t).map((function(e){return r+e}))}},{key:"getSuffixes",value:function e(t){var r=this,n=this.getRule(t);return n?n.numbers.map((function(e){return r.getSuffix(t,e)})):[]}},{key:"getSuffix",value:function e(t,r){var n=this,i=this.getRule(t);if(i){var o=i.noAbs?i.plurals(r):i.plurals(Math.abs(r)),a=i.numbers[o];this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]&&(2===a?a="plural":1===a&&(a=""));var s=function e(){return n.options.prepend&&a.toString()?n.options.prepend+a.toString():a.toString()};return"v1"===this.options.compatibilityJSON?1===a?"":"number"==typeof a?"_plural_".concat(a.toString()):s():"v2"===this.options.compatibilityJSON?s():this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]?s():this.options.prepend&&o.toString()?this.options.prepend+o.toString():o.toString()}return this.logger.warn("no plural rule found for: ".concat(t)),""}}]),e}(),V=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};p.default(this,e),this.logger=x.create("interpolator"),this.options=t,this.format=t.interpolation&&t.interpolation.format||function(e){return e},this.init(t)}return b.default(e,[{key:"init",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var r=t.interpolation;this.escape=void 0!==r.escape?r.escape:R,this.escapeValue=void 0===r.escapeValue||r.escapeValue,this.useRawValueToEscape=void 0!==r.useRawValueToEscape&&r.useRawValueToEscape,this.prefix=r.prefix?B(r.prefix):r.prefixEscaped||"{{",this.suffix=r.suffix?B(r.suffix):r.suffixEscaped||"}}",this.formatSeparator=r.formatSeparator?r.formatSeparator:r.formatSeparator||",",this.unescapePrefix=r.unescapeSuffix?"":r.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":r.unescapeSuffix||"",this.nestingPrefix=r.nestingPrefix?B(r.nestingPrefix):r.nestingPrefixEscaped||B("$t("),this.nestingSuffix=r.nestingSuffix?B(r.nestingSuffix):r.nestingSuffixEscaped||B(")"),this.nestingOptionsSeparator=r.nestingOptionsSeparator?r.nestingOptionsSeparator:r.nestingOptionsSeparator||",",this.maxReplaces=r.maxReplaces?r.maxReplaces:1e3,this.alwaysFormat=void 0!==r.alwaysFormat&&r.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function e(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function e(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var r="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(r,"g");var n="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(n,"g")}},{key:"interpolate",value:function e(t,r,n,i){var o=this,a,s,u,c=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function l(e){return e.replace(/\$/g,"$$$$")}var f=function e(t){if(t.indexOf(o.formatSeparator)<0){var a=T(r,c,t);return o.alwaysFormat?o.format(a,void 0,n):a}var s=t.split(o.formatSeparator),u=s.shift().trim(),l=s.join(o.formatSeparator).trim();return o.format(T(r,c,u),l,n,i)};this.resetRegExp();var d=i&&i.missingInterpolationHandler||this.options.missingInterpolationHandler,h=i&&i.interpolation&&i.interpolation.skipOnVariables||this.options.interpolation.skipOnVariables,p;return[{regex:this.regexpUnescape,safeValue:function e(t){return l(t)}},{regex:this.regexp,safeValue:function e(t){return o.escapeValue?l(o.escape(t)):l(t)}}].forEach((function(e){for(u=0;a=e.regex.exec(t);){if(void 0===(s=f(a[1].trim())))if("function"==typeof d){var r=d(t,a,i);s="string"==typeof r?r:""}else{if(h){s=a[0];continue}o.logger.warn("missed to pass in variable ".concat(a[1]," for interpolating ").concat(t)),s=""}else"string"==typeof s||o.useRawValueToEscape||(s=j(s));if(t=t.replace(a[0],e.safeValue(s)),e.regex.lastIndex=0,++u>=o.maxReplaces)break}})),t}},{key:"nest",value:function e(t,r){var n=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o,a,s=h.default({},i);function u(e,t){var r=this.nestingOptionsSeparator;if(e.indexOf(r)<0)return e;var n=e.split(new RegExp("".concat(r,"[ ]*{"))),i="{".concat(n[1]);e=n[0],i=(i=this.interpolate(i,s)).replace(/'/g,'"');try{s=JSON.parse(i),t&&(s=h.default({},t,s))}catch(o){return this.logger.warn("failed parsing options string in nesting for key ".concat(e),o),"".concat(e).concat(r).concat(i)}return delete s.defaultValue,e}for(s.applyPostProcessor=!1,delete s.defaultValue;o=this.nestingRegexp.exec(t);){var c=[],l=!1;if(o[0].includes(this.formatSeparator)&&!/{.*}/.test(o[1])){var f=o[1].split(this.formatSeparator).map((function(e){return e.trim()}));o[1]=f.shift(),c=f,l=!0}if((a=r(u.call(this,o[1].trim(),s),s))&&o[0]===t&&"string"!=typeof a)return a;"string"!=typeof a&&(a=j(a)),a||(this.logger.warn("missed to resolve ".concat(o[1]," for nesting ").concat(t)),a=""),l&&(a=c.reduce((function(e,t){return n.format(e,t,i.lng,i)}),a.trim())),t=t.replace(o[0],a),this.regexp.lastIndex=0}return t}}]),e}();function K(e,t){for(var r=e.indexOf(t);-1!==r;)e.splice(r,1),r=e.indexOf(t)}var G=function(e){function t(e,r,n){var i,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return p.default(this,t),i=m.default(this,g.default(t).call(this)),N&&k.call(v.default(i)),i.backend=e,i.store=r,i.services=n,i.languageUtils=n.languageUtils,i.options=o,i.logger=x.create("backendConnector"),i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(n,o.backend,o),i}return y.default(t,e),b.default(t,[{key:"queueLoad",value:function e(t,r,n,i){var o=this,a=[],s=[],u=[],c=[];return t.forEach((function(e){var t=!0;r.forEach((function(r){var i="".concat(e,"|").concat(r);!n.reload&&o.store.hasResourceBundle(e,r)?o.state[i]=2:o.state[i]<0||(1===o.state[i]?s.indexOf(i)<0&&s.push(i):(o.state[i]=1,t=!1,s.indexOf(i)<0&&s.push(i),a.indexOf(i)<0&&a.push(i),c.indexOf(r)<0&&c.push(r)))})),t||u.push(e)})),(a.length||s.length)&&this.queue.push({pending:s,loaded:{},errors:[],callback:i}),{toLoad:a,pending:s,toLoadLanguages:u,toLoadNamespaces:c}}},{key:"loaded",value:function e(t,r,n){var i=t.split("|"),o=i[0],a=i[1];r&&this.emit("failedLoading",o,a,r),n&&this.store.addResourceBundle(o,a,n),this.state[t]=r?-1:2;var e={};this.queue.forEach((function(n){O(n.loaded,[o],a),K(n.pending,t),r&&n.errors.push(r),0!==n.pending.length||n.done||(Object.keys(n.loaded).forEach((function(t){e[t]||(e[t]=[]),n.loaded[t].length&&n.loaded[t].forEach((function(r){e[t].indexOf(r)<0&&e[t].push(r)}))})),n.done=!0,n.errors.length?n.callback(n.errors):n.callback())})),this.emit("loaded",e),this.queue=this.queue.filter((function(e){return!e.done}))}},{key:"read",value:function e(t,r,n){var i=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:350,s=arguments.length>5?arguments[5]:void 0;return t.length?this.backend[n](t,r,(function(e,u){e&&u&&o<5?setTimeout((function(){i.read.call(i,t,r,n,o+1,2*a,s)}),a):s(e,u)})):s(null,{})}},{key:"prepareLoading",value:function e(t,r){var n=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof r&&(r=[r]);var a=this.queueLoad(t,r,i,o);if(!a.toLoad.length)return a.pending.length||o(),null;a.toLoad.forEach((function(e){n.loadOne(e)}))}},{key:"load",value:function e(t,r,n){this.prepareLoading(t,r,{},n)}},{key:"reload",value:function e(t,r,n){this.prepareLoading(t,r,{reload:!0},n)}},{key:"loadOne",value:function e(t){var r=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=t.split("|"),o=i[0],a=i[1];this.read(o,a,"read",void 0,void 0,(function(e,i){e&&r.logger.warn("".concat(n,"loading namespace ").concat(a," for language ").concat(o," failed"),e),!e&&i&&r.logger.log("".concat(n,"loaded namespace ").concat(a," for language ").concat(o),i),r.loaded(t,e,i)}))}},{key:"saveMissing",value:function e(t,r,n,i,o){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(r)?this.logger.warn('did not save key "'.concat(n,'" as the namespace "').concat(r,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=n&&""!==n&&(this.backend&&this.backend.create&&this.backend.create(t,r,n,i,null,h.default({},a,{isUpdate:o})),t&&t[0]&&this.store.addResource(t[0],r,n,i))}}]),t}(k);function X(){return{debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,whitelist:!1,nonExplicitWhitelist:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function e(t){var r={};if("object"===d.default(t[1])&&(r=t[1]),"string"==typeof t[1]&&(r.defaultValue=t[1]),"string"==typeof t[2]&&(r.tDescription=t[2]),"object"===d.default(t[2])||"object"===d.default(t[3])){var n=t[3]||t[2];Object.keys(n).forEach((function(e){r[e]=n[e]}))}return r},interpolation:{escapeValue:!0,format:function e(t,r,n,i){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!1}}}function Z(e){return"string"==typeof e.ns&&(e.ns=[e.ns]),"string"==typeof e.fallbackLng&&(e.fallbackLng=[e.fallbackLng]),"string"==typeof e.fallbackNS&&(e.fallbackNS=[e.fallbackNS]),e.whitelist&&(e.whitelist&&e.whitelist.indexOf("cimode")<0&&(e.whitelist=e.whitelist.concat(["cimode"])),e.supportedLngs=e.whitelist),e.nonExplicitWhitelist&&(e.nonExplicitSupportedLngs=e.nonExplicitWhitelist),e.supportedLngs&&e.supportedLngs.indexOf("cimode")<0&&(e.supportedLngs=e.supportedLngs.concat(["cimode"])),e}function J(){}var Q,ee=new(function(e){function t(){var e,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;if(p.default(this,t),e=m.default(this,g.default(t).call(this)),N&&k.call(v.default(e)),e.options=Z(r),e.services={},e.logger=x,e.modules={external:[]},n&&!e.isInitialized&&!r.isClone){if(!e.options.initImmediate)return e.init(r,n),m.default(e,v.default(e));setTimeout((function(){e.init(r,n)}),0)}return e}return y.default(t,e),b.default(t,[{key:"init",value:function e(){var t=this,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;function i(e){return e?"function"==typeof e?new e:e:null}if("function"==typeof r&&(n=r,r={}),r.whitelist&&!r.supportedLngs&&this.logger.deprecate("whitelist",'option "whitelist" will be renamed to "supportedLngs" in the next major - please make sure to rename this option asap.'),r.nonExplicitWhitelist&&!r.nonExplicitSupportedLngs&&this.logger.deprecate("whitelist",'options "nonExplicitWhitelist" will be renamed to "nonExplicitSupportedLngs" in the next major - please make sure to rename this option asap.'),this.options=h.default({},X(),this.options,Z(r)),this.format=this.options.interpolation.format,n||(n=J),!this.options.isClone){this.modules.logger?x.init(i(this.modules.logger),this.options):x.init(null,this.options);var o=new U(this.options);this.store=new F(this.options.resources,this.options);var a=this.services;a.logger=x,a.resourceStore=this.store,a.languageUtils=o,a.pluralResolver=new Y(o,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),a.interpolator=new V(this.options),a.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},a.backendConnector=new G(i(this.modules.backend),a.resourceStore,a,this.options),a.backendConnector.on("*",(function(e){for(var r=arguments.length,n=new Array(r>1?r-1:0),i=1;i1?r-1:0),i=1;i0&&"dev"!==s[0]&&(this.options.lng=s[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined");var u=["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"];u.forEach((function(e){t[e]=function(){var r;return(r=t.store)[e].apply(r,arguments)}}));var c=["addResource","addResources","addResourceBundle","removeResourceBundle"];c.forEach((function(e){t[e]=function(){var r;return(r=t.store)[e].apply(r,arguments),t}}));var l=S(),f=function e(){var r=function e(r,i){t.isInitialized&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),l.resolve(i),n(r,i)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return r(null,t.t.bind(t));t.changeLanguage(t.options.lng,r)};return this.options.resources||!this.options.initImmediate?f():setTimeout(f,0),l}},{key:"loadResources",value:function e(t){var r=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:J,i=n,o="string"==typeof t?t:this.language;if("function"==typeof t&&(i=t),!this.options.resources||this.options.partialBundledLanguages){if(o&&"cimode"===o.toLowerCase())return i();var a=[],s=function e(t){var n;t&&r.services.languageUtils.toResolveHierarchy(t).forEach((function(e){a.indexOf(e)<0&&a.push(e)}))};if(o)s(o);else{var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.forEach((function(e){return s(e)}))}this.options.preload&&this.options.preload.forEach((function(e){return s(e)})),this.services.backendConnector.load(a,this.options.ns,i)}else i(null)}},{key:"reloadResources",value:function e(t,r,n){var i=S();return t||(t=this.languages),r||(r=this.options.ns),n||(n=J),this.services.backendConnector.reload(t,r,(function(e){i.resolve(),n(e)})),i}},{key:"use",value:function e(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&L.addPostProcessor(t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"changeLanguage",value:function e(t,r){var n=this;this.isLanguageChangingTo=t;var i=S();this.emit("languageChanging",t);var o=function e(t,o){o?(n.language=o,n.languages=n.services.languageUtils.toResolveHierarchy(o),n.translator.changeLanguage(o),n.isLanguageChangingTo=void 0,n.emit("languageChanged",o),n.logger.log("languageChanged",o)):n.isLanguageChangingTo=void 0,i.resolve((function(){return n.t.apply(n,arguments)})),r&&r(t,(function(){return n.t.apply(n,arguments)}))},a=function e(t){var r="string"==typeof t?t:n.services.languageUtils.getBestMatchFromCodes(t);r&&(n.language||(n.language=r,n.languages=n.services.languageUtils.toResolveHierarchy(r)),n.translator.language||n.translator.changeLanguage(r),n.services.languageDetector&&n.services.languageDetector.cacheUserLanguage(r)),n.loadResources(r,(function(e){o(e,r)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(a):a(t):a(this.services.languageDetector.detect()),i}},{key:"getFixedT",value:function e(t,r){var n=this,i=function e(t,r){var i;if("object"!==d.default(r)){for(var o=arguments.length,a=new Array(o>2?o-2:0),s=2;s1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var i=this.languages[0],o=!!this.options&&this.options.fallbackLng,a=this.languages[this.languages.length-1];if("cimode"===i.toLowerCase())return!0;var s=function e(t,n){var i=r.services.backendConnector.state["".concat(t,"|").concat(n)];return-1===i||2===i};if(n.precheck){var u=n.precheck(this,s);if(void 0!==u)return u}return!!this.hasResourceBundle(i,t)||(!this.services.backendConnector.backend||!(!s(i,t)||o&&!s(a,t)))}},{key:"loadNamespaces",value:function e(t,r){var n=this,i=S();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(e){n.options.ns.indexOf(e)<0&&n.options.ns.push(e)})),this.loadResources((function(e){i.resolve(),r&&r(e)})),i):(r&&r(),Promise.resolve())}},{key:"loadLanguages",value:function e(t,r){var n=S();"string"==typeof t&&(t=[t]);var i=this.options.preload||[],o=t.filter((function(e){return i.indexOf(e)<0}));return o.length?(this.options.preload=i.concat(o),this.loadResources((function(e){n.resolve(),r&&r(e)})),n):(r&&r(),Promise.resolve())}},{key:"dir",value:function e(t){return t||(t=this.languages&&this.languages.length>0?this.languages[0]:this.language),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>=0?"rtl":"ltr":"rtl";var r}},{key:"createInstance",value:function e(){var r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;return new t(r,n)}},{key:"cloneInstance",value:function e(){var r=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:J,o=h.default({},this.options,n,{isClone:!0}),a=new t(o),s=["store","services","language"];return s.forEach((function(e){a[e]=r[e]})),a.services=h.default({},this.services),a.services.utils={hasLoadedNamespace:a.hasLoadedNamespace.bind(a)},a.translator=new q(a.services,a.options),a.translator.on("*",(function(e){for(var t=arguments.length,r=new Array(t>1?t-1:0),n=1;n=0&&r<=y}}function Z(e){return function(t){return null==t?void 0:t[e]}}var J=Z("byteLength"),Q=X(J),ee=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;function te(e){return p?p(e)&&!U(e):Q(e)&&ee.test(s.call(e))}var re=c?te:G(!1),ne=Z("length");function ie(e){for(var t={},r=e.length,n=0;n":">",'"':""","'":"'","`":"`"},st=ot(at),ut,ct=ot(Ce(at)),lt=ce.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g},ft=/(.)^/,dt={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},ht=/\\|'|\r|\n|\u2028|\u2029/g;function pt(e){return"\\"+dt[e]}var bt=/^\s*(\w|\$)+\s*$/;function mt(e,t,r){!t&&r&&(t=r),t=Re({},t,ce.templateSettings);var n=RegExp([(t.escape||ft).source,(t.interpolate||ft).source,(t.evaluate||ft).source].join("|")+"|$","g"),i=0,o="__p+='";e.replace(n,(function(t,r,n,a,s){return o+=e.slice(i,s).replace(ht,pt),i=s+t.length,r?o+="'+\n((__t=("+r+"))==null?'':_.escape(__t))+\n'":n?o+="'+\n((__t=("+n+"))==null?'':__t)+\n'":a&&(o+="';\n"+a+"\n__p+='"),t})),o+="';\n";var a=t.variable,s;if(a){if(!bt.test(a))throw new Error("variable is not a bare identifier: "+a)}else o="with(obj||{}){\n"+o+"}\n",a="obj";o="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+o+"return __p;\n";try{s=new Function(a,"_",o)}catch(c){throw c.source=o,c}var u=function(e){return s.call(this,e,ce)};return u.source="function("+a+"){\n"+o+"}",u}function gt(e,t,r){var n=(t=Ue(t)).length;if(!n)return N(r)?r.call(e):r;for(var i=0;i1)jt(s,t-1,r,n),i=n.length;else for(var u=0,c=s.length;ut?(n&&(clearTimeout(n),n=null),s=c,a=e.apply(i,o),n||(i=o=null)):n||!1===r.trailing||(n=setTimeout(u,l)),a};return c.cancel=function(){clearTimeout(n),s=0,n=i=o=null},c}function Tt(e,t,r){var n,i,o,a,s,u=function(){var c=it()-i;t>c?n=setTimeout(u,t-c):(n=null,r||(a=e.apply(s,o)),n||(o=s=null))},c=w((function(c){return s=this,o=c,i=it(),n||(n=setTimeout(u,t),r&&(a=e.apply(s,o))),a}));return c.cancel=function(){clearTimeout(n),n=o=s=null},c}function Mt(e,t){return xt(t,e)}function Bt(e){return function(){return!e.apply(this,arguments)}}function It(){var e=arguments,t=e.length-1;return function(){for(var r=t,n=e[t].apply(this,arguments);r--;)n=e[r].call(this,n);return n}}function Rt(e,t){return function(){if(--e<1)return t.apply(this,arguments)}}function Nt(e,t){var r;return function(){return--e>0&&(r=t.apply(this,arguments)),e<=1&&(t=null),r}}var Ft=xt(Nt,2);function Lt(e,t,r){t=Je(t,r);for(var n=ae(e),i,o=0,a=n.length;o0?0:i-1;o>=0&&o0?s=o>=0?o:Math.max(o+u,s):u=o>=0?Math.min(o+1,u):o+u+1;else if(r&&o&&u)return n[o=r(n,i)]===i?o:-1;if(i!=i)return(o=t(a.call(n,s,u),K))>=0?o+s:-1;for(o=e>0?s:u-1;o>=0&&o0?0:a-1;for(i||(n=t[o?o[s]:s],s+=e);s>=0&&s=3;return t(e,Ge(r,i,4),n,o)}}var Zt=Xt(1),Jt=Xt(-1);function Qt(e,t,r){var n=[];return t=Je(t,r),Kt(e,(function(e,r,i){t(e,r,i)&&n.push(e)})),n}function er(e,t,r){return Qt(e,Bt(Je(t)),r)}function tr(e,t,r){t=Je(t,r);for(var n=!St(e)&&ae(e),i=(n||e).length,o=0;o=0}var ir=w((function(e,t,r){var n,i;return N(t)?i=t:(t=Ue(t),n=t.slice(0,-1),t=t[t.length-1]),Gt(e,(function(e){var o=i;if(!o){if(n&&n.length&&(e=$e(e,n)),null==e)return;o=e[t]}return null==o?o:o.apply(e,r)}))}));function or(e,t){return Gt(e,Ke(t))}function ar(e,t){return Qt(e,Ve(t))}function sr(e,t,r){var n=-1/0,i=-1/0,o,a;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var s=0,u=(e=St(e)?e:Ee(e)).length;sn&&(n=o);else t=Je(t,r),Kt(e,(function(e,r,o){((a=t(e,r,o))>i||a===-1/0&&n===-1/0)&&(n=e,i=a)}));return n}function ur(e,t,r){var n=1/0,i=1/0,o,a;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var s=0,u=(e=St(e)?e:Ee(e)).length;sn||void 0===r)return 1;if(r1&&(n=Ge(n,t[1])),t=be(e)):(n=wr,t=jt(t,!1,!1),e=Object(e));for(var i=0,o=t.length;i1&&(n=t[1])):(t=Gt(jt(t,!1,!1),String),r=function(e,r){return!nr(t,r)}),_r(e,r,n)}));function kr(e,t,r){return a.call(e,0,Math.max(0,e.length-(null==t||r?1:t)))}function Sr(e,t,r){return null==e||e.length<1?null==t||r?void 0:[]:null==t||r?e[0]:kr(e,e.length-t)}function jr(e,t,r){return a.call(e,null==t||r?1:t)}function Ar(e,t,r){return null==e||e.length<1?null==t||r?void 0:[]:null==t||r?e[e.length-1]:jr(e,Math.max(0,e.length-t))}function Dr(e){return Qt(e,Boolean)}function Er(e,t){return jt(e,t,!1)}var Or=w((function(e,t){return t=jt(t,!0,!0),Qt(e,(function(e){return!nr(t,e)}))})),Cr=w((function(e,t){return Or(e,t)}));function Tr(e,t,r,n){S(t)||(n=r,r=t,t=!1),null!=r&&(r=Je(r,n));for(var i=[],o=[],a=0,s=ne(e);ae(t),this)}}onabort(){}addEventListener(e,t){"abort"===e&&this._listeners.push(t)}removeEventListener(e,t){"abort"===e&&(this._listeners=this._listeners.filter(e=>e!==t))}},c=new Set,l=(e,t)=>{const r=`LRU_CACHE_OPTION_${e}`;p(r)&&b(r,`${e} option`,`options.${t}`,w)},f=(e,t)=>{const r=`LRU_CACHE_METHOD_${e}`;if(p(r)){const{prototype:n}=w,{get:i}=Object.getOwnPropertyDescriptor(n,e);b(r,`${e} method`,`cache.${t}()`,i)}},d=(e,t)=>{const r=`LRU_CACHE_PROPERTY_${e}`;if(p(r)){const{prototype:n}=w,{get:i}=Object.getOwnPropertyDescriptor(n,e);b(r,`${e} property`,`cache.${t}`,i)}},h=(...e)=>{"object"==typeof process&&process&&"function"==typeof process.emitWarning?process.emitWarning(...e):console.error(...e)},p=e=>!c.has(e),b=(e,t,r,n)=>{c.add(e);const i=`The ${t} is deprecated. Please use ${r} instead.`;h(i,"DeprecationWarning",e,n)},m=e=>e&&e===Math.floor(e)&&e>0&&isFinite(e),g=e=>m(e)?e<=Math.pow(2,8)?Uint8Array:e<=Math.pow(2,16)?Uint16Array:e<=Math.pow(2,32)?Uint32Array:e<=Number.MAX_SAFE_INTEGER?v:null:null;class v extends Array{constructor(e){super(e),this.fill(0)}}class y{constructor(e){if(0===e)return[];const t=g(e);this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}}class w{constructor(e={}){const{max:t=0,ttl:r,ttlResolution:n=1,ttlAutopurge:i,updateAgeOnGet:o,updateAgeOnHas:a,allowStale:s,dispose:u,disposeAfter:f,noDisposeOnSet:d,noUpdateTTL:b,maxSize:v=0,maxEntrySize:_=0,sizeCalculation:x,fetchMethod:k,fetchContext:S,noDeleteOnFetchRejection:j,noDeleteOnStaleGet:A}=e,{length:D,maxAge:E,stale:O}=e instanceof w?{}:e;if(0!==t&&!m(t))throw new TypeError("max option must be a nonnegative integer");const C=t?g(t):Array;if(!C)throw new Error("invalid max value: "+t);if(this.max=t,this.maxSize=v,this.maxEntrySize=_||this.maxSize,this.sizeCalculation=x||D,this.sizeCalculation){if(!this.maxSize&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if("function"!=typeof this.sizeCalculation)throw new TypeError("sizeCalculation set to non-function")}if(this.fetchMethod=k||null,this.fetchMethod&&"function"!=typeof this.fetchMethod)throw new TypeError("fetchMethod must be a function if specified");if(this.fetchContext=S,!this.fetchMethod&&void 0!==S)throw new TypeError("cannot set fetchContext without fetchMethod");if(this.keyMap=new Map,this.keyList=new Array(t).fill(null),this.valList=new Array(t).fill(null),this.next=new C(t),this.prev=new C(t),this.head=0,this.tail=0,this.free=new y(t),this.initialFill=1,this.size=0,"function"==typeof u&&(this.dispose=u),"function"==typeof f?(this.disposeAfter=f,this.disposed=[]):(this.disposeAfter=null,this.disposed=null),this.noDisposeOnSet=!!d,this.noUpdateTTL=!!b,this.noDeleteOnFetchRejection=!!j,0!==this.maxEntrySize){if(0!==this.maxSize&&!m(this.maxSize))throw new TypeError("maxSize must be a positive integer if specified");if(!m(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.initializeSizeTracking()}if(this.allowStale=!!s||!!O,this.noDeleteOnStaleGet=!!A,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!a,this.ttlResolution=m(n)||0===n?n:1,this.ttlAutopurge=!!i,this.ttl=r||E||0,this.ttl){if(!m(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.initializeTTLTracking()}if(0===this.max&&0===this.ttl&&0===this.maxSize)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.max&&!this.maxSize){const e="LRU_CACHE_UNBOUNDED";if(p(e)){c.add(e);const t="TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";h(t,"UnboundedCacheWarning",e,w)}}O&&l("stale","allowStale"),E&&l("maxAge","ttl"),D&&l("length","sizeCalculation")}getRemainingTTL(e){return this.has(e,{updateAgeOnHas:!1})?1/0:0}initializeTTLTracking(){this.ttls=new v(this.max),this.starts=new v(this.max),this.setItemTTL=(e,t,r=n.now())=>{if(this.starts[e]=0!==t?r:0,this.ttls[e]=t,0!==t&&this.ttlAutopurge){const r=setTimeout(()=>{this.isStale(e)&&this.delete(this.keyList[e])},t+1);r.unref&&r.unref()}},this.updateItemAge=e=>{this.starts[e]=0!==this.ttls[e]?n.now():0};let e=0;const t=()=>{const t=n.now();if(this.ttlResolution>0){e=t;const r=setTimeout(()=>e=0,this.ttlResolution);r.unref&&r.unref()}return t};this.getRemainingTTL=r=>{const n=this.keyMap.get(r);return void 0===n?0:0===this.ttls[n]||0===this.starts[n]?1/0:this.starts[n]+this.ttls[n]-(e||t())},this.isStale=r=>0!==this.ttls[r]&&0!==this.starts[r]&&(e||t())-this.starts[r]>this.ttls[r]}updateItemAge(e){}setItemTTL(e,t,r){}isStale(e){return!1}initializeSizeTracking(){this.calculatedSize=0,this.sizes=new v(this.max),this.removeItemSize=e=>{this.calculatedSize-=this.sizes[e],this.sizes[e]=0},this.requireSize=(e,t,r,n)=>{if(this.isBackgroundFetch(t))return 0;if(!m(r)){if(!n)throw new TypeError("invalid size value (must be positive integer)");if("function"!=typeof n)throw new TypeError("sizeCalculation must be a function");if(r=n(t,e),!m(r))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}return r},this.addItemSize=(e,t)=>{if(this.sizes[e]=t,this.maxSize){const t=this.maxSize-this.sizes[e];for(;this.calculatedSize>t;)this.evict(!0)}this.calculatedSize+=this.sizes[e]}}removeItemSize(e){}addItemSize(e,t){}requireSize(e,t,r,n){if(r||n)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache")}*indexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.tail;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.head);)t=this.prev[t]}*rindexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.head;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.tail);)t=this.next[t]}isValidIndex(e){return this.keyMap.get(this.keyList[e])===e}*entries(){for(const e of this.indexes())yield[this.keyList[e],this.valList[e]]}*rentries(){for(const e of this.rindexes())yield[this.keyList[e],this.valList[e]]}*keys(){for(const e of this.indexes())yield this.keyList[e]}*rkeys(){for(const e of this.rindexes())yield this.keyList[e]}*values(){for(const e of this.indexes())yield this.valList[e]}*rvalues(){for(const e of this.rindexes())yield this.valList[e]}[Symbol.iterator](){return this.entries()}find(e,t={}){for(const r of this.indexes())if(e(this.valList[r],this.keyList[r],this))return this.get(this.keyList[r],t)}forEach(e,t=this){for(const r of this.indexes())e.call(t,this.valList[r],this.keyList[r],this)}rforEach(e,t=this){for(const r of this.rindexes())e.call(t,this.valList[r],this.keyList[r],this)}get prune(){return f("prune","purgeStale"),this.purgeStale}purgeStale(){let e=!1;for(const t of this.rindexes({allowStale:!0}))this.isStale(t)&&(this.delete(this.keyList[t]),e=!0);return e}dump(){const e=[];for(const t of this.indexes({allowStale:!0})){const r=this.keyList[t],i=this.valList[t],o=this.isBackgroundFetch(i)?i.__staleWhileFetching:i,a={value:o};if(this.ttls){a.ttl=this.ttls[t];const e=n.now()-this.starts[t];a.start=Math.floor(Date.now()-e)}this.sizes&&(a.size=this.sizes[t]),e.unshift([r,a])}return e}load(e){this.clear();for(const[t,r]of e){if(r.start){const e=Date.now()-r.start;r.start=n.now()-e}this.set(t,r.value,r)}}dispose(e,t,r){}set(e,t,{ttl:r=this.ttl,start:n,noDisposeOnSet:i=this.noDisposeOnSet,size:o=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:s=this.noUpdateTTL}={}){if(o=this.requireSize(e,t,o,a),this.maxEntrySize&&o>this.maxEntrySize)return this.delete(e),this;let u=0===this.size?void 0:this.keyMap.get(e);if(void 0===u)u=this.newIndex(),this.keyList[u]=e,this.valList[u]=t,this.keyMap.set(e,u),this.next[this.tail]=u,this.prev[u]=this.tail,this.tail=u,this.size++,this.addItemSize(u,o),s=!1;else{const r=this.valList[u];t!==r&&(this.isBackgroundFetch(r)?r.__abortController.abort():i||(this.dispose(r,e,"set"),this.disposeAfter&&this.disposed.push([r,e,"set"])),this.removeItemSize(u),this.valList[u]=t,this.addItemSize(u,o)),this.moveToTail(u)}if(0===r||0!==this.ttl||this.ttls||this.initializeTTLTracking(),s||this.setItemTTL(u,r,n),this.disposeAfter)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return this}newIndex(){return 0===this.size?this.tail:this.size===this.max&&0!==this.max?this.evict(!1):0!==this.free.length?this.free.pop():this.initialFill++}pop(){if(this.size){const e=this.valList[this.head];return this.evict(!0),e}}evict(e){const t=this.head,r=this.keyList[t],n=this.valList[t];return this.isBackgroundFetch(n)?n.__abortController.abort():(this.dispose(n,r,"evict"),this.disposeAfter&&this.disposed.push([n,r,"evict"])),this.removeItemSize(t),e&&(this.keyList[t]=null,this.valList[t]=null,this.free.push(t)),this.head=this.next[t],this.keyMap.delete(r),this.size--,t}has(e,{updateAgeOnHas:t=this.updateAgeOnHas}={}){const r=this.keyMap.get(e);return void 0!==r&&!this.isStale(r)&&(t&&this.updateItemAge(r),!0)}peek(e,{allowStale:t=this.allowStale}={}){const r=this.keyMap.get(e);if(void 0!==r&&(t||!this.isStale(r))){const e=this.valList[r];return this.isBackgroundFetch(e)?e.__staleWhileFetching:e}}backgroundFetch(e,t,r,n){const i=void 0===t?void 0:this.valList[t];if(this.isBackgroundFetch(i))return i;const a=new o,s={signal:a.signal,options:r,context:n},u=t=>(a.signal.aborted||this.set(e,t,s.options),t),c=n=>{if(this.valList[t]===f){const n=!r.noDeleteOnFetchRejection||void 0===f.__staleWhileFetching;n?this.delete(e):this.valList[t]=f.__staleWhileFetching}if(f.__returned===f)throw n},l=t=>t(this.fetchMethod(e,i,s)),f=new Promise(l).then(u,c);return f.__abortController=a,f.__staleWhileFetching=i,f.__returned=null,void 0===t?(this.set(e,f,s.options),t=this.keyMap.get(e)):this.valList[t]=f,f}isBackgroundFetch(e){return e&&"object"==typeof e&&"function"==typeof e.then&&Object.prototype.hasOwnProperty.call(e,"__staleWhileFetching")&&Object.prototype.hasOwnProperty.call(e,"__returned")&&(e.__returned===e||null===e.__returned)}async fetch(e,{allowStale:t=this.allowStale,updateAgeOnGet:r=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:i=this.ttl,noDisposeOnSet:o=this.noDisposeOnSet,size:a=0,sizeCalculation:s=this.sizeCalculation,noUpdateTTL:u=this.noUpdateTTL,noDeleteOnFetchRejection:c=this.noDeleteOnFetchRejection,fetchContext:l=this.fetchContext,forceRefresh:f=!1}={}){if(!this.fetchMethod)return this.get(e,{allowStale:t,updateAgeOnGet:r,noDeleteOnStaleGet:n});const d={allowStale:t,updateAgeOnGet:r,noDeleteOnStaleGet:n,ttl:i,noDisposeOnSet:o,size:a,sizeCalculation:s,noUpdateTTL:u,noDeleteOnFetchRejection:c};let h=this.keyMap.get(e);if(void 0===h){const t=this.backgroundFetch(e,h,d,l);return t.__returned=t}{const n=this.valList[h];if(this.isBackgroundFetch(n))return t&&void 0!==n.__staleWhileFetching?n.__staleWhileFetching:n.__returned=n;if(!f&&!this.isStale(h))return this.moveToTail(h),r&&this.updateItemAge(h),n;const i=this.backgroundFetch(e,h,d,l);return t&&void 0!==i.__staleWhileFetching?i.__staleWhileFetching:i.__returned=i}}get(e,{allowStale:t=this.allowStale,updateAgeOnGet:r=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet}={}){const i=this.keyMap.get(e);if(void 0!==i){const o=this.valList[i],a=this.isBackgroundFetch(o);if(this.isStale(i))return a?t?o.__staleWhileFetching:void 0:(n||this.delete(e),t?o:void 0);if(a)return;return this.moveToTail(i),r&&this.updateItemAge(i),o}}connect(e,t){this.prev[t]=e,this.next[e]=t}moveToTail(e){e!==this.tail&&(e===this.head?this.head=this.next[e]:this.connect(this.prev[e],this.next[e]),this.connect(this.tail,e),this.tail=e)}get del(){return f("del","delete"),this.delete}delete(e){let t=!1;if(0!==this.size){const r=this.keyMap.get(e);if(void 0!==r)if(t=!0,1===this.size)this.clear();else{this.removeItemSize(r);const t=this.valList[r];this.isBackgroundFetch(t)?t.__abortController.abort():(this.dispose(t,e,"delete"),this.disposeAfter&&this.disposed.push([t,e,"delete"])),this.keyMap.delete(e),this.keyList[r]=null,this.valList[r]=null,r===this.tail?this.tail=this.prev[r]:r===this.head?this.head=this.next[r]:(this.next[this.prev[r]]=this.next[r],this.prev[this.next[r]]=this.prev[r]),this.size--,this.free.push(r)}}if(this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return t}clear(){for(const e of this.rindexes({allowStale:!0})){const t=this.valList[e];if(this.isBackgroundFetch(t))t.__abortController.abort();else{const r=this.keyList[e];this.dispose(t,r,"delete"),this.disposeAfter&&this.disposed.push([t,r,"delete"])}}if(this.keyMap.clear(),this.valList.fill(null),this.keyList.fill(null),this.ttls&&(this.ttls.fill(0),this.starts.fill(0)),this.sizes&&this.sizes.fill(0),this.head=0,this.tail=0,this.initialFill=1,this.free.length=0,this.calculatedSize=0,this.size=0,this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift())}get reset(){return f("reset","clear"),this.clear}get length(){return d("length","size"),this.size}static get AbortController(){return o}static get AbortSignal(){return u}}e.exports=w}}}},"form-builder":{"package.json":function e(t,r,e){e.exports={name:"@steedos/form-builder",version:"3.6.2-patch.5",private:!1,publishConfig:{access:"public"},main:"dist/form-builder.min.js",homepage:"https://formbuilder.online/",repository:{url:"https://github.com/kevinchappell/formBuilder.git",type:"git"},files:["dist/**/*","docs/**/*","src/**/*"],author:"Kevin Chappell ",contributors:[],bugs:"https://github.com/kevinchappell/formBuilder/issues",description:"A jQuery plugin for drag and drop form building",keywords:["jquery-plugin","forms","drag and drop","form builder","form create"],license:"MIT",ignore:["**/*","node_modules","test"],config:{files:{test:["test/**/*.spec.js"],pluginsDir:"src/js/control_plugins/",fonts:"src/fonts",sass:"src/sass",formBuilder:{js:"src/js/form-builder.js",sass:["src/sass/form-builder.scss"]},formRender:{js:"src/js/form-render.js",sass:["src/sass/form-render.scss"]},site:["demo/assets/sass/site.scss"]},fontServer:"http://fontello.com",fontelloToken:"09d648f01d6c57cb9f9b8cc55043e0c0"},babel:{presets:[["@babel/preset-env",{targets:{browsers:["> 1%"]},loose:!0}]],comments:!1,plugins:["@babel/plugin-proposal-object-rest-spread","@babel/plugin-proposal-class-properties"]},scripts:{"build:analyze":"webpack --mode production -p --progress --config tools/webpack.config --analyze","build:plugins":"webpack --mode production -p --display-entrypoints --progress --config tools/webpack.plugins.config","build:vendor":"babel-node tools/build-vendor",build:"webpack --mode production -p --progress --config tools/webpack.config","build:all":"npm-run-all build:plugins build:vendor build copy",copy:"cp -a dist/* demo/assets/js/ && cp CONTRIBUTING.md docs/contributing.md && cp LICENSE docs/license.md && npm run copy:lang","copy:lang":"babel-node tools/copy-language-files","deploy:all":"npm-run-all deploy:demo deploy:site","deploy:demo":"node tools/deploy-demo.js","deploy:site":"node tools/deploy-site.js",docs:"mkdocs build",font:"babel-node tools/icon-font",lint:"eslint ./src --ext .js || true","semantic-release":"semantic-release","start:devServer":"webpack-dev-server --mode development --config tools/webpack.config",prestart:"npm-run-all -p build:vendor copy:lang",start:"npm run start:devServer",test:"npm run-script build"},dependencies:{jquery:">=3.4.1","jquery-ui-sortable":"*"},devDependencies:{"@babel/cli":"^7.10.5","@babel/core":"^7.11.4","@babel/node":"^7.10.5","@babel/plugin-proposal-class-properties":"^7.10.4","@babel/plugin-proposal-object-rest-spread":"^7.11.0","@babel/plugin-syntax-object-rest-spread":"^7.8.3","@babel/plugin-transform-destructuring":"^7.10.4","@babel/preset-env":"^7.11.0","@semantic-release/changelog":"^5.0.1","@semantic-release/git":"^9.0.0","@semantic-release/npm":"^7.0.5",autoprefixer:"^9.8.6","babel-eslint":"^10.1.0","babel-loader":"^8.1.0","clean-webpack-plugin":"^3.0.0",clui:"^0.3.6","compression-webpack-plugin":"^5.0.1","concat-files":"^0.1.1","cross-env":"^7.0.2","css-loader":"^4.2.1",eslint:"^7.7.0","eslint-loader":"^4.0.2","formbuilder-languages":"latest","fs-extra":"^9.0.1","html-webpack-harddisk-plugin":"^1.0.2","html-webpack-plugin":"^4.3.0",inquirer:"^7.3.3",mi18n:"^0.4.8","node-sass":"6.0.1","npm-run-all":"^4.1.5",opener:"^1.5.1","postcss-loader":"^3.0.0","replace-in-file":"^6.1.0",request:"^2.88.2","sass-loader":"10.5.2","semantic-release":"^17.1.1",semver:"^7.3.2","style-loader":"^1.2.1",unzipper:"^0.10.11",webpack:"^4.44.1","webpack-bundle-analyzer":"^3.8.0","webpack-cli":"^3.3.12","webpack-dev-server":"^3.11.0","wrapper-webpack-plugin":"^2.1.0"},prettier:{singleQuote:!0,trailingComma:"all",printWidth:120,semi:!1,arrowParens:"avoid",spaceAfterFunction:!1},engines:{},release:{branch:"master",verifyConditions:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"],prepare:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"]},browserslist:["> 1%"]}},dist:{"form-builder.min.js":function e(t,r){ +if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");!function(e){"use strict";var t=e.fn.jquery.split(" ")[0].split(".");if(t[0]<2&&t[1]<9||1==t[0]&&9==t[1]&&t[2]<1||t[0]>3)throw new Error("Bootstrap's JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4")}(jQuery),function(e){"use strict";function t(){var e=document.createElement("bootstrap"),t={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var r in t)if(void 0!==e.style[r])return{end:t[r]};return!1}e.fn.emulateTransitionEnd=function(t){var r=!1,n=this,i;return e(this).one("bsTransitionEnd",(function(){r=!0})),setTimeout((function(){r||e(n).trigger(e.support.transition.end)}),t),this},e((function(){e.support.transition=t(),e.support.transition&&(e.event.special.bsTransitionEnd={bindType:e.support.transition.end,delegateType:e.support.transition.end,handle:function(t){if(e(t.target).is(this))return t.handleObj.handler.apply(this,arguments)}})}))}(jQuery),function(e){"use strict";var t='[data-dismiss="alert"]',r=function(r){e(r).on("click",t,this.close)};function n(t){return this.each((function(){var n=e(this),i=n.data("bs.alert");i||n.data("bs.alert",i=new r(this)),"string"==typeof t&&i[t].call(n)}))}r.VERSION="3.4.1",r.TRANSITION_DURATION=150,r.prototype.close=function(t){var n=e(this),i=n.attr("data-target");i||(i=(i=n.attr("href"))&&i.replace(/.*(?=#[^\s]*$)/,"")),i="#"===i?[]:i;var o=e(document).find(i);function a(){o.detach().trigger("closed.bs.alert").remove()}t&&t.preventDefault(),o.length||(o=n.closest(".alert")),o.trigger(t=e.Event("close.bs.alert")),t.isDefaultPrevented()||(o.removeClass("in"),e.support.transition&&o.hasClass("fade")?o.one("bsTransitionEnd",a).emulateTransitionEnd(r.TRANSITION_DURATION):a())};var i=e.fn.alert;e.fn.alert=n,e.fn.alert.Constructor=r,e.fn.alert.noConflict=function(){return e.fn.alert=i,this},e(document).on("click.bs.alert.data-api",t,r.prototype.close)}(jQuery),function(e){"use strict";var t=function(r,n){this.$element=e(r),this.options=e.extend({},t.DEFAULTS,n),this.isLoading=!1};function r(r){return this.each((function(){var n=e(this),i=n.data("bs.button"),o="object"==typeof r&&r;i||n.data("bs.button",i=new t(this,o)),"toggle"==r?i.toggle():r&&i.setState(r)}))}t.VERSION="3.4.1",t.DEFAULTS={loadingText:"loading..."},t.prototype.setState=function(t){var r="disabled",n=this.$element,i=n.is("input")?"val":"html",o=n.data();t+="Text",null==o.resetText&&n.data("resetText",n[i]()),setTimeout(e.proxy((function(){n[i](null==o[t]?this.options[t]:o[t]),"loadingText"==t?(this.isLoading=!0,n.addClass(r).attr(r,r).prop(r,!0)):this.isLoading&&(this.isLoading=!1,n.removeClass(r).removeAttr(r).prop(r,!1))}),this),0)},t.prototype.toggle=function(){var e=!0,t=this.$element.closest('[data-toggle="buttons"]');if(t.length){var r=this.$element.find("input");"radio"==r.prop("type")?(r.prop("checked")&&(e=!1),t.find(".active").removeClass("active"),this.$element.addClass("active")):"checkbox"==r.prop("type")&&(r.prop("checked")!==this.$element.hasClass("active")&&(e=!1),this.$element.toggleClass("active")),r.prop("checked",this.$element.hasClass("active")),e&&r.trigger("change")}else this.$element.attr("aria-pressed",!this.$element.hasClass("active")),this.$element.toggleClass("active")};var n=e.fn.button;e.fn.button=r,e.fn.button.Constructor=t,e.fn.button.noConflict=function(){return e.fn.button=n,this},e(document).on("click.bs.button.data-api",'[data-toggle^="button"]',(function(t){var n=e(t.target).closest(".btn");r.call(n,"toggle"),e(t.target).is('input[type="radio"], input[type="checkbox"]')||(t.preventDefault(),n.is("input,button")?n.trigger("focus"):n.find("input:visible,button:visible").first().trigger("focus"))})).on("focus.bs.button.data-api blur.bs.button.data-api",'[data-toggle^="button"]',(function(t){e(t.target).closest(".btn").toggleClass("focus",/^focus(in)?$/.test(t.type))}))}(jQuery),function(e){"use strict";var t=function(t,r){this.$element=e(t),this.$indicators=this.$element.find(".carousel-indicators"),this.options=r,this.paused=null,this.sliding=null,this.interval=null,this.$active=null,this.$items=null,this.options.keyboard&&this.$element.on("keydown.bs.carousel",e.proxy(this.keydown,this)),"hover"==this.options.pause&&!("ontouchstart"in document.documentElement)&&this.$element.on("mouseenter.bs.carousel",e.proxy(this.pause,this)).on("mouseleave.bs.carousel",e.proxy(this.cycle,this))};function r(r){return this.each((function(){var n=e(this),i=n.data("bs.carousel"),o=e.extend({},t.DEFAULTS,n.data(),"object"==typeof r&&r),a="string"==typeof r?r:o.slide;i||n.data("bs.carousel",i=new t(this,o)),"number"==typeof r?i.to(r):a?i[a]():o.interval&&i.pause().cycle()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=600,t.DEFAULTS={interval:5e3,pause:"hover",wrap:!0,keyboard:!0},t.prototype.keydown=function(e){if(!/input|textarea/i.test(e.target.tagName)){switch(e.which){case 37:this.prev();break;case 39:this.next();break;default:return}e.preventDefault()}},t.prototype.cycle=function(t){return t||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(e.proxy(this.next,this),this.options.interval)),this},t.prototype.getItemIndex=function(e){return this.$items=e.parent().children(".item"),this.$items.index(e||this.$active)},t.prototype.getItemForDirection=function(e,t){var r=this.getItemIndex(t),n;if(("prev"==e&&0===r||"next"==e&&r==this.$items.length-1)&&!this.options.wrap)return t;var i,o=(r+("prev"==e?-1:1))%this.$items.length;return this.$items.eq(o)},t.prototype.to=function(e){var t=this,r=this.getItemIndex(this.$active=this.$element.find(".item.active"));if(!(e>this.$items.length-1||e<0))return this.sliding?this.$element.one("slid.bs.carousel",(function(){t.to(e)})):r==e?this.pause().cycle():this.slide(e>r?"next":"prev",this.$items.eq(e))},t.prototype.pause=function(t){return t||(this.paused=!0),this.$element.find(".next, .prev").length&&e.support.transition&&(this.$element.trigger(e.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},t.prototype.next=function(){if(!this.sliding)return this.slide("next")},t.prototype.prev=function(){if(!this.sliding)return this.slide("prev")},t.prototype.slide=function(r,n){var i=this.$element.find(".item.active"),o=n||this.getItemForDirection(r,i),a=this.interval,s="next"==r?"left":"right",u=this;if(o.hasClass("active"))return this.sliding=!1;var c=o[0],l=e.Event("slide.bs.carousel",{relatedTarget:c,direction:s});if(this.$element.trigger(l),!l.isDefaultPrevented()){if(this.sliding=!0,a&&this.pause(),this.$indicators.length){this.$indicators.find(".active").removeClass("active");var f=e(this.$indicators.children()[this.getItemIndex(o)]);f&&f.addClass("active")}var d=e.Event("slid.bs.carousel",{relatedTarget:c,direction:s});return e.support.transition&&this.$element.hasClass("slide")?(o.addClass(r),"object"==typeof o&&o.length&&o[0].offsetWidth,i.addClass(s),o.addClass(s),i.one("bsTransitionEnd",(function(){o.removeClass([r,s].join(" ")).addClass("active"),i.removeClass(["active",s].join(" ")),u.sliding=!1,setTimeout((function(){u.$element.trigger(d)}),0)})).emulateTransitionEnd(t.TRANSITION_DURATION)):(i.removeClass("active"),o.addClass("active"),this.sliding=!1,this.$element.trigger(d)),a&&this.cycle(),this}};var n=e.fn.carousel;e.fn.carousel=r,e.fn.carousel.Constructor=t,e.fn.carousel.noConflict=function(){return e.fn.carousel=n,this};var i=function(t){var n=e(this),i=n.attr("href");i&&(i=i.replace(/.*(?=#[^\s]+$)/,""));var o=n.attr("data-target")||i,a=e(document).find(o);if(a.hasClass("carousel")){var s=e.extend({},a.data(),n.data()),u=n.attr("data-slide-to");u&&(s.interval=!1),r.call(a,s),u&&a.data("bs.carousel").to(u),t.preventDefault()}};e(document).on("click.bs.carousel.data-api","[data-slide]",i).on("click.bs.carousel.data-api","[data-slide-to]",i),e(window).on("load",(function(){e('[data-ride="carousel"]').each((function(){var t=e(this);r.call(t,t.data())}))}))}(jQuery),function(e){"use strict";var t=function(r,n){this.$element=e(r),this.options=e.extend({},t.DEFAULTS,n),this.$trigger=e('[data-toggle="collapse"][href="#'+r.id+'"],[data-toggle="collapse"][data-target="#'+r.id+'"]'),this.transitioning=null,this.options.parent?this.$parent=this.getParent():this.addAriaAndCollapsedClass(this.$element,this.$trigger),this.options.toggle&&this.toggle()};function r(t){var r,n=t.attr("data-target")||(r=t.attr("href"))&&r.replace(/.*(?=#[^\s]+$)/,"");return e(document).find(n)}function n(r){return this.each((function(){var n=e(this),i=n.data("bs.collapse"),o=e.extend({},t.DEFAULTS,n.data(),"object"==typeof r&&r);!i&&o.toggle&&/show|hide/.test(r)&&(o.toggle=!1),i||n.data("bs.collapse",i=new t(this,o)),"string"==typeof r&&i[r]()}))}t.VERSION="3.4.1",t.TRANSITION_DURATION=350,t.DEFAULTS={toggle:!0},t.prototype.dimension=function(){var e;return this.$element.hasClass("width")?"width":"height"},t.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var r,i=this.$parent&&this.$parent.children(".panel").children(".in, .collapsing");if(!(i&&i.length&&(r=i.data("bs.collapse"))&&r.transitioning)){var o=e.Event("show.bs.collapse");if(this.$element.trigger(o),!o.isDefaultPrevented()){i&&i.length&&(n.call(i,"hide"),r||i.data("bs.collapse",null));var a=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[a](0).attr("aria-expanded",!0),this.$trigger.removeClass("collapsed").attr("aria-expanded",!0),this.transitioning=1;var s=function(){this.$element.removeClass("collapsing").addClass("collapse in")[a](""),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!e.support.transition)return s.call(this);var u=e.camelCase(["scroll",a].join("-"));this.$element.one("bsTransitionEnd",e.proxy(s,this)).emulateTransitionEnd(t.TRANSITION_DURATION)[a](this.$element[0][u])}}}},t.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var r=e.Event("hide.bs.collapse");if(this.$element.trigger(r),!r.isDefaultPrevented()){var n=this.dimension();this.$element[n](this.$element[n]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse in").attr("aria-expanded",!1),this.$trigger.addClass("collapsed").attr("aria-expanded",!1),this.transitioning=1;var i=function(){this.transitioning=0,this.$element.removeClass("collapsing").addClass("collapse").trigger("hidden.bs.collapse")};if(!e.support.transition)return i.call(this);this.$element[n](0).one("bsTransitionEnd",e.proxy(i,this)).emulateTransitionEnd(t.TRANSITION_DURATION)}}},t.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()},t.prototype.getParent=function(){return e(document).find(this.options.parent).find('[data-toggle="collapse"][data-parent="'+this.options.parent+'"]').each(e.proxy((function(t,n){var i=e(n);this.addAriaAndCollapsedClass(r(i),i)}),this)).end()},t.prototype.addAriaAndCollapsedClass=function(e,t){var r=e.hasClass("in");e.attr("aria-expanded",r),t.toggleClass("collapsed",!r).attr("aria-expanded",r)};var i=e.fn.collapse;e.fn.collapse=n,e.fn.collapse.Constructor=t,e.fn.collapse.noConflict=function(){return e.fn.collapse=i,this},e(document).on("click.bs.collapse.data-api",'[data-toggle="collapse"]',(function(t){var i=e(this);i.attr("data-target")||t.preventDefault();var o=r(i),a,s=o.data("bs.collapse")?"toggle":i.data();n.call(o,s)}))}(jQuery),function(e){"use strict";var t=".dropdown-backdrop",r='[data-toggle="dropdown"]',n=function(t){e(t).on("click.bs.dropdown",this.toggle)};function i(t){var r=t.attr("data-target");r||(r=(r=t.attr("href"))&&/#[A-Za-z]/.test(r)&&r.replace(/.*(?=#[^\s]*$)/,""));var n="#"!==r?e(document).find(r):null;return n&&n.length?n:t.parent()}function o(n){n&&3===n.which||(e(t).remove(),e(r).each((function(){var t=e(this),r=i(t),o={relatedTarget:this};r.hasClass("open")&&(n&&"click"==n.type&&/input|textarea/i.test(n.target.tagName)&&e.contains(r[0],n.target)||(r.trigger(n=e.Event("hide.bs.dropdown",o)),n.isDefaultPrevented()||(t.attr("aria-expanded","false"),r.removeClass("open").trigger(e.Event("hidden.bs.dropdown",o)))))})))}function a(t){return this.each((function(){var r=e(this),i=r.data("bs.dropdown");i||r.data("bs.dropdown",i=new n(this)),"string"==typeof t&&i[t].call(r)}))}n.VERSION="3.4.1",n.prototype.toggle=function(t){var r=e(this);if(!r.is(".disabled, :disabled")){var n=i(r),a=n.hasClass("open");if(o(),!a){"ontouchstart"in document.documentElement&&!n.closest(".navbar-nav").length&&e(document.createElement("div")).addClass("dropdown-backdrop").insertAfter(e(this)).on("click",o);var s={relatedTarget:this};if(n.trigger(t=e.Event("show.bs.dropdown",s)),t.isDefaultPrevented())return;r.trigger("focus").attr("aria-expanded","true"),n.toggleClass("open").trigger(e.Event("shown.bs.dropdown",s))}return!1}},n.prototype.keydown=function(t){if(/(38|40|27|32)/.test(t.which)&&!/input|textarea/i.test(t.target.tagName)){var n=e(this);if(t.preventDefault(),t.stopPropagation(),!n.is(".disabled, :disabled")){var o=i(n),a=o.hasClass("open");if(!a&&27!=t.which||a&&27==t.which)return 27==t.which&&o.find(r).trigger("focus"),n.trigger("click");var s=" li:not(.disabled):visible a",u=o.find(".dropdown-menu"+s);if(u.length){var c=u.index(t.target);38==t.which&&c>0&&c--,40==t.which&&cdocument.documentElement.clientHeight;this.$element.css({paddingLeft:!this.bodyIsOverflowing&&e?this.scrollbarWidth:"",paddingRight:this.bodyIsOverflowing&&!e?this.scrollbarWidth:""})},t.prototype.resetAdjustments=function(){this.$element.css({paddingLeft:"",paddingRight:""})},t.prototype.checkScrollbar=function(){var e=window.innerWidth;if(!e){var t=document.documentElement.getBoundingClientRect();e=t.right-Math.abs(t.left)}this.bodyIsOverflowing=document.body.clientWidth
',trigger:"hover focus",title:"",delay:0,html:!1,container:!1,viewport:{selector:"body",padding:0},sanitize:!0,sanitizeFn:null,whiteList:i},c.prototype.init=function(t,r,n){if(this.enabled=!0,this.type=t,this.$element=e(r),this.options=this.getOptions(n),this.$viewport=this.options.viewport&&e(document).find(e.isFunction(this.options.viewport)?this.options.viewport.call(this,this.$element):this.options.viewport.selector||this.options.viewport),this.inState={click:!1,hover:!1,focus:!1},this.$element[0]instanceof document.constructor&&!this.options.selector)throw new Error("`selector` option must be specified when initializing "+this.type+" on the window.document object!");for(var i=this.options.trigger.split(" "),o=i.length;o--;){var a=i[o];if("click"==a)this.$element.on("click."+this.type,this.options.selector,e.proxy(this.toggle,this));else if("manual"!=a){var s="hover"==a?"mouseenter":"focusin",u="hover"==a?"mouseleave":"focusout";this.$element.on(s+"."+this.type,this.options.selector,e.proxy(this.enter,this)),this.$element.on(u+"."+this.type,this.options.selector,e.proxy(this.leave,this))}}this.options.selector?this._options=e.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},c.prototype.getDefaults=function(){return c.DEFAULTS},c.prototype.getOptions=function(r){var n=this.$element.data();for(var i in n)n.hasOwnProperty(i)&&-1!==e.inArray(i,t)&&delete n[i];return(r=e.extend({},this.getDefaults(),n,r)).delay&&"number"==typeof r.delay&&(r.delay={show:r.delay,hide:r.delay}),r.sanitize&&(r.template=u(r.template,r.whiteList,r.sanitizeFn)),r},c.prototype.getDelegateOptions=function(){var t={},r=this.getDefaults();return this._options&&e.each(this._options,(function(e,n){r[e]!=n&&(t[e]=n)})),t},c.prototype.enter=function(t){var r=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(r||(r=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,r)),t instanceof e.Event&&(r.inState["focusin"==t.type?"focus":"hover"]=!0),r.tip().hasClass("in")||"in"==r.hoverState)r.hoverState="in";else{if(clearTimeout(r.timeout),r.hoverState="in",!r.options.delay||!r.options.delay.show)return r.show();r.timeout=setTimeout((function(){"in"==r.hoverState&&r.show()}),r.options.delay.show)}},c.prototype.isInStateTrue=function(){for(var e in this.inState)if(this.inState[e])return!0;return!1},c.prototype.leave=function(t){var r=t instanceof this.constructor?t:e(t.currentTarget).data("bs."+this.type);if(r||(r=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,r)),t instanceof e.Event&&(r.inState["focusout"==t.type?"focus":"hover"]=!1),!r.isInStateTrue()){if(clearTimeout(r.timeout),r.hoverState="out",!r.options.delay||!r.options.delay.hide)return r.hide();r.timeout=setTimeout((function(){"out"==r.hoverState&&r.hide()}),r.options.delay.hide)}},c.prototype.show=function(){var t=e.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){this.$element.trigger(t);var r=e.contains(this.$element[0].ownerDocument.documentElement,this.$element[0]);if(t.isDefaultPrevented()||!r)return;var n=this,i=this.tip(),o=this.getUID(this.type);this.setContent(),i.attr("id",o),this.$element.attr("aria-describedby",o),this.options.animation&&i.addClass("fade");var a="function"==typeof this.options.placement?this.options.placement.call(this,i[0],this.$element[0]):this.options.placement,s=/\s?auto?\s?/i,u=s.test(a);u&&(a=a.replace(s,"")||"top"),i.detach().css({top:0,left:0,display:"block"}).addClass(a).data("bs."+this.type,this),this.options.container?i.appendTo(e(document).find(this.options.container)):i.insertAfter(this.$element),this.$element.trigger("inserted.bs."+this.type);var l=this.getPosition(),f=i[0].offsetWidth,d=i[0].offsetHeight;if(u){var h=a,p=this.getPosition(this.$viewport);a="bottom"==a&&l.bottom+d>p.bottom?"top":"top"==a&&l.top-dp.width?"left":"left"==a&&l.left-fa.top+a.height&&(i.top=a.top+a.height-u)}else{var c=t.left-o,l=t.left+o+r;ca.right&&(i.left=a.left+a.width-l)}return i},c.prototype.getTitle=function(){var e,t=this.$element,r=this.options;return e=t.attr("data-original-title")||("function"==typeof r.title?r.title.call(t[0]):r.title)},c.prototype.getUID=function(e){do{e+=~~(1e6*Math.random())}while(document.getElementById(e));return e},c.prototype.tip=function(){if(!this.$tip&&(this.$tip=e(this.options.template),1!=this.$tip.length))throw new Error(this.type+" `template` option must consist of exactly 1 top-level element!");return this.$tip},c.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},c.prototype.enable=function(){this.enabled=!0},c.prototype.disable=function(){this.enabled=!1},c.prototype.toggleEnabled=function(){this.enabled=!this.enabled},c.prototype.toggle=function(t){var r=this;t&&((r=e(t.currentTarget).data("bs."+this.type))||(r=new this.constructor(t.currentTarget,this.getDelegateOptions()),e(t.currentTarget).data("bs."+this.type,r))),t?(r.inState.click=!r.inState.click,r.isInStateTrue()?r.enter(r):r.leave(r)):r.tip().hasClass("in")?r.leave(r):r.enter(r)},c.prototype.destroy=function(){var e=this;clearTimeout(this.timeout),this.hide((function(){e.$element.off("."+e.type).removeData("bs."+e.type),e.$tip&&e.$tip.detach(),e.$tip=null,e.$arrow=null,e.$viewport=null,e.$element=null}))},c.prototype.sanitizeHtml=function(e){return u(e,this.options.whiteList,this.options.sanitizeFn)};var f=e.fn.tooltip;e.fn.tooltip=l,e.fn.tooltip.Constructor=c,e.fn.tooltip.noConflict=function(){return e.fn.tooltip=f,this}}(jQuery),function(e){"use strict";var t=function(e,t){this.init("popover",e,t)};if(!e.fn.tooltip)throw new Error("Popover requires tooltip.js");function r(r){return this.each((function(){var n=e(this),i=n.data("bs.popover"),o="object"==typeof r&&r;!i&&/destroy|hide/.test(r)||(i||n.data("bs.popover",i=new t(this,o)),"string"==typeof r&&i[r]())}))}t.VERSION="3.4.1",t.DEFAULTS=e.extend({},e.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:''}),t.prototype=e.extend({},e.fn.tooltip.Constructor.prototype),t.prototype.constructor=t,t.prototype.getDefaults=function(){return t.DEFAULTS},t.prototype.setContent=function(){var e=this.tip(),t=this.getTitle(),r=this.getContent();if(this.options.html){var n=typeof r;this.options.sanitize&&(t=this.sanitizeHtml(t),"string"===n&&(r=this.sanitizeHtml(r))),e.find(".popover-title").html(t),e.find(".popover-content").children().detach().end()["string"===n?"html":"append"](r)}else e.find(".popover-title").text(t),e.find(".popover-content").children().detach().end().text(r);e.removeClass("fade top bottom left right in"),e.find(".popover-title").html()||e.find(".popover-title").hide()},t.prototype.hasContent=function(){return this.getTitle()||this.getContent()},t.prototype.getContent=function(){var e=this.$element,t=this.options;return e.attr("data-content")||("function"==typeof t.content?t.content.call(e[0]):t.content)},t.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")};var n=e.fn.popover;e.fn.popover=r,e.fn.popover.Constructor=t,e.fn.popover.noConflict=function(){return e.fn.popover=n,this}}(jQuery),function(e){"use strict";function t(r,n){this.$body=e(document.body),this.$scrollElement=e(r).is(document.body)?e(window):e(r),this.options=e.extend({},t.DEFAULTS,n),this.selector=(this.options.target||"")+" .nav li > a",this.offsets=[],this.targets=[],this.activeTarget=null,this.scrollHeight=0,this.$scrollElement.on("scroll.bs.scrollspy",e.proxy(this.process,this)),this.refresh(),this.process()}function r(r){return this.each((function(){var n=e(this),i=n.data("bs.scrollspy"),o="object"==typeof r&&r;i||n.data("bs.scrollspy",i=new t(this,o)),"string"==typeof r&&i[r]()}))}t.VERSION="3.4.1",t.DEFAULTS={offset:10},t.prototype.getScrollHeight=function(){return this.$scrollElement[0].scrollHeight||Math.max(this.$body[0].scrollHeight,document.documentElement.scrollHeight)},t.prototype.refresh=function(){var t=this,r="offset",n=0;this.offsets=[],this.targets=[],this.scrollHeight=this.getScrollHeight(),e.isWindow(this.$scrollElement[0])||(r="position",n=this.$scrollElement.scrollTop()),this.$body.find(this.selector).map((function(){var t=e(this),i=t.data("target")||t.attr("href"),o=/^#./.test(i)&&e(i);return o&&o.length&&o.is(":visible")&&[[o[r]().top+n,i]]||null})).sort((function(e,t){return e[0]-t[0]})).each((function(){t.offsets.push(this[0]),t.targets.push(this[1])}))},t.prototype.process=function(){var e=this.$scrollElement.scrollTop()+this.options.offset,t=this.getScrollHeight(),r=this.options.offset+t-this.$scrollElement.height(),n=this.offsets,i=this.targets,o=this.activeTarget,a;if(this.scrollHeight!=t&&this.refresh(),e>=r)return o!=(a=i[i.length-1])&&this.activate(a);if(o&&e=n[a]&&(void 0===n[a+1]||e .active"),a=i&&e.support.transition&&(o.length&&o.hasClass("fade")||!!n.find("> .fade").length);function s(){o.removeClass("active").find("> .dropdown-menu > .active").removeClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!1),r.addClass("active").find('[data-toggle="tab"]').attr("aria-expanded",!0),a?(r[0].offsetWidth,r.addClass("in")):r.removeClass("fade"),r.parent(".dropdown-menu").length&&r.closest("li.dropdown").addClass("active").end().find('[data-toggle="tab"]').attr("aria-expanded",!0),i&&i()}o.length&&a?o.one("bsTransitionEnd",s).emulateTransitionEnd(t.TRANSITION_DURATION):s(),o.removeClass("in")};var n=e.fn.tab;e.fn.tab=r,e.fn.tab.Constructor=t,e.fn.tab.noConflict=function(){return e.fn.tab=n,this};var i=function(t){t.preventDefault(),r.call(e(this),"show")};e(document).on("click.bs.tab.data-api",'[data-toggle="tab"]',i).on("click.bs.tab.data-api",'[data-toggle="pill"]',i)}(jQuery),function(e){"use strict";var t=function(r,n){this.options=e.extend({},t.DEFAULTS,n);var i=this.options.target===t.DEFAULTS.target?e(this.options.target):e(document).find(this.options.target);this.$target=i.on("scroll.bs.affix.data-api",e.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",e.proxy(this.checkPositionWithEventLoop,this)),this.$element=e(r),this.affixed=null,this.unpin=null,this.pinnedOffset=null,this.checkPosition()};function r(r){return this.each((function(){var n=e(this),i=n.data("bs.affix"),o="object"==typeof r&&r;i||n.data("bs.affix",i=new t(this,o)),"string"==typeof r&&i[r]()}))}t.VERSION="3.4.1",t.RESET="affix affix-top affix-bottom",t.DEFAULTS={offset:0,target:window},t.prototype.getState=function(e,t,r,n){var i=this.$target.scrollTop(),o=this.$element.offset(),a=this.$target.height();if(null!=r&&"top"==this.affixed)return i=e-n&&"bottom"},t.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(t.RESET).addClass("affix");var e=this.$target.scrollTop(),r=this.$element.offset();return this.pinnedOffset=r.top-e},t.prototype.checkPositionWithEventLoop=function(){setTimeout(e.proxy(this.checkPosition,this),1)},t.prototype.checkPosition=function(){if(this.$element.is(":visible")){var r=this.$element.height(),n=this.options.offset,i=n.top,o=n.bottom,a=Math.max(e(document).height(),e(document.body).height());"object"!=typeof n&&(o=i=n),"function"==typeof i&&(i=n.top(this.$element)),"function"==typeof o&&(o=n.bottom(this.$element));var s=this.getState(a,r,i,o);if(this.affixed!=s){null!=this.unpin&&this.$element.css("top","");var u="affix"+(s?"-"+s:""),c=e.Event(u+".bs.affix");if(this.$element.trigger(c),c.isDefaultPrevented())return;this.affixed=s,this.unpin="bottom"==s?this.getPinnedOffset():null,this.$element.removeClass(t.RESET).addClass(u).trigger(u.replace("affix","affixed")+".bs.affix")}"bottom"==s&&this.$element.offset({top:a-r-o})}};var n=e.fn.affix;e.fn.affix=r,e.fn.affix.Constructor=t,e.fn.affix.noConflict=function(){return e.fn.affix=n,this},e(window).on("load",(function(){e('[data-spy="affix"]').each((function(){var t=e(this),n=t.data();n.offset=n.offset||{},null!=n.offsetBottom&&(n.offset.bottom=n.offsetBottom),null!=n.offsetTop&&(n.offset.top=n.offsetTop),r.call(t,n)}))}))}(jQuery)}}}},fibers:{"package.json":function e(t,r,e){e.exports={name:"fibers",version:"5.0.3",main:"fibers"}},"fibers.js":function e(t,r,e,n,i){if(process.fiberLib)e.exports=process.fiberLib;else{var o=t("fs"),a=t("path"),s=t("detect-libc");Math.random();var u=a.join(i,"bin",process.platform+"-"+process.arch+"-"+process.versions.modules+("linux"===process.platform?"-"+s.family:""),"fibers");try{process.fiberLib=e.exports=t(u).Fiber}catch(l){throw console.error("## There is an issue with `node-fibers` ##\n`"+u+".node` is missing.\n\nTry running this to fix the issue: "+process.execPath+" "+i.replace(" ","\\ ")+"/build"),console.error(l.stack||l.message||l),new Error("Missing binary. See message above.")}c(e.exports)}function c(e){try{var t=process.binding("async_wrap"),r;if(t.asyncIdStackSize instanceof Function)r=t.asyncIdStackSize;else{if(void 0===t.constants.kStackLength)throw new Error("Couldn't figure out how to get async stack size");f=t.constants.kStackLength,r=function(){return t.async_hook_fields[f]}}var n=t.popAsyncContext||t.popAsyncIds,i=t.pushAsyncContext||t.pushAsyncIds,o,a;if(!n||!i)throw new Error("Push/pop do not exist");o=void 0===t.constants.kExecutionAsyncId?t.constants.kCurrentAsyncId:t.constants.kExecutionAsyncId,a=void 0===t.constants.kTriggerAsyncId?t.constants.kCurrentTriggerId:t.constants.kTriggerAsyncId;var s=t.async_id_fields||t.async_uid_fields;function u(){for(var e=r(),t=new Array(e);e>0;--e){var i=s[o];t[e-1]={asyncId:i,triggerId:s[a]},n(i)}return t}function c(e){for(var t=0;t0)i.changeLanguage(e,n);else if(0!=s[u]){s[u]=0;var c=new XMLHttpRequest;c.overrideMimeType("application/json"),c.open("GET",u,!1),c.send(null),200===c.status?s[u]=1:s[u]=-1,r.addResourceBundle(e,a,JSON.parse(c.response)||{}),i.changeLanguage(e,n)}};r.changeLanguage=p;var b=function(e,t,r){return i.format(e,t,r)};r.format=b;var m=function(){return i.languages};r.getLanguages=m;var g=function(e,t){return i.loadLanguages(e,t)};r.loadLanguages=g;var v=function(e,t){return i.loadNamespaces(e,t)};r.loadNamespaces=v;var y=function(e,t){return i.on(e,t)};r.on=y;var w=function(e,t){return i.off(e,t)};r.off=w,n.__exportStar(t("./i18n/i18n"),r),n.__exportStar(t("./i18n/i18n.app"),r),n.__exportStar(t("./translations"),r)},i18n:{"i18n.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.fallbackKeys=r.getObjectI18nTemplate=r.translationI18nObjects=r.addObjectsI18n=r.translationI18nObject=void 0;var n=t("../index"),i=t("underscore"),o=t("clone"),a="_",s="base",u="core",c="translation",l=function(e,t){var r={lng:t,ns:c};if((0,n.exists)(e,r))return(0,n._t)(e,r)},f=function(e){return"".concat(e,"__object")},d=function(e,t){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t)},h=function(e,t){var r=d(e,t);return"".concat(r).concat("_","inlineHelpText")},p=function(e,t){var r=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","group").concat("_").concat(r)},b=function(e,t,r){return t&&(t=t.replace(/\./g,"_")),"".concat(e).concat("_","field").concat("_").concat(t).concat("_","options").concat("_").concat(r)},m=function(e,t){return"".concat(e).concat("_","action").concat("_").concat(t)},g=function(e,t){return"".concat(e).concat("_","listview").concat("_").concat(t)},v=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},y=function(e,t,r){var n=f(t);return l(n,e)||r||""},w=function(e,t,r,n,i){var o=d(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=w(e,s,r,n,i))}return a||n||""},_=function(e,t,r,n,i){var o=h(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=_(e,s,r,n,i))}return a||n||""},x=function(e,t,r,n){var i=p(t,r);return l(i,e)||n||""},k=function(e,t,r,n,i,o){var a=b(t,r,n),s=l(a,e);if(!s){var u=v(o);u&&"base"!=t&&"core"!=t&&(s=k(e,u,r,n,i,o))}return s||i||""},S=function(e,t,r,n,i){var o=m(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=S(e,s,r,n,i))}return a||n||""},j=function(e,t,r,n,i){var o=g(t,r),a=l(o,e);if(!a){var s=v(i);s&&"base"!=t&&"core"!=t&&(a=j(e,s,r,n,i))}return a||n||""},A=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},D=function(e){i.forEach(e.fields,(function(e,t){var r=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;return e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return r.push(A(e))}))):r.push(A(e))})),e.options=r}catch(n){console.error("convertFieldsOptions error: ",e.options,n)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return r.push({label:e,value:t})})),e.options=r)}))},E=function(e,t,r){r.label=y(e,t,r.label),i.each(r.fields,(function(n,o){if(n.label=w(e,t,o,n.label,r.datasource),n.inlineHelpText&&(n.inlineHelpText=_(e,t,o,n.inlineHelpText,r.datasource)),n.group&&(n.group=x(e,t,n.group,n.group)),n.options){var a=[];i.each(n.options,(function(n){if(i.has(n,"value")){var s=k(e,t,o,n.value,n.label,r.datasource);a.push(i.extend({},n,{label:s}))}else a.push(n)})),n.options=a}})),i.each(r.actions,(function(n,i){n.label=S(e,t,i,n.label,r.datasource)})),i.each(r.list_views,(function(n,i){n.label=j(e,t,i,n.label,r.datasource)}))};r.translationI18nObject=E;var O=function(e){i.each(e,(function(e){(0,n.addResourceBundle)(e.lng,c,e.data,!0,!0)}))};r.addObjectsI18n=O;var C=function(e,t){i.each(t,(function(t,n){(0,r.translationI18nObject)(e,n,t)}))};r.translationI18nObjects=C;var T=function(e,t,r){var n=o(r);D(n);var a={};return a[f(t)]=y(e,t,n.label),i.each(n.fields,(function(r,o){a[d(t,o)]=w(e,t,o,r.label),r.inlineHelpText&&(a[h(t,o)]=_(e,t,o,r.inlineHelpText,n.datasource)),r.group&&(a[p(t,r.group)]=x(e,t,r.group,r.group)),r.options&&i.each(r.options,(function(r){i.has(r,"value")&&(a[b(t,o,r.value)]=k(e,t,o,r.value,r.label))}))})),i.each(n.actions,(function(r,n){a[m(t,n)]=S(e,t,n,r.label)})),i.each(n.list_views,(function(r,n){a[g(t,n)]=j(e,t,n,r.label)})),a};r.getObjectI18nTemplate=T,r.fallbackKeys={getObjectLabelKey:f,getObjectFieldLabelKey:d,getObjectFieldInlineHelpTextLabelKey:h,getObjectFieldGroupKey:p,getObjectFieldOptionsLabelKey:b,getObjectActionLabelKey:m,getObjectListviewLabelKey:g}},"i18n.app.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.appFallbackKeys=r.getAppI18nTemplate=r.translationI18nApps=r.translationI18nMenus=void 0;var n=t("../index"),i=t("underscore"),o=t("clone"),a="translation",s="_",u=function(e,t){var r={lng:t,ns:a};if((0,n.exists)(e,r))return(0,n._t)(e,r)},c=function(e){return"app".concat("_").concat(e).concat("_","name")},l=function(e){return"app".concat("_").concat(e).concat("_","description")},f=function(e,t){var r=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");return"".concat(e).concat("_","tab_group").concat("_").concat(r)},d=function(e){return"menu".concat("_").concat(e)},h=function(e){return"tab".concat("_").concat(e)},p=function(e,t,r){var n=c(t);return u(n,e)||r||""},b=function(e,t,r){var n=l(t);return u(n,e)||r||""},m=function(e,t,r){var n=d(t);return u(n,e)||r||""},g=function(e,t,n){n.label=p(e,t,n.label||n.name),n.description=b(e,t,n.description),(0,r.translationI18nMenus)(e,n.admin_menus)},v=function(e,t){i.each(t,(function(t){var r=m(e,t._id,t.label||t.name);t.label=r,t.name=r}))};r.translationI18nMenus=v;var y=function(e,t){i.each(t,(function(t,r){g(e,r,t)}))};r.translationI18nApps=y;var w=function(e,t,r){var n=o(r),a={};return a[c(t)]=p(e,t,n.label||n.name),a[l(t)]=b(e,t,n.description),i.each(n.admin_menus,(function(t){a[d(t._id)]=m(e,t._id,t.label||t.name)})),a};r.getAppI18nTemplate=w,r.appFallbackKeys={getAppLabelKey:c,getAppDescriptionKey:l,getAppGroupKey:f,getMenuLabelKey:d,getTabKey:h}}},translations:{"index.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.SteedosTranslationPrefixKeys=r.convertObject=void 0;var n=t("tslib"),i=t("underscore");n.__exportStar(t("./objectTranslation"),r),n.__exportStar(t("./translation"),r),n.__exportStar(t("./templates/objectTranslation"),r),n.__exportStar(t("./templates/translation"),r);var o=function(e){var t;return(t=e.split(":")).length>1?{label:t[0],value:t[1]}:{label:t[0],value:t[0]}},a=function(e){i.forEach(e.fields,(function(e,t){var r=[];if(e.options&&i.isString(e.options))try{i.forEach(e.options.split("\n"),(function(e){var t;e.indexOf(",")?(t=e.split(","),i.forEach(t,(function(e){return r.push(o(e))}))):r.push(o(e))})),e.options=r}catch(n){console.error("convertFieldsOptions error: ",e.options,n)}else if(e.options&&i.isArray(e.options))try{i.forEach(e.options,(function(e){i.isString(e)?r.push(o(e)):r.push(e)})),e.options=r}catch(n){console.error("Creator.convertFieldsOptions",e.options,n)}else e.options&&!i.isFunction(e.options)&&!i.isArray(e.options)&&i.isObject(e.options)&&(i.each(e.options,(function(e,t){return r.push({label:e,value:t})})),e.options=r)}))},s;r.convertObject=a,function(e){e.Object="CustomObject",e.Field="CustomField",e.Action="CustomAction",e.Listview="CustomListview",e.Permission="CustomPermission",e.ValidationRule="CustomValidationRule",e.Application="CustomApplication",e.Tab="CustomTabs",e.Permissionset="CustomPermissionset",e.Profile="CustomProfile",e.Report="CustomReport",e.Workflow="Workflow",e.Layout="Layout",e.Client="Client",e.Server="Server",e.Function="Function",e.Router="Router",e.Trigger="Trigger"}(s=r.SteedosTranslationPrefixKeys||(r.SteedosTranslationPrefixKeys={}))},"objectTranslation.js":function e(t,r,e,n){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.addObjectsTranslation=r.getObjectTranslationTemplate=r.translationObjects=r.translationObject=r.translationObjectLabel=void 0;var i=t("underscore"),o=t("./"),a=t("../index"),s=t("./index"),u=t("../i18n/i18n"),c=t("lodash"),l=t("crypto"),f,d=(0,t("@steedos/cachers").getCacher)("lru.translations.objects");function h(e){var t;return l.createHash("md5").update(e).digest("hex")}var p=function(e,t){return"".concat(e,"_").concat(t.name,"_").concat(h(JSON.stringify(t)))},b=t("clone"),m=".",g="base",v="core",y="translation",w="object",_="field",x="listview",k="action",S=function(e,t){var r={lng:t,ns:y,keySeparator:!1};if((0,a.exists)(e,r))return(0,a._t)(e,r)},j=function(e){if(!e)return"";var t="core";return"default"!==e&&"meteor"!==e||(t="base"),t},A=function(e){switch(e){case"object":return o.SteedosTranslationPrefixKeys.Object;case"field":return o.SteedosTranslationPrefixKeys.Field;case"listview":return o.SteedosTranslationPrefixKeys.Listview;case"action":return o.SteedosTranslationPrefixKeys.Action;default:return"CustomLabels"}},D=function(e){var t;return[A(),e].join(".")},E=function(e){var t;return[A("object"),e,"label"].join(".")},O=function(e){var t;return[A("object"),e,"description"].join(".")},C=function(e,t){var r;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"label"].join(".")},T=function(e,t){var r;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"help"].join(".")},M=function(e,t){var r;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"description"].join(".")},B=function(e,t){var r=t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_"),n;return[A("field"),e,"group",r].join(".")},I=function(e,t,r){var n;return t&&(t=t.replace(/\./g,"_")),[A("field"),e,t,"options",r].join(".")},R=function(e,t){var r;return[A("action"),e,t].join(".")},N=function(e,t){var r;return[A("listview"),e,t].join(".")},F=function(e,t,r){var n,i=[E(t)],o=u.fallbackKeys.getObjectLabelKey(t);return o&&i.push(o),S(i,e)||r||""};r.translationObjectLabel=F;var L=function(e,t,r){var n=O(t);return S(n,e)||r||""},P=function(e,t,r,n,i,o){var a,s=[C(t,r)],c=u.fallbackKeys.getObjectFieldLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=P(e,f,r,n,i))}return l||n||""},q=function(e,t,r,n,i,o){var a,s=[T(t,r)],c=u.fallbackKeys.getObjectFieldInlineHelpTextLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=q(e,f,r,n,i))}return l||n||""},z=function(e,t,r,n,i,o){var a=M(t,r),s,u=S([a],e);if(1!=o&&!u){var c=j(i);c&&"base"!=t&&"core"!=t&&(u=z(e,c,r,n,i))}return u||n||""},U=function(e,t,r,n,i,o){var a,s=[B(t,r)],c=u.fallbackKeys.getObjectFieldGroupKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=U(e,f,r,n,i))}return l||n||""},$=function(e,t,r,n,i,o,a){var s,c=[I(t,r,n)],l=u.fallbackKeys.getObjectFieldOptionsLabelKey(t,r,n);l&&c.push(l);var f=S(c,e);if(1!=a&&!f){var d=j(o);d&&"base"!=t&&"core"!=t&&(f=$(e,d,r,n,i,o))}return f||i||""},H=function(e,t,r,n,i,o){var a,s=[R(t,r)],c=u.fallbackKeys.getObjectActionLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=H(e,f,r,n,i))}return l||n||""},W=function(e,t,r,n,i,o){var a,s=[N(t,r)],c=u.fallbackKeys.getObjectListviewLabelKey(t,r);c&&s.push(c);var l=S(s,e);if(1!=o&&!l){var f=j(i);f&&"base"!=t&&"core"!=t&&(l=W(e,f,r,n,i))}return l||n||""},Y=function(e,t,n,o,a){void 0===a&&(a=!1);var u=p(e,n),l=d.get(u);if(l)return Object.assign(n,(0,c.cloneDeep)(l));o&&(0,s.convertObject)(n),n.label=(0,r.translationObjectLabel)(e,t,n.label),n.description=L(e,t,n.description),i.each(n.fields,(function(r,o){if(r.label=P(e,t,o,r.label,n.datasource,a),r.inlineHelpText=q(e,t,o,r.inlineHelpText,n.datasource,a),r.description=z(e,t,o,r.description,n.datasource,a),r.group&&(r.group=U(e,t,r.group,r.group,n.datasource,a)),r.options){var s=[];i.each(r.options,(function(r){if(i.has(r,"value")){var u=$(e,t,o,r.value,r.label,n.datasource,a);s.push(i.extend({},r,{label:u}))}else s.push(r)})),r.options=s}})),i.each(n.actions,(function(r,i){r.label=H(e,t,i,r.label,n.datasource,a)})),i.each(n.list_views,(function(r,i){r.label=W(e,t,i,r.label,n.datasource,a)})),d.set(u,(0,c.cloneDeep)(n))};r.translationObject=Y;var V=function(e,t){i.each(t,(function(t,n){(0,r.translationObject)(e,n,t)}))};r.translationObjects=V;var K=function(e,t,n){var o=b(n);(0,s.convertObject)(o);var a={};return a[E(t)]=(0,r.translationObjectLabel)(e,t,o.label),a[O(t)]=L(e,t,o.description),i.each(o.fields,(function(r,n){a[C(t,n)]=P(e,t,n,r.label),r.inlineHelpText&&(a[T(t,n)]=q(e,t,n,r.inlineHelpText,o.datasource)),r.description&&(a[M(t,n)]=z(e,t,n,r.description,o.datasource)),r.group&&(a[B(t,r.group)]=U(e,t,r.group,r.group,o.datasource)),r.options&&i.each(r.options,(function(r){i.has(r,"value")&&(a[I(t,n,r.value)]=$(e,t,n,r.value,r.label))}))})),i.each(o.actions,(function(r,n){a[R(t,n)]=H(e,t,n,r.label)})),i.each(o.list_views,(function(r,n){a[N(t,n)]=W(e,t,n,r.label)})),a};function G(e,t){var r=b(e);(0,s.convertObject)(r);var n={},o=r.name;return o||console.error("Error: Invalid objectTranslation:"+t),n[E(o)]=r.label,n[O(o)]=r.description,i.each(r.fields,(function(e,t){n[C(o,t)]=e.label,e.help&&(n[T(o,t)]=e.help),e.description&&(n[M(o,t)]=e.description),e.options&&i.each(e.options,(function(e){i.has(e,"value")&&(n[I(o,t,e.value)]=e.label)}))})),i.each(r.groups,(function(e,t){n[B(o,t)]=e})),i.each(r.actions,(function(e,t){n[R(o,t)]=e.label})),i.each(r.listviews,(function(e,t){n[N(o,t)]=e.label})),i.each(r.CustomLabels,(function(e,t){n[D(t)]=e})),n}r.getObjectTranslationTemplate=K;var X=function(e){i.each(e,(function(e){var t=G(e.data,e.__filename);(0,a.addResourceBundle)(e.lng,y,t,!0,!0)}))};r.addObjectsTranslation=X},"translation.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.addTranslations=r.convertTranslation=r.convertTranslationData=r.getAppTranslationTemplate=r.translationApps=r.translationMenus=r.translationApp=r.translationTabLabel=r.translationTabGroup=void 0;var n=t("../index"),i=t("underscore"),o=t("./"),a=t("../i18n/i18n.app"),s=t("clone"),u="translation",c=".",l="app",f="menu",d="tab",h=function(e){switch(e){case"app":return o.SteedosTranslationPrefixKeys.Application;case"tab":return o.SteedosTranslationPrefixKeys.Tab;default:return"CustomLabels"}},p=function(e){var t;return[h(),e].join(".")},b=function(e,t){var r={lng:t,ns:u,keySeparator:!1};if((0,n.exists)(e,r))return(0,n._t)(e,r)},m=function(e){var t;return[h("app"),e,"name"].join(".")},g=function(e){var t;return[h("app"),e,"description"].join(".")},v=function(e,t){var r,n;return[h("app"),e,"groups",t.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_")].join(".")},y=function(e){var t;return[h("menu"),"menu_".concat(e)].join(".")},w=function(e){var t;return[h("tab"),e].join(".")},_=function(e,t,r){var n,i=[m(t)],o=a.appFallbackKeys.getAppLabelKey(t);return o&&i.push(o),b(i,e)||r||""},x=function(e,t,r){var n,i=[g(t)],o=a.appFallbackKeys.getAppDescriptionKey(t);return o&&i.push(o),b(i,e)||r||""},k=function(e,t,r,n){var i,o=[v(t,r)],s=a.appFallbackKeys.getAppGroupKey(t,r);return s&&o.push(s),b(o,e)||n||""};r.translationTabGroup=k;var S=function(e,t,r){var n,i=[y(t)],o=a.appFallbackKeys.getMenuLabelKey(t);return o&&i.push(o),b(i,e)||r||""},j=function(e,t,r){var n,i=[w(t)],o=a.appFallbackKeys.getTabKey(t);return o&&i.push(o),b(i,e)||r||""};r.translationTabLabel=j;var A=function(e,t,n){n.label=_(e,t,n.label||n.name),n.description=x(e,t,n.description),i.each(n.tab_groups,(function(i,o){n.tab_groups[o].id=i.id||i.group_name,n.tab_groups[o].group_name=(0,r.translationTabGroup)(e,t,i.group_name,i.group_name)})),(0,r.translationMenus)(e,n.admin_menus)};r.translationApp=A;var D=function(e,t){i.each(t,(function(t){var r=S(e,t._id,t.label||t.name);t.label=r,t.name=r}))};r.translationMenus=D;var E=function(e,t){i.each(t,(function(t,n){(0,r.translationApp)(e,n,t)}))};r.translationApps=E;var O=function(e,t,r){var n=s(r),o={};return o[m(t)]=_(e,t,n.label||n.name),o[g(t)]=x(e,t,n.description),i.each(n.admin_menus,(function(t){o[y(t._id)]=S(e,t._id,t.label||t.name)})),o};r.getAppTranslationTemplate=O;var C=function(e,t,r){i.isArray(r)?i.each(r,(function(e){C(e,"",e)})):r&&i.each(i.keys(r),(function(n){var o=t?"".concat(t,".").concat(n):n,a=r[n];"object"==typeof a?i.isArray(a)?i.each(a,(function(e){C(e,o,a)})):C(e,o,a):e[o]=a}))};function T(e){for(var t in e)"object"==typeof e[t]&&C(e,t,e[t]);return e}r.convertTranslationData=T;var M=function(e){var t=s(e),r={};return i.each(t.CustomApplications,(function(e,t){r[m(t)]=e.name,r[g(t)]=e.description,i.each(e.groups,(function(e,n){r[v(t,n)]=e}))})),i.each(t.CustomTabs,(function(e,t){r[w(t)]=e})),i.each(t.CustomLabels,(function(e,t){var n;if("simpleschema"!=t&&i.isObject(e)){var o=T(((n={})[t]=e,n));i.each(o,(function(e,t){i.isObject(e)||(r[p(t)]=e)}))}else r[p(t)]=e})),r};r.convertTranslation=M;var B=function(e){i.each(e,(function(e){var t=(0,r.convertTranslation)(e.data);(0,n.addResourceBundle)(e.lng,u,t,!0,!0)}))};r.addTranslations=B},templates:{"objectTranslation.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.getObjectMetadataTranslationTemplate=void 0;var n=t("underscore"),i=t("../index"),o=t("clone");function a(e,t){var r={};return n.each(e,(function(e){r[e]="help"===e?t.inlineHelpText||"":t[e]||""})),r}function s(e){return a(["label","description"],e)}function u(e){switch(e.type){case"select":return a(["label","help","options","description"],e);default:return a(["label","help","description"],e)}}function c(e){return a(["label"],e)}function l(e){return a(["label"],e)}function f(e){var t={};return n.each(e,(function(e,r){t[r]=u(e)})),t}function d(e){var t={};return n.each(e,(function(e,r){t[r]=l(e)})),t}function h(e){var t={};return n.each(e,(function(e,r){t[r]=c(e)})),t}function p(e,t){var r={};return n.each(e,(function(e,n){if(e.group){var i=e.group.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");r[i]=t[n].group}})),r}var b=function(e,t,r,a){void 0===a&&(a=!1);var u=o(r);1!=a&&(0,i.translationObject)(e,t,u,!0,a);var c=Object.assign({},s(u));c=Object.assign({},c,{fields:f(u.fields)});var l=p(r.fields,u.fields);n.isEmpty(l)||(c=Object.assign({},c,{groups:l}));var b=h(u.list_views);n.isEmpty(b)||(c=Object.assign({},c,{listviews:b}));var m=d(u.actions);return n.isEmpty(m)||(c=Object.assign({},c,{actions:m})),Object.assign({name:t},c)};r.getObjectMetadataTranslationTemplate=b},"translation.js":function e(t,r){"use strict";Object.defineProperty(r,"__esModule",{value:!0}),r.getAppMetadataTranslationTemplate=void 0;var n=t("underscore"),i=t("../index"),o=t("clone");function a(e,t){var r={};return n.each(e,(function(e){r[e]=t[e]||""})),r}function s(e){var t={groups:{}};return e?(n.each(e,(function(e){var r=e.group_name.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t.groups[r]=e.group_name})),t):{}}var u=function(e){return Object.assign({},a(["name","description"],e),s(e.tab_groups))},c=function(e){var t={};return n.each(e,(function(e,r){t[r]=r})),t},l=function(e){var t={};return n.each(e,(function(e){var r=e.toLocaleLowerCase().replace(/\%/g,"_").replace(/\./g,"_").replace(/\ /g,"_");t[r]=e})),t},f=function(e,t,r){var n,a=o(r);(0,i.translationApp)(e,t,a);var s={},f;return a.tab_items?s=c(a.tab_items):a.tabs&&(s=l(a.tabs)),Object.assign({},{CustomApplications:(n={},n[t]=u(a),n)},{CustomTabs:s})};r.getAppMetadataTranslationTemplate=f}}}},node_modules:{i18next:{"package.json":function e(t,r,e){e.exports={name:"i18next",version:"19.9.2",main:"./dist/cjs/i18next.js",module:"./dist/esm/i18next.js"}},dist:{cjs:{"i18next.js":function e(t,r,e){"use strict";var n=t("@babel/runtime/helpers/typeof"),i=t("@babel/runtime/helpers/objectSpread"),o=t("@babel/runtime/helpers/classCallCheck"),a=t("@babel/runtime/helpers/createClass"),s=t("@babel/runtime/helpers/possibleConstructorReturn"),u=t("@babel/runtime/helpers/getPrototypeOf"),c=t("@babel/runtime/helpers/assertThisInitialized"),l=t("@babel/runtime/helpers/inherits");function f(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var d=f(n),h=f(i),p=f(o),b=f(a),m=f(s),g=f(u),v=f(c),y=f(l),w={type:"logger",log:function e(t){this.output("log",t)},warn:function e(t){this.output("warn",t)},error:function e(t){this.output("error",t)},output:function e(t,r){console&&console[t]&&console[t].apply(console,r)}},_,x=new(function(){function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};p.default(this,e),this.init(t,r)}return b.default(e,[{key:"init",value:function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};this.prefix=r.prefix||"i18next:",this.logger=t||w,this.options=r,this.debug=r.debug}},{key:"setDebug",value:function e(t){this.debug=t}},{key:"log",value:function e(){for(var t=arguments.length,r=new Array(t),n=0;n1?r-1:0),i=1;i-1?e.replace(/###/g,"."):e}function i(){return!e||"string"==typeof e}for(var o="string"!=typeof t?[].concat(t):t.split(".");o.length>1;){if(i())return{};var a=n(o.shift());!e[a]&&r&&(e[a]=new r),e=Object.prototype.hasOwnProperty.call(e,a)?e[a]:{}}return i()?{}:{obj:e,k:n(o.shift())}}function E(e,t,r){var n=D(e,t,Object),i,o;n.obj[n.k]=r}function O(e,t,r,n){var i=D(e,t,Object),o=i.obj,a=i.k;o[a]=o[a]||[],n&&(o[a]=o[a].concat(r)),n||o[a].push(r)}function C(e,t){var r=D(e,t),n=r.obj,i=r.k;if(n)return n[i]}function T(e,t,r){var n=C(e,r);return void 0!==n?n:C(t,r)}function M(e,t,r){for(var n in t)"__proto__"!==n&&"constructor"!==n&&(n in e?"string"==typeof e[n]||e[n]instanceof String||"string"==typeof t[n]||t[n]instanceof String?r&&(e[n]=t[n]):M(e[n],t[n],r):e[n]=t[n]);return e}function B(e){return e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g,"\\$&")}var I={"&":"&","<":"<",">":">",'"':""","'":"'","/":"/"};function R(e){return"string"==typeof e?e.replace(/[&<>"'\/]/g,(function(e){return I[e]})):e}var N="undefined"!=typeof window&&window.navigator&&window.navigator.userAgent&&window.navigator.userAgent.indexOf("MSIE")>-1,F=function(e){function t(e){var r,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{ns:["translation"],defaultNS:"translation"};return p.default(this,t),r=m.default(this,g.default(t).call(this)),N&&k.call(v.default(r)),r.data=e||{},r.options=n,void 0===r.options.keySeparator&&(r.options.keySeparator="."),r}return y.default(t,e),b.default(t,[{key:"addNamespaces",value:function e(t){this.options.ns.indexOf(t)<0&&this.options.ns.push(t)}},{key:"removeNamespaces",value:function e(t){var r=this.options.ns.indexOf(t);r>-1&&this.options.ns.splice(r,1)}},{key:"getResource",value:function e(t,r,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},o=void 0!==i.keySeparator?i.keySeparator:this.options.keySeparator,a=[t,r];return n&&"string"!=typeof n&&(a=a.concat(n)),n&&"string"==typeof n&&(a=a.concat(o?n.split(o):n)),t.indexOf(".")>-1&&(a=t.split(".")),C(this.data,a)}},{key:"addResource",value:function e(t,r,n,i){var o=arguments.length>4&&void 0!==arguments[4]?arguments[4]:{silent:!1},a=this.options.keySeparator;void 0===a&&(a=".");var s=[t,r];n&&(s=s.concat(a?n.split(a):n)),t.indexOf(".")>-1&&(i=r,r=(s=t.split("."))[1]),this.addNamespaces(r),E(this.data,s,i),o.silent||this.emit("added",t,r,n,i)}},{key:"addResources",value:function e(t,r,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{silent:!1};for(var o in n)"string"!=typeof n[o]&&"[object Array]"!==Object.prototype.toString.apply(n[o])||this.addResource(t,r,o,n[o],{silent:!0});i.silent||this.emit("added",t,r,n)}},{key:"addResourceBundle",value:function e(t,r,n,i,o){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{silent:!1},s=[t,r];t.indexOf(".")>-1&&(i=n,n=r,r=(s=t.split("."))[1]),this.addNamespaces(r);var u=C(this.data,s)||{};i?M(u,n,o):u=h.default({},u,n),E(this.data,s,u),a.silent||this.emit("added",t,r,n)}},{key:"removeResourceBundle",value:function e(t,r){this.hasResourceBundle(t,r)&&delete this.data[t][r],this.removeNamespaces(r),this.emit("removed",t,r)}},{key:"hasResourceBundle",value:function e(t,r){return void 0!==this.getResource(t,r)}},{key:"getResourceBundle",value:function e(t,r){return r||(r=this.options.defaultNS),"v1"===this.options.compatibilityAPI?h.default({},{},this.getResource(t,r)):this.getResource(t,r)}},{key:"getDataByLanguage",value:function e(t){return this.data[t]}},{key:"toJSON",value:function e(){return this.data}}]),t}(k),L={processors:{},addPostProcessor:function e(t){this.processors[t.name]=t},handle:function e(t,r,n,i,o){var a=this;return t.forEach((function(e){a.processors[e]&&(r=a.processors[e].process(r,n,i,o))})),r}},P={},q=function(e){function t(e){var r,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};return p.default(this,t),r=m.default(this,g.default(t).call(this)),N&&k.call(v.default(r)),A(["resourceStore","languageUtils","pluralResolver","interpolator","backendConnector","i18nFormat","utils"],e,v.default(r)),r.options=n,void 0===r.options.keySeparator&&(r.options.keySeparator="."),r.logger=x.create("translator"),r}return y.default(t,e),b.default(t,[{key:"changeLanguage",value:function e(t){t&&(this.language=t)}},{key:"exists",value:function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{interpolation:{}},n=this.resolve(t,r);return n&&void 0!==n.res}},{key:"extractFromKey",value:function e(t,r){var n=void 0!==r.nsSeparator?r.nsSeparator:this.options.nsSeparator;void 0===n&&(n=":");var i=void 0!==r.keySeparator?r.keySeparator:this.options.keySeparator,o=r.ns||this.options.defaultNS;if(n&&t.indexOf(n)>-1){var a=t.match(this.interpolator.nestingRegexp);if(a&&a.length>0)return{key:t,namespaces:o};var s=t.split(n);(n!==i||n===i&&this.options.ns.indexOf(s[0])>-1)&&(o=s.shift()),t=s.join(i)}return"string"==typeof o&&(o=[o]),{key:t,namespaces:o}}},{key:"translate",value:function e(r,n,i){var o=this;if("object"!==d.default(n)&&this.options.overloadTranslationOptionHandler&&(n=this.options.overloadTranslationOptionHandler(arguments)),n||(n={}),null==r)return"";Array.isArray(r)||(r=[String(r)]);var a=void 0!==n.keySeparator?n.keySeparator:this.options.keySeparator,s=this.extractFromKey(r[r.length-1],n),u=s.key,c=s.namespaces,l=c[c.length-1],f=n.lng||this.language,p=n.appendNamespaceToCIMode||this.options.appendNamespaceToCIMode;if(f&&"cimode"===f.toLowerCase()){if(p){var b=n.nsSeparator||this.options.nsSeparator;return l+b+u}return u}var m=this.resolve(r,n),g=m&&m.res,v=m&&m.usedKey||u,y=m&&m.exactUsedKey||u,w=Object.prototype.toString.apply(g),_=["[object Number]","[object Function]","[object RegExp]"],x=void 0!==n.joinArrays?n.joinArrays:this.options.joinArrays,k=!this.i18nFormat||this.i18nFormat.handleAsObject,S="string"!=typeof g&&"boolean"!=typeof g&&"number"!=typeof g;if(k&&g&&S&&_.indexOf(w)<0&&("string"!=typeof x||"[object Array]"!==w)){if(!n.returnObjects&&!this.options.returnObjects)return this.logger.warn("accessing an object - but returnObjects options is not enabled!"),this.options.returnedObjectHandler?this.options.returnedObjectHandler(v,g,n):"key '".concat(u," (").concat(this.language,")' returned an object instead of string.");if(a){var j="[object Array]"===w,A=j?[]:{},D=j?y:v;for(var E in g)if(Object.prototype.hasOwnProperty.call(g,E)){var O="".concat(D).concat(a).concat(E);A[E]=this.translate(O,h.default({},n,{joinArrays:!1,ns:c})),A[E]===O&&(A[E]=g[E])}g=A}}else if(k&&"string"==typeof x&&"[object Array]"===w)(g=g.join(x))&&(g=this.extendTranslation(g,r,n,i));else{var C=!1,T=!1,M=void 0!==n.count&&"string"!=typeof n.count,B=t.hasDefaultValue(n),I=M?this.pluralResolver.getSuffix(f,n.count):"",R=n["defaultValue".concat(I)]||n.defaultValue;!this.isValidLookup(g)&&B&&(C=!0,g=R),this.isValidLookup(g)||(T=!0,g=u);var N=B&&R!==g&&this.options.updateMissing;if(T||C||N){if(this.logger.log(N?"updateKey":"missingKey",f,l,u,N?R:g),a){var F=this.resolve(u,h.default({},n,{keySeparator:!1}));F&&F.res&&this.logger.warn("Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.")}var L=[],P=this.languageUtils.getFallbackCodes(this.options.fallbackLng,n.lng||this.language);if("fallback"===this.options.saveMissingTo&&P&&P[0])for(var q=0;q1&&void 0!==arguments[1]?arguments[1]:{},i,o,a,s,u;return"string"==typeof t&&(t=[t]),t.forEach((function(e){if(!r.isValidLookup(i)){var t=r.extractFromKey(e,n),c=t.key;o=c;var l=t.namespaces;r.options.fallbackNS&&(l=l.concat(r.options.fallbackNS));var f=void 0!==n.count&&"string"!=typeof n.count,d=void 0!==n.context&&"string"==typeof n.context&&""!==n.context,h=n.lngs?n.lngs:r.languageUtils.toResolveHierarchy(n.lng||r.language,n.fallbackLng);l.forEach((function(e){r.isValidLookup(i)||(u=e,!P["".concat(h[0],"-").concat(e)]&&r.utils&&r.utils.hasLoadedNamespace&&!r.utils.hasLoadedNamespace(u)&&(P["".concat(h[0],"-").concat(e)]=!0,r.logger.warn('key "'.concat(o,'" for languages "').concat(h.join(", "),'" won\'t get resolved as namespace "').concat(u,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!")),h.forEach((function(t){if(!r.isValidLookup(i)){s=t;var o=c,u=[o],l,h;if(r.i18nFormat&&r.i18nFormat.addLookupKeys)r.i18nFormat.addLookupKeys(u,c,t,e,n);else f&&(l=r.pluralResolver.getSuffix(t,n.count)),f&&d&&u.push(o+l),d&&u.push(o+="".concat(r.options.contextSeparator).concat(n.context)),f&&u.push(o+=l);for(;h=u.pop();)r.isValidLookup(i)||(a=h,i=r.getResource(t,e,h,n))}})))}))}})),{res:i,usedKey:o,exactUsedKey:a,usedLng:s,usedNS:u}}},{key:"isValidLookup",value:function e(t){return!(void 0===t||!this.options.returnNull&&null===t||!this.options.returnEmptyString&&""===t)}},{key:"getResource",value:function e(t,r,n){var i=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return this.i18nFormat&&this.i18nFormat.getResource?this.i18nFormat.getResource(t,r,n,i):this.resourceStore.getResource(t,r,n,i)}}],[{key:"hasDefaultValue",value:function e(t){var r="defaultValue";for(var n in t)if(Object.prototype.hasOwnProperty.call(t,n)&&r===n.substring(0,r.length)&&void 0!==t[n])return!0;return!1}}]),t}(k);function z(e){return e.charAt(0).toUpperCase()+e.slice(1)}var U=function(){function e(t){p.default(this,e),this.options=t,this.whitelist=this.options.supportedLngs||!1,this.supportedLngs=this.options.supportedLngs||!1,this.logger=x.create("languageUtils")}return b.default(e,[{key:"getScriptPartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return null;var r=t.split("-");return 2===r.length?null:(r.pop(),"x"===r[r.length-1].toLowerCase()?null:this.formatLanguageCode(r.join("-")))}},{key:"getLanguagePartFromCode",value:function e(t){if(!t||t.indexOf("-")<0)return t;var r=t.split("-");return this.formatLanguageCode(r[0])}},{key:"formatLanguageCode",value:function e(t){if("string"==typeof t&&t.indexOf("-")>-1){var r=["hans","hant","latn","cyrl","cans","mong","arab"],n=t.split("-");return this.options.lowerCaseLng?n=n.map((function(e){return e.toLowerCase()})):2===n.length?(n[0]=n[0].toLowerCase(),n[1]=n[1].toUpperCase(),r.indexOf(n[1].toLowerCase())>-1&&(n[1]=z(n[1].toLowerCase()))):3===n.length&&(n[0]=n[0].toLowerCase(),2===n[1].length&&(n[1]=n[1].toUpperCase()),"sgn"!==n[0]&&2===n[2].length&&(n[2]=n[2].toUpperCase()),r.indexOf(n[1].toLowerCase())>-1&&(n[1]=z(n[1].toLowerCase())),r.indexOf(n[2].toLowerCase())>-1&&(n[2]=z(n[2].toLowerCase()))),n.join("-")}return this.options.cleanCode||this.options.lowerCaseLng?t.toLowerCase():t}},{key:"isWhitelisted",value:function e(t){return this.logger.deprecate("languageUtils.isWhitelisted",'function "isWhitelisted" will be renamed to "isSupportedCode" in the next major - please make sure to rename it\'s usage asap.'),this.isSupportedCode(t)}},{key:"isSupportedCode",value:function e(t){return("languageOnly"===this.options.load||this.options.nonExplicitSupportedLngs)&&(t=this.getLanguagePartFromCode(t)),!this.supportedLngs||!this.supportedLngs.length||this.supportedLngs.indexOf(t)>-1}},{key:"getBestMatchFromCodes",value:function e(t){var r=this,n;return t?(t.forEach((function(e){if(!n){var t=r.formatLanguageCode(e);r.options.supportedLngs&&!r.isSupportedCode(t)||(n=t)}})),!n&&this.options.supportedLngs&&t.forEach((function(e){if(!n){var t=r.getLanguagePartFromCode(e);if(r.isSupportedCode(t))return n=t;n=r.options.supportedLngs.find((function(e){if(0===e.indexOf(t))return e}))}})),n||(n=this.getFallbackCodes(this.options.fallbackLng)[0]),n):null}},{key:"getFallbackCodes",value:function e(t,r){if(!t)return[];if("function"==typeof t&&(t=t(r)),"string"==typeof t&&(t=[t]),"[object Array]"===Object.prototype.toString.apply(t))return t;if(!r)return t.default||[];var n=t[r];return n||(n=t[this.getScriptPartFromCode(r)]),n||(n=t[this.formatLanguageCode(r)]),n||(n=t[this.getLanguagePartFromCode(r)]),n||(n=t.default),n||[]}},{key:"toResolveHierarchy",value:function e(t,r){var n=this,i=this.getFallbackCodes(r||this.options.fallbackLng||[],t),o=[],a=function e(t){t&&(n.isSupportedCode(t)?o.push(t):n.logger.warn("rejecting language code not found in supportedLngs: ".concat(t)))};return"string"==typeof t&&t.indexOf("-")>-1?("languageOnly"!==this.options.load&&a(this.formatLanguageCode(t)),"languageOnly"!==this.options.load&&"currentOnly"!==this.options.load&&a(this.getScriptPartFromCode(t)),"currentOnly"!==this.options.load&&a(this.getLanguagePartFromCode(t))):"string"==typeof t&&a(this.formatLanguageCode(t)),i.forEach((function(e){o.indexOf(e)<0&&a(n.formatLanguageCode(e))})),o}}]),e}(),$=[{lngs:["ach","ak","am","arn","br","fil","gun","ln","mfe","mg","mi","oc","pt","pt-BR","tg","tl","ti","tr","uz","wa"],nr:[1,2],fc:1},{lngs:["af","an","ast","az","bg","bn","ca","da","de","dev","el","en","eo","es","et","eu","fi","fo","fur","fy","gl","gu","ha","hi","hu","hy","ia","it","kn","ku","lb","mai","ml","mn","mr","nah","nap","nb","ne","nl","nn","no","nso","pa","pap","pms","ps","pt-PT","rm","sco","se","si","so","son","sq","sv","sw","ta","te","tk","ur","yo"],nr:[1,2],fc:2},{lngs:["ay","bo","cgg","fa","ht","id","ja","jbo","ka","kk","km","ko","ky","lo","ms","sah","su","th","tt","ug","vi","wo","zh"],nr:[1],fc:3},{lngs:["be","bs","cnr","dz","hr","ru","sr","uk"],nr:[1,2,5],fc:4},{lngs:["ar"],nr:[0,1,2,3,11,100],fc:5},{lngs:["cs","sk"],nr:[1,2,5],fc:6},{lngs:["csb","pl"],nr:[1,2,5],fc:7},{lngs:["cy"],nr:[1,2,3,8],fc:8},{lngs:["fr"],nr:[1,2],fc:9},{lngs:["ga"],nr:[1,2,3,7,11],fc:10},{lngs:["gd"],nr:[1,2,3,20],fc:11},{lngs:["is"],nr:[1,2],fc:12},{lngs:["jv"],nr:[0,1],fc:13},{lngs:["kw"],nr:[1,2,3,4],fc:14},{lngs:["lt"],nr:[1,2,10],fc:15},{lngs:["lv"],nr:[1,2,0],fc:16},{lngs:["mk"],nr:[1,2],fc:17},{lngs:["mnk"],nr:[0,1,2],fc:18},{lngs:["mt"],nr:[1,2,11,20],fc:19},{lngs:["or"],nr:[2,1],fc:2},{lngs:["ro"],nr:[1,2,20],fc:20},{lngs:["sl"],nr:[5,1,2,3],fc:21},{lngs:["he","iw"],nr:[1,2,20,21],fc:22}],H={1:function e(t){return Number(t>1)},2:function e(t){return Number(1!=t)},3:function e(t){return 0},4:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},5:function e(t){return Number(0==t?0:1==t?1:2==t?2:t%100>=3&&t%100<=10?3:t%100>=11?4:5)},6:function e(t){return Number(1==t?0:t>=2&&t<=4?1:2)},7:function e(t){return Number(1==t?0:t%10>=2&&t%10<=4&&(t%100<10||t%100>=20)?1:2)},8:function e(t){return Number(1==t?0:2==t?1:8!=t&&11!=t?2:3)},9:function e(t){return Number(t>=2)},10:function e(t){return Number(1==t?0:2==t?1:t<7?2:t<11?3:4)},11:function e(t){return Number(1==t||11==t?0:2==t||12==t?1:t>2&&t<20?2:3)},12:function e(t){return Number(t%10!=1||t%100==11)},13:function e(t){return Number(0!==t)},14:function e(t){return Number(1==t?0:2==t?1:3==t?2:3)},15:function e(t){return Number(t%10==1&&t%100!=11?0:t%10>=2&&(t%100<10||t%100>=20)?1:2)},16:function e(t){return Number(t%10==1&&t%100!=11?0:0!==t?1:2)},17:function e(t){return Number(1==t||t%10==1&&t%100!=11?0:1)},18:function e(t){return Number(0==t?0:1==t?1:2)},19:function e(t){return Number(1==t?0:0==t||t%100>1&&t%100<11?1:t%100>10&&t%100<20?2:3)},20:function e(t){return Number(1==t?0:0==t||t%100>0&&t%100<20?1:2)},21:function e(t){return Number(t%100==1?1:t%100==2?2:t%100==3||t%100==4?3:0)},22:function e(t){return Number(1==t?0:2==t?1:(t<0||t>10)&&t%10==0?2:3)}};function W(){var e={};return $.forEach((function(t){t.lngs.forEach((function(r){e[r]={numbers:t.nr,plurals:H[t.fc]}}))})),e}var Y=function(){function e(t){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{};p.default(this,e),this.languageUtils=t,this.options=r,this.logger=x.create("pluralResolver"),this.rules=W()}return b.default(e,[{key:"addRule",value:function e(t,r){this.rules[t]=r}},{key:"getRule",value:function e(t){return this.rules[t]||this.rules[this.languageUtils.getLanguagePartFromCode(t)]}},{key:"needsPlural",value:function e(t){var r=this.getRule(t);return r&&r.numbers.length>1}},{key:"getPluralFormsOfKey",value:function e(t,r){return this.getSuffixes(t).map((function(e){return r+e}))}},{key:"getSuffixes",value:function e(t){var r=this,n=this.getRule(t);return n?n.numbers.map((function(e){return r.getSuffix(t,e)})):[]}},{key:"getSuffix",value:function e(t,r){var n=this,i=this.getRule(t);if(i){var o=i.noAbs?i.plurals(r):i.plurals(Math.abs(r)),a=i.numbers[o];this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]&&(2===a?a="plural":1===a&&(a=""));var s=function e(){return n.options.prepend&&a.toString()?n.options.prepend+a.toString():a.toString()};return"v1"===this.options.compatibilityJSON?1===a?"":"number"==typeof a?"_plural_".concat(a.toString()):s():"v2"===this.options.compatibilityJSON?s():this.options.simplifyPluralSuffix&&2===i.numbers.length&&1===i.numbers[0]?s():this.options.prepend&&o.toString()?this.options.prepend+o.toString():o.toString()}return this.logger.warn("no plural rule found for: ".concat(t)),""}}]),e}(),V=function(){function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};p.default(this,e),this.logger=x.create("interpolator"),this.options=t,this.format=t.interpolation&&t.interpolation.format||function(e){return e},this.init(t)}return b.default(e,[{key:"init",value:function e(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};t.interpolation||(t.interpolation={escapeValue:!0});var r=t.interpolation;this.escape=void 0!==r.escape?r.escape:R,this.escapeValue=void 0===r.escapeValue||r.escapeValue,this.useRawValueToEscape=void 0!==r.useRawValueToEscape&&r.useRawValueToEscape,this.prefix=r.prefix?B(r.prefix):r.prefixEscaped||"{{",this.suffix=r.suffix?B(r.suffix):r.suffixEscaped||"}}",this.formatSeparator=r.formatSeparator?r.formatSeparator:r.formatSeparator||",",this.unescapePrefix=r.unescapeSuffix?"":r.unescapePrefix||"-",this.unescapeSuffix=this.unescapePrefix?"":r.unescapeSuffix||"",this.nestingPrefix=r.nestingPrefix?B(r.nestingPrefix):r.nestingPrefixEscaped||B("$t("),this.nestingSuffix=r.nestingSuffix?B(r.nestingSuffix):r.nestingSuffixEscaped||B(")"),this.nestingOptionsSeparator=r.nestingOptionsSeparator?r.nestingOptionsSeparator:r.nestingOptionsSeparator||",",this.maxReplaces=r.maxReplaces?r.maxReplaces:1e3,this.alwaysFormat=void 0!==r.alwaysFormat&&r.alwaysFormat,this.resetRegExp()}},{key:"reset",value:function e(){this.options&&this.init(this.options)}},{key:"resetRegExp",value:function e(){var t="".concat(this.prefix,"(.+?)").concat(this.suffix);this.regexp=new RegExp(t,"g");var r="".concat(this.prefix).concat(this.unescapePrefix,"(.+?)").concat(this.unescapeSuffix).concat(this.suffix);this.regexpUnescape=new RegExp(r,"g");var n="".concat(this.nestingPrefix,"(.+?)").concat(this.nestingSuffix);this.nestingRegexp=new RegExp(n,"g")}},{key:"interpolate",value:function e(t,r,n,i){var o=this,a,s,u,c=this.options&&this.options.interpolation&&this.options.interpolation.defaultVariables||{};function l(e){return e.replace(/\$/g,"$$$$")}var f=function e(t){if(t.indexOf(o.formatSeparator)<0){var a=T(r,c,t);return o.alwaysFormat?o.format(a,void 0,n):a}var s=t.split(o.formatSeparator),u=s.shift().trim(),l=s.join(o.formatSeparator).trim();return o.format(T(r,c,u),l,n,i)};this.resetRegExp();var d=i&&i.missingInterpolationHandler||this.options.missingInterpolationHandler,h=i&&i.interpolation&&i.interpolation.skipOnVariables||this.options.interpolation.skipOnVariables,p;return[{regex:this.regexpUnescape,safeValue:function e(t){return l(t)}},{regex:this.regexp,safeValue:function e(t){return o.escapeValue?l(o.escape(t)):l(t)}}].forEach((function(e){for(u=0;a=e.regex.exec(t);){if(void 0===(s=f(a[1].trim())))if("function"==typeof d){var r=d(t,a,i);s="string"==typeof r?r:""}else{if(h){s=a[0];continue}o.logger.warn("missed to pass in variable ".concat(a[1]," for interpolating ").concat(t)),s=""}else"string"==typeof s||o.useRawValueToEscape||(s=j(s));if(t=t.replace(a[0],e.safeValue(s)),e.regex.lastIndex=0,++u>=o.maxReplaces)break}})),t}},{key:"nest",value:function e(t,r){var n=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o,a,s=h.default({},i);function u(e,t){var r=this.nestingOptionsSeparator;if(e.indexOf(r)<0)return e;var n=e.split(new RegExp("".concat(r,"[ ]*{"))),i="{".concat(n[1]);e=n[0],i=(i=this.interpolate(i,s)).replace(/'/g,'"');try{s=JSON.parse(i),t&&(s=h.default({},t,s))}catch(o){return this.logger.warn("failed parsing options string in nesting for key ".concat(e),o),"".concat(e).concat(r).concat(i)}return delete s.defaultValue,e}for(s.applyPostProcessor=!1,delete s.defaultValue;o=this.nestingRegexp.exec(t);){var c=[],l=!1;if(o[0].includes(this.formatSeparator)&&!/{.*}/.test(o[1])){var f=o[1].split(this.formatSeparator).map((function(e){return e.trim()}));o[1]=f.shift(),c=f,l=!0}if((a=r(u.call(this,o[1].trim(),s),s))&&o[0]===t&&"string"!=typeof a)return a;"string"!=typeof a&&(a=j(a)),a||(this.logger.warn("missed to resolve ".concat(o[1]," for nesting ").concat(t)),a=""),l&&(a=c.reduce((function(e,t){return n.format(e,t,i.lng,i)}),a.trim())),t=t.replace(o[0],a),this.regexp.lastIndex=0}return t}}]),e}();function K(e,t){for(var r=e.indexOf(t);-1!==r;)e.splice(r,1),r=e.indexOf(t)}var G=function(e){function t(e,r,n){var i,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{};return p.default(this,t),i=m.default(this,g.default(t).call(this)),N&&k.call(v.default(i)),i.backend=e,i.store=r,i.services=n,i.languageUtils=n.languageUtils,i.options=o,i.logger=x.create("backendConnector"),i.state={},i.queue=[],i.backend&&i.backend.init&&i.backend.init(n,o.backend,o),i}return y.default(t,e),b.default(t,[{key:"queueLoad",value:function e(t,r,n,i){var o=this,a=[],s=[],u=[],c=[];return t.forEach((function(e){var t=!0;r.forEach((function(r){var i="".concat(e,"|").concat(r);!n.reload&&o.store.hasResourceBundle(e,r)?o.state[i]=2:o.state[i]<0||(1===o.state[i]?s.indexOf(i)<0&&s.push(i):(o.state[i]=1,t=!1,s.indexOf(i)<0&&s.push(i),a.indexOf(i)<0&&a.push(i),c.indexOf(r)<0&&c.push(r)))})),t||u.push(e)})),(a.length||s.length)&&this.queue.push({pending:s,loaded:{},errors:[],callback:i}),{toLoad:a,pending:s,toLoadLanguages:u,toLoadNamespaces:c}}},{key:"loaded",value:function e(t,r,n){var i=t.split("|"),o=i[0],a=i[1];r&&this.emit("failedLoading",o,a,r),n&&this.store.addResourceBundle(o,a,n),this.state[t]=r?-1:2;var e={};this.queue.forEach((function(n){O(n.loaded,[o],a),K(n.pending,t),r&&n.errors.push(r),0!==n.pending.length||n.done||(Object.keys(n.loaded).forEach((function(t){e[t]||(e[t]=[]),n.loaded[t].length&&n.loaded[t].forEach((function(r){e[t].indexOf(r)<0&&e[t].push(r)}))})),n.done=!0,n.errors.length?n.callback(n.errors):n.callback())})),this.emit("loaded",e),this.queue=this.queue.filter((function(e){return!e.done}))}},{key:"read",value:function e(t,r,n){var i=this,o=arguments.length>3&&void 0!==arguments[3]?arguments[3]:0,a=arguments.length>4&&void 0!==arguments[4]?arguments[4]:350,s=arguments.length>5?arguments[5]:void 0;return t.length?this.backend[n](t,r,(function(e,u){e&&u&&o<5?setTimeout((function(){i.read.call(i,t,r,n,o+1,2*a,s)}),a):s(e,u)})):s(null,{})}},{key:"prepareLoading",value:function e(t,r){var n=this,i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},o=arguments.length>3?arguments[3]:void 0;if(!this.backend)return this.logger.warn("No backend was added via i18next.use. Will not load resources."),o&&o();"string"==typeof t&&(t=this.languageUtils.toResolveHierarchy(t)),"string"==typeof r&&(r=[r]);var a=this.queueLoad(t,r,i,o);if(!a.toLoad.length)return a.pending.length||o(),null;a.toLoad.forEach((function(e){n.loadOne(e)}))}},{key:"load",value:function e(t,r,n){this.prepareLoading(t,r,{},n)}},{key:"reload",value:function e(t,r,n){this.prepareLoading(t,r,{reload:!0},n)}},{key:"loadOne",value:function e(t){var r=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=t.split("|"),o=i[0],a=i[1];this.read(o,a,"read",void 0,void 0,(function(e,i){e&&r.logger.warn("".concat(n,"loading namespace ").concat(a," for language ").concat(o," failed"),e),!e&&i&&r.logger.log("".concat(n,"loaded namespace ").concat(a," for language ").concat(o),i),r.loaded(t,e,i)}))}},{key:"saveMissing",value:function e(t,r,n,i,o){var a=arguments.length>5&&void 0!==arguments[5]?arguments[5]:{};this.services.utils&&this.services.utils.hasLoadedNamespace&&!this.services.utils.hasLoadedNamespace(r)?this.logger.warn('did not save key "'.concat(n,'" as the namespace "').concat(r,'" was not yet loaded'),"This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!"):null!=n&&""!==n&&(this.backend&&this.backend.create&&this.backend.create(t,r,n,i,null,h.default({},a,{isUpdate:o})),t&&t[0]&&this.store.addResource(t[0],r,n,i))}}]),t}(k);function X(){return{debug:!1,initImmediate:!0,ns:["translation"],defaultNS:["translation"],fallbackLng:["dev"],fallbackNS:!1,whitelist:!1,nonExplicitWhitelist:!1,supportedLngs:!1,nonExplicitSupportedLngs:!1,load:"all",preload:!1,simplifyPluralSuffix:!0,keySeparator:".",nsSeparator:":",pluralSeparator:"_",contextSeparator:"_",partialBundledLanguages:!1,saveMissing:!1,updateMissing:!1,saveMissingTo:"fallback",saveMissingPlurals:!0,missingKeyHandler:!1,missingInterpolationHandler:!1,postProcess:!1,postProcessPassResolved:!1,returnNull:!0,returnEmptyString:!0,returnObjects:!1,joinArrays:!1,returnedObjectHandler:!1,parseMissingKeyHandler:!1,appendNamespaceToMissingKey:!1,appendNamespaceToCIMode:!1,overloadTranslationOptionHandler:function e(t){var r={};if("object"===d.default(t[1])&&(r=t[1]),"string"==typeof t[1]&&(r.defaultValue=t[1]),"string"==typeof t[2]&&(r.tDescription=t[2]),"object"===d.default(t[2])||"object"===d.default(t[3])){var n=t[3]||t[2];Object.keys(n).forEach((function(e){r[e]=n[e]}))}return r},interpolation:{escapeValue:!0,format:function e(t,r,n,i){return t},prefix:"{{",suffix:"}}",formatSeparator:",",unescapePrefix:"-",nestingPrefix:"$t(",nestingSuffix:")",nestingOptionsSeparator:",",maxReplaces:1e3,skipOnVariables:!1}}}function Z(e){return"string"==typeof e.ns&&(e.ns=[e.ns]),"string"==typeof e.fallbackLng&&(e.fallbackLng=[e.fallbackLng]),"string"==typeof e.fallbackNS&&(e.fallbackNS=[e.fallbackNS]),e.whitelist&&(e.whitelist&&e.whitelist.indexOf("cimode")<0&&(e.whitelist=e.whitelist.concat(["cimode"])),e.supportedLngs=e.whitelist),e.nonExplicitWhitelist&&(e.nonExplicitSupportedLngs=e.nonExplicitWhitelist),e.supportedLngs&&e.supportedLngs.indexOf("cimode")<0&&(e.supportedLngs=e.supportedLngs.concat(["cimode"])),e}function J(){}var Q,ee=new(function(e){function t(){var e,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;if(p.default(this,t),e=m.default(this,g.default(t).call(this)),N&&k.call(v.default(e)),e.options=Z(r),e.services={},e.logger=x,e.modules={external:[]},n&&!e.isInitialized&&!r.isClone){if(!e.options.initImmediate)return e.init(r,n),m.default(e,v.default(e));setTimeout((function(){e.init(r,n)}),0)}return e}return y.default(t,e),b.default(t,[{key:"init",value:function e(){var t=this,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;function i(e){return e?"function"==typeof e?new e:e:null}if("function"==typeof r&&(n=r,r={}),r.whitelist&&!r.supportedLngs&&this.logger.deprecate("whitelist",'option "whitelist" will be renamed to "supportedLngs" in the next major - please make sure to rename this option asap.'),r.nonExplicitWhitelist&&!r.nonExplicitSupportedLngs&&this.logger.deprecate("whitelist",'options "nonExplicitWhitelist" will be renamed to "nonExplicitSupportedLngs" in the next major - please make sure to rename this option asap.'),this.options=h.default({},X(),this.options,Z(r)),this.format=this.options.interpolation.format,n||(n=J),!this.options.isClone){this.modules.logger?x.init(i(this.modules.logger),this.options):x.init(null,this.options);var o=new U(this.options);this.store=new F(this.options.resources,this.options);var a=this.services;a.logger=x,a.resourceStore=this.store,a.languageUtils=o,a.pluralResolver=new Y(o,{prepend:this.options.pluralSeparator,compatibilityJSON:this.options.compatibilityJSON,simplifyPluralSuffix:this.options.simplifyPluralSuffix}),a.interpolator=new V(this.options),a.utils={hasLoadedNamespace:this.hasLoadedNamespace.bind(this)},a.backendConnector=new G(i(this.modules.backend),a.resourceStore,a,this.options),a.backendConnector.on("*",(function(e){for(var r=arguments.length,n=new Array(r>1?r-1:0),i=1;i1?r-1:0),i=1;i0&&"dev"!==s[0]&&(this.options.lng=s[0])}this.services.languageDetector||this.options.lng||this.logger.warn("init: no languageDetector is used and no lng is defined");var u=["getResource","hasResourceBundle","getResourceBundle","getDataByLanguage"];u.forEach((function(e){t[e]=function(){var r;return(r=t.store)[e].apply(r,arguments)}}));var c=["addResource","addResources","addResourceBundle","removeResourceBundle"];c.forEach((function(e){t[e]=function(){var r;return(r=t.store)[e].apply(r,arguments),t}}));var l=S(),f=function e(){var r=function e(r,i){t.isInitialized&&t.logger.warn("init: i18next is already initialized. You should call init just once!"),t.isInitialized=!0,t.options.isClone||t.logger.log("initialized",t.options),t.emit("initialized",t.options),l.resolve(i),n(r,i)};if(t.languages&&"v1"!==t.options.compatibilityAPI&&!t.isInitialized)return r(null,t.t.bind(t));t.changeLanguage(t.options.lng,r)};return this.options.resources||!this.options.initImmediate?f():setTimeout(f,0),l}},{key:"loadResources",value:function e(t){var r=this,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:J,i=n,o="string"==typeof t?t:this.language;if("function"==typeof t&&(i=t),!this.options.resources||this.options.partialBundledLanguages){if(o&&"cimode"===o.toLowerCase())return i();var a=[],s=function e(t){var n;t&&r.services.languageUtils.toResolveHierarchy(t).forEach((function(e){a.indexOf(e)<0&&a.push(e)}))};if(o)s(o);else{var u=this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);u.forEach((function(e){return s(e)}))}this.options.preload&&this.options.preload.forEach((function(e){return s(e)})),this.services.backendConnector.load(a,this.options.ns,i)}else i(null)}},{key:"reloadResources",value:function e(t,r,n){var i=S();return t||(t=this.languages),r||(r=this.options.ns),n||(n=J),this.services.backendConnector.reload(t,r,(function(e){i.resolve(),n(e)})),i}},{key:"use",value:function e(t){if(!t)throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");if(!t.type)throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");return"backend"===t.type&&(this.modules.backend=t),("logger"===t.type||t.log&&t.warn&&t.error)&&(this.modules.logger=t),"languageDetector"===t.type&&(this.modules.languageDetector=t),"i18nFormat"===t.type&&(this.modules.i18nFormat=t),"postProcessor"===t.type&&L.addPostProcessor(t),"3rdParty"===t.type&&this.modules.external.push(t),this}},{key:"changeLanguage",value:function e(t,r){var n=this;this.isLanguageChangingTo=t;var i=S();this.emit("languageChanging",t);var o=function e(t,o){o?(n.language=o,n.languages=n.services.languageUtils.toResolveHierarchy(o),n.translator.changeLanguage(o),n.isLanguageChangingTo=void 0,n.emit("languageChanged",o),n.logger.log("languageChanged",o)):n.isLanguageChangingTo=void 0,i.resolve((function(){return n.t.apply(n,arguments)})),r&&r(t,(function(){return n.t.apply(n,arguments)}))},a=function e(t){var r="string"==typeof t?t:n.services.languageUtils.getBestMatchFromCodes(t);r&&(n.language||(n.language=r,n.languages=n.services.languageUtils.toResolveHierarchy(r)),n.translator.language||n.translator.changeLanguage(r),n.services.languageDetector&&n.services.languageDetector.cacheUserLanguage(r)),n.loadResources(r,(function(e){o(e,r)}))};return t||!this.services.languageDetector||this.services.languageDetector.async?!t&&this.services.languageDetector&&this.services.languageDetector.async?this.services.languageDetector.detect(a):a(t):a(this.services.languageDetector.detect()),i}},{key:"getFixedT",value:function e(t,r){var n=this,i=function e(t,r){var i;if("object"!==d.default(r)){for(var o=arguments.length,a=new Array(o>2?o-2:0),s=2;s1&&void 0!==arguments[1]?arguments[1]:{};if(!this.isInitialized)return this.logger.warn("hasLoadedNamespace: i18next was not initialized",this.languages),!1;if(!this.languages||!this.languages.length)return this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty",this.languages),!1;var i=this.languages[0],o=!!this.options&&this.options.fallbackLng,a=this.languages[this.languages.length-1];if("cimode"===i.toLowerCase())return!0;var s=function e(t,n){var i=r.services.backendConnector.state["".concat(t,"|").concat(n)];return-1===i||2===i};if(n.precheck){var u=n.precheck(this,s);if(void 0!==u)return u}return!!this.hasResourceBundle(i,t)||(!this.services.backendConnector.backend||!(!s(i,t)||o&&!s(a,t)))}},{key:"loadNamespaces",value:function e(t,r){var n=this,i=S();return this.options.ns?("string"==typeof t&&(t=[t]),t.forEach((function(e){n.options.ns.indexOf(e)<0&&n.options.ns.push(e)})),this.loadResources((function(e){i.resolve(),r&&r(e)})),i):(r&&r(),Promise.resolve())}},{key:"loadLanguages",value:function e(t,r){var n=S();"string"==typeof t&&(t=[t]);var i=this.options.preload||[],o=t.filter((function(e){return i.indexOf(e)<0}));return o.length?(this.options.preload=i.concat(o),this.loadResources((function(e){n.resolve(),r&&r(e)})),n):(r&&r(),Promise.resolve())}},{key:"dir",value:function e(t){return t||(t=this.languages&&this.languages.length>0?this.languages[0]:this.language),t?["ar","shu","sqr","ssh","xaa","yhd","yud","aao","abh","abv","acm","acq","acw","acx","acy","adf","ads","aeb","aec","afb","ajp","apc","apd","arb","arq","ars","ary","arz","auz","avl","ayh","ayl","ayn","ayp","bbz","pga","he","iw","ps","pbt","pbu","pst","prp","prd","ug","ur","ydd","yds","yih","ji","yi","hbo","men","xmn","fa","jpr","peo","pes","prs","dv","sam"].indexOf(this.services.languageUtils.getLanguagePartFromCode(t))>=0?"rtl":"ltr":"rtl";var r}},{key:"createInstance",value:function e(){var r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},n=arguments.length>1?arguments[1]:void 0;return new t(r,n)}},{key:"cloneInstance",value:function e(){var r=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},i=arguments.length>1&&void 0!==arguments[1]?arguments[1]:J,o=h.default({},this.options,n,{isClone:!0}),a=new t(o),s=["store","services","language"];return s.forEach((function(e){a[e]=r[e]})),a.services=h.default({},this.services),a.services.utils={hasLoadedNamespace:a.hasLoadedNamespace.bind(a)},a.translator=new q(a.services,a.options),a.translator.on("*",(function(e){for(var t=arguments.length,r=new Array(t>1?t-1:0),n=1;n=0&&r<=y}}function Z(e){return function(t){return null==t?void 0:t[e]}}var J=Z("byteLength"),Q=X(J),ee=/\[object ((I|Ui)nt(8|16|32)|Float(32|64)|Uint8Clamped|Big(I|Ui)nt64)Array\]/;function te(e){return p?p(e)&&!U(e):Q(e)&&ee.test(s.call(e))}var re=c?te:G(!1),ne=Z("length");function ie(e){for(var t={},r=e.length,n=0;n":">",'"':""","'":"'","`":"`"},st=ot(at),ut,ct=ot(Ce(at)),lt=ce.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g},ft=/(.)^/,dt={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},ht=/\\|'|\r|\n|\u2028|\u2029/g;function pt(e){return"\\"+dt[e]}var bt=/^\s*(\w|\$)+\s*$/;function mt(e,t,r){!t&&r&&(t=r),t=Re({},t,ce.templateSettings);var n=RegExp([(t.escape||ft).source,(t.interpolate||ft).source,(t.evaluate||ft).source].join("|")+"|$","g"),i=0,o="__p+='";e.replace(n,(function(t,r,n,a,s){return o+=e.slice(i,s).replace(ht,pt),i=s+t.length,r?o+="'+\n((__t=("+r+"))==null?'':_.escape(__t))+\n'":n?o+="'+\n((__t=("+n+"))==null?'':__t)+\n'":a&&(o+="';\n"+a+"\n__p+='"),t})),o+="';\n";var a=t.variable,s;if(a){if(!bt.test(a))throw new Error("variable is not a bare identifier: "+a)}else o="with(obj||{}){\n"+o+"}\n",a="obj";o="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+o+"return __p;\n";try{s=new Function(a,"_",o)}catch(c){throw c.source=o,c}var u=function(e){return s.call(this,e,ce)};return u.source="function("+a+"){\n"+o+"}",u}function gt(e,t,r){var n=(t=Ue(t)).length;if(!n)return N(r)?r.call(e):r;for(var i=0;i1)jt(s,t-1,r,n),i=n.length;else for(var u=0,c=s.length;ut?(n&&(clearTimeout(n),n=null),s=c,a=e.apply(i,o),n||(i=o=null)):n||!1===r.trailing||(n=setTimeout(u,l)),a};return c.cancel=function(){clearTimeout(n),s=0,n=i=o=null},c}function Tt(e,t,r){var n,i,o,a,s,u=function(){var c=it()-i;t>c?n=setTimeout(u,t-c):(n=null,r||(a=e.apply(s,o)),n||(o=s=null))},c=w((function(c){return s=this,o=c,i=it(),n||(n=setTimeout(u,t),r&&(a=e.apply(s,o))),a}));return c.cancel=function(){clearTimeout(n),n=o=s=null},c}function Mt(e,t){return xt(t,e)}function Bt(e){return function(){return!e.apply(this,arguments)}}function It(){var e=arguments,t=e.length-1;return function(){for(var r=t,n=e[t].apply(this,arguments);r--;)n=e[r].call(this,n);return n}}function Rt(e,t){return function(){if(--e<1)return t.apply(this,arguments)}}function Nt(e,t){var r;return function(){return--e>0&&(r=t.apply(this,arguments)),e<=1&&(t=null),r}}var Ft=xt(Nt,2);function Lt(e,t,r){t=Je(t,r);for(var n=ae(e),i,o=0,a=n.length;o0?0:i-1;o>=0&&o0?s=o>=0?o:Math.max(o+u,s):u=o>=0?Math.min(o+1,u):o+u+1;else if(r&&o&&u)return n[o=r(n,i)]===i?o:-1;if(i!=i)return(o=t(a.call(n,s,u),K))>=0?o+s:-1;for(o=e>0?s:u-1;o>=0&&o0?0:a-1;for(i||(n=t[o?o[s]:s],s+=e);s>=0&&s=3;return t(e,Ge(r,i,4),n,o)}}var Zt=Xt(1),Jt=Xt(-1);function Qt(e,t,r){var n=[];return t=Je(t,r),Kt(e,(function(e,r,i){t(e,r,i)&&n.push(e)})),n}function er(e,t,r){return Qt(e,Bt(Je(t)),r)}function tr(e,t,r){t=Je(t,r);for(var n=!St(e)&&ae(e),i=(n||e).length,o=0;o=0}var ir=w((function(e,t,r){var n,i;return N(t)?i=t:(t=Ue(t),n=t.slice(0,-1),t=t[t.length-1]),Gt(e,(function(e){var o=i;if(!o){if(n&&n.length&&(e=$e(e,n)),null==e)return;o=e[t]}return null==o?o:o.apply(e,r)}))}));function or(e,t){return Gt(e,Ke(t))}function ar(e,t){return Qt(e,Ve(t))}function sr(e,t,r){var n=-1/0,i=-1/0,o,a;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var s=0,u=(e=St(e)?e:Ee(e)).length;sn&&(n=o);else t=Je(t,r),Kt(e,(function(e,r,o){((a=t(e,r,o))>i||a===-1/0&&n===-1/0)&&(n=e,i=a)}));return n}function ur(e,t,r){var n=1/0,i=1/0,o,a;if(null==t||"number"==typeof t&&"object"!=typeof e[0]&&null!=e)for(var s=0,u=(e=St(e)?e:Ee(e)).length;sn||void 0===r)return 1;if(r1&&(n=Ge(n,t[1])),t=be(e)):(n=wr,t=jt(t,!1,!1),e=Object(e));for(var i=0,o=t.length;i1&&(n=t[1])):(t=Gt(jt(t,!1,!1),String),r=function(e,r){return!nr(t,r)}),_r(e,r,n)}));function kr(e,t,r){return a.call(e,0,Math.max(0,e.length-(null==t||r?1:t)))}function Sr(e,t,r){return null==e||e.length<1?null==t||r?void 0:[]:null==t||r?e[0]:kr(e,e.length-t)}function jr(e,t,r){return a.call(e,null==t||r?1:t)}function Ar(e,t,r){return null==e||e.length<1?null==t||r?void 0:[]:null==t||r?e[e.length-1]:jr(e,Math.max(0,e.length-t))}function Dr(e){return Qt(e,Boolean)}function Er(e,t){return jt(e,t,!1)}var Or=w((function(e,t){return t=jt(t,!0,!0),Qt(e,(function(e){return!nr(t,e)}))})),Cr=w((function(e,t){return Or(e,t)}));function Tr(e,t,r,n){S(t)||(n=r,r=t,t=!1),null!=r&&(r=Je(r,n));for(var i=[],o=[],a=0,s=ne(e);ae(t),this)}}onabort(){}addEventListener(e,t){"abort"===e&&this._listeners.push(t)}removeEventListener(e,t){"abort"===e&&(this._listeners=this._listeners.filter(e=>e!==t))}},c=new Set,l=(e,t)=>{const r=`LRU_CACHE_OPTION_${e}`;p(r)&&b(r,`${e} option`,`options.${t}`,w)},f=(e,t)=>{const r=`LRU_CACHE_METHOD_${e}`;if(p(r)){const{prototype:n}=w,{get:i}=Object.getOwnPropertyDescriptor(n,e);b(r,`${e} method`,`cache.${t}()`,i)}},d=(e,t)=>{const r=`LRU_CACHE_PROPERTY_${e}`;if(p(r)){const{prototype:n}=w,{get:i}=Object.getOwnPropertyDescriptor(n,e);b(r,`${e} property`,`cache.${t}`,i)}},h=(...e)=>{"object"==typeof process&&process&&"function"==typeof process.emitWarning?process.emitWarning(...e):console.error(...e)},p=e=>!c.has(e),b=(e,t,r,n)=>{c.add(e);const i=`The ${t} is deprecated. Please use ${r} instead.`;h(i,"DeprecationWarning",e,n)},m=e=>e&&e===Math.floor(e)&&e>0&&isFinite(e),g=e=>m(e)?e<=Math.pow(2,8)?Uint8Array:e<=Math.pow(2,16)?Uint16Array:e<=Math.pow(2,32)?Uint32Array:e<=Number.MAX_SAFE_INTEGER?v:null:null;class v extends Array{constructor(e){super(e),this.fill(0)}}class y{constructor(e){if(0===e)return[];const t=g(e);this.heap=new t(e),this.length=0}push(e){this.heap[this.length++]=e}pop(){return this.heap[--this.length]}}class w{constructor(e={}){const{max:t=0,ttl:r,ttlResolution:n=1,ttlAutopurge:i,updateAgeOnGet:o,updateAgeOnHas:a,allowStale:s,dispose:u,disposeAfter:f,noDisposeOnSet:d,noUpdateTTL:b,maxSize:v=0,maxEntrySize:_=0,sizeCalculation:x,fetchMethod:k,fetchContext:S,noDeleteOnFetchRejection:j,noDeleteOnStaleGet:A}=e,{length:D,maxAge:E,stale:O}=e instanceof w?{}:e;if(0!==t&&!m(t))throw new TypeError("max option must be a nonnegative integer");const C=t?g(t):Array;if(!C)throw new Error("invalid max value: "+t);if(this.max=t,this.maxSize=v,this.maxEntrySize=_||this.maxSize,this.sizeCalculation=x||D,this.sizeCalculation){if(!this.maxSize&&!this.maxEntrySize)throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");if("function"!=typeof this.sizeCalculation)throw new TypeError("sizeCalculation set to non-function")}if(this.fetchMethod=k||null,this.fetchMethod&&"function"!=typeof this.fetchMethod)throw new TypeError("fetchMethod must be a function if specified");if(this.fetchContext=S,!this.fetchMethod&&void 0!==S)throw new TypeError("cannot set fetchContext without fetchMethod");if(this.keyMap=new Map,this.keyList=new Array(t).fill(null),this.valList=new Array(t).fill(null),this.next=new C(t),this.prev=new C(t),this.head=0,this.tail=0,this.free=new y(t),this.initialFill=1,this.size=0,"function"==typeof u&&(this.dispose=u),"function"==typeof f?(this.disposeAfter=f,this.disposed=[]):(this.disposeAfter=null,this.disposed=null),this.noDisposeOnSet=!!d,this.noUpdateTTL=!!b,this.noDeleteOnFetchRejection=!!j,0!==this.maxEntrySize){if(0!==this.maxSize&&!m(this.maxSize))throw new TypeError("maxSize must be a positive integer if specified");if(!m(this.maxEntrySize))throw new TypeError("maxEntrySize must be a positive integer if specified");this.initializeSizeTracking()}if(this.allowStale=!!s||!!O,this.noDeleteOnStaleGet=!!A,this.updateAgeOnGet=!!o,this.updateAgeOnHas=!!a,this.ttlResolution=m(n)||0===n?n:1,this.ttlAutopurge=!!i,this.ttl=r||E||0,this.ttl){if(!m(this.ttl))throw new TypeError("ttl must be a positive integer if specified");this.initializeTTLTracking()}if(0===this.max&&0===this.ttl&&0===this.maxSize)throw new TypeError("At least one of max, maxSize, or ttl is required");if(!this.ttlAutopurge&&!this.max&&!this.maxSize){const e="LRU_CACHE_UNBOUNDED";if(p(e)){c.add(e);const t="TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";h(t,"UnboundedCacheWarning",e,w)}}O&&l("stale","allowStale"),E&&l("maxAge","ttl"),D&&l("length","sizeCalculation")}getRemainingTTL(e){return this.has(e,{updateAgeOnHas:!1})?1/0:0}initializeTTLTracking(){this.ttls=new v(this.max),this.starts=new v(this.max),this.setItemTTL=(e,t,r=n.now())=>{if(this.starts[e]=0!==t?r:0,this.ttls[e]=t,0!==t&&this.ttlAutopurge){const r=setTimeout(()=>{this.isStale(e)&&this.delete(this.keyList[e])},t+1);r.unref&&r.unref()}},this.updateItemAge=e=>{this.starts[e]=0!==this.ttls[e]?n.now():0};let e=0;const t=()=>{const t=n.now();if(this.ttlResolution>0){e=t;const r=setTimeout(()=>e=0,this.ttlResolution);r.unref&&r.unref()}return t};this.getRemainingTTL=r=>{const n=this.keyMap.get(r);return void 0===n?0:0===this.ttls[n]||0===this.starts[n]?1/0:this.starts[n]+this.ttls[n]-(e||t())},this.isStale=r=>0!==this.ttls[r]&&0!==this.starts[r]&&(e||t())-this.starts[r]>this.ttls[r]}updateItemAge(e){}setItemTTL(e,t,r){}isStale(e){return!1}initializeSizeTracking(){this.calculatedSize=0,this.sizes=new v(this.max),this.removeItemSize=e=>{this.calculatedSize-=this.sizes[e],this.sizes[e]=0},this.requireSize=(e,t,r,n)=>{if(this.isBackgroundFetch(t))return 0;if(!m(r)){if(!n)throw new TypeError("invalid size value (must be positive integer)");if("function"!=typeof n)throw new TypeError("sizeCalculation must be a function");if(r=n(t,e),!m(r))throw new TypeError("sizeCalculation return invalid (expect positive integer)")}return r},this.addItemSize=(e,t)=>{if(this.sizes[e]=t,this.maxSize){const t=this.maxSize-this.sizes[e];for(;this.calculatedSize>t;)this.evict(!0)}this.calculatedSize+=this.sizes[e]}}removeItemSize(e){}addItemSize(e,t){}requireSize(e,t,r,n){if(r||n)throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache")}*indexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.tail;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.head);)t=this.prev[t]}*rindexes({allowStale:e=this.allowStale}={}){if(this.size)for(let t=this.head;this.isValidIndex(t)&&(!e&&this.isStale(t)||(yield t),t!==this.tail);)t=this.next[t]}isValidIndex(e){return this.keyMap.get(this.keyList[e])===e}*entries(){for(const e of this.indexes())yield[this.keyList[e],this.valList[e]]}*rentries(){for(const e of this.rindexes())yield[this.keyList[e],this.valList[e]]}*keys(){for(const e of this.indexes())yield this.keyList[e]}*rkeys(){for(const e of this.rindexes())yield this.keyList[e]}*values(){for(const e of this.indexes())yield this.valList[e]}*rvalues(){for(const e of this.rindexes())yield this.valList[e]}[Symbol.iterator](){return this.entries()}find(e,t={}){for(const r of this.indexes())if(e(this.valList[r],this.keyList[r],this))return this.get(this.keyList[r],t)}forEach(e,t=this){for(const r of this.indexes())e.call(t,this.valList[r],this.keyList[r],this)}rforEach(e,t=this){for(const r of this.rindexes())e.call(t,this.valList[r],this.keyList[r],this)}get prune(){return f("prune","purgeStale"),this.purgeStale}purgeStale(){let e=!1;for(const t of this.rindexes({allowStale:!0}))this.isStale(t)&&(this.delete(this.keyList[t]),e=!0);return e}dump(){const e=[];for(const t of this.indexes({allowStale:!0})){const r=this.keyList[t],i=this.valList[t],o=this.isBackgroundFetch(i)?i.__staleWhileFetching:i,a={value:o};if(this.ttls){a.ttl=this.ttls[t];const e=n.now()-this.starts[t];a.start=Math.floor(Date.now()-e)}this.sizes&&(a.size=this.sizes[t]),e.unshift([r,a])}return e}load(e){this.clear();for(const[t,r]of e){if(r.start){const e=Date.now()-r.start;r.start=n.now()-e}this.set(t,r.value,r)}}dispose(e,t,r){}set(e,t,{ttl:r=this.ttl,start:n,noDisposeOnSet:i=this.noDisposeOnSet,size:o=0,sizeCalculation:a=this.sizeCalculation,noUpdateTTL:s=this.noUpdateTTL}={}){if(o=this.requireSize(e,t,o,a),this.maxEntrySize&&o>this.maxEntrySize)return this.delete(e),this;let u=0===this.size?void 0:this.keyMap.get(e);if(void 0===u)u=this.newIndex(),this.keyList[u]=e,this.valList[u]=t,this.keyMap.set(e,u),this.next[this.tail]=u,this.prev[u]=this.tail,this.tail=u,this.size++,this.addItemSize(u,o),s=!1;else{const r=this.valList[u];t!==r&&(this.isBackgroundFetch(r)?r.__abortController.abort():i||(this.dispose(r,e,"set"),this.disposeAfter&&this.disposed.push([r,e,"set"])),this.removeItemSize(u),this.valList[u]=t,this.addItemSize(u,o)),this.moveToTail(u)}if(0===r||0!==this.ttl||this.ttls||this.initializeTTLTracking(),s||this.setItemTTL(u,r,n),this.disposeAfter)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return this}newIndex(){return 0===this.size?this.tail:this.size===this.max&&0!==this.max?this.evict(!1):0!==this.free.length?this.free.pop():this.initialFill++}pop(){if(this.size){const e=this.valList[this.head];return this.evict(!0),e}}evict(e){const t=this.head,r=this.keyList[t],n=this.valList[t];return this.isBackgroundFetch(n)?n.__abortController.abort():(this.dispose(n,r,"evict"),this.disposeAfter&&this.disposed.push([n,r,"evict"])),this.removeItemSize(t),e&&(this.keyList[t]=null,this.valList[t]=null,this.free.push(t)),this.head=this.next[t],this.keyMap.delete(r),this.size--,t}has(e,{updateAgeOnHas:t=this.updateAgeOnHas}={}){const r=this.keyMap.get(e);return void 0!==r&&!this.isStale(r)&&(t&&this.updateItemAge(r),!0)}peek(e,{allowStale:t=this.allowStale}={}){const r=this.keyMap.get(e);if(void 0!==r&&(t||!this.isStale(r))){const e=this.valList[r];return this.isBackgroundFetch(e)?e.__staleWhileFetching:e}}backgroundFetch(e,t,r,n){const i=void 0===t?void 0:this.valList[t];if(this.isBackgroundFetch(i))return i;const a=new o,s={signal:a.signal,options:r,context:n},u=t=>(a.signal.aborted||this.set(e,t,s.options),t),c=n=>{if(this.valList[t]===f){const n=!r.noDeleteOnFetchRejection||void 0===f.__staleWhileFetching;n?this.delete(e):this.valList[t]=f.__staleWhileFetching}if(f.__returned===f)throw n},l=t=>t(this.fetchMethod(e,i,s)),f=new Promise(l).then(u,c);return f.__abortController=a,f.__staleWhileFetching=i,f.__returned=null,void 0===t?(this.set(e,f,s.options),t=this.keyMap.get(e)):this.valList[t]=f,f}isBackgroundFetch(e){return e&&"object"==typeof e&&"function"==typeof e.then&&Object.prototype.hasOwnProperty.call(e,"__staleWhileFetching")&&Object.prototype.hasOwnProperty.call(e,"__returned")&&(e.__returned===e||null===e.__returned)}async fetch(e,{allowStale:t=this.allowStale,updateAgeOnGet:r=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet,ttl:i=this.ttl,noDisposeOnSet:o=this.noDisposeOnSet,size:a=0,sizeCalculation:s=this.sizeCalculation,noUpdateTTL:u=this.noUpdateTTL,noDeleteOnFetchRejection:c=this.noDeleteOnFetchRejection,fetchContext:l=this.fetchContext,forceRefresh:f=!1}={}){if(!this.fetchMethod)return this.get(e,{allowStale:t,updateAgeOnGet:r,noDeleteOnStaleGet:n});const d={allowStale:t,updateAgeOnGet:r,noDeleteOnStaleGet:n,ttl:i,noDisposeOnSet:o,size:a,sizeCalculation:s,noUpdateTTL:u,noDeleteOnFetchRejection:c};let h=this.keyMap.get(e);if(void 0===h){const t=this.backgroundFetch(e,h,d,l);return t.__returned=t}{const n=this.valList[h];if(this.isBackgroundFetch(n))return t&&void 0!==n.__staleWhileFetching?n.__staleWhileFetching:n.__returned=n;if(!f&&!this.isStale(h))return this.moveToTail(h),r&&this.updateItemAge(h),n;const i=this.backgroundFetch(e,h,d,l);return t&&void 0!==i.__staleWhileFetching?i.__staleWhileFetching:i.__returned=i}}get(e,{allowStale:t=this.allowStale,updateAgeOnGet:r=this.updateAgeOnGet,noDeleteOnStaleGet:n=this.noDeleteOnStaleGet}={}){const i=this.keyMap.get(e);if(void 0!==i){const o=this.valList[i],a=this.isBackgroundFetch(o);if(this.isStale(i))return a?t?o.__staleWhileFetching:void 0:(n||this.delete(e),t?o:void 0);if(a)return;return this.moveToTail(i),r&&this.updateItemAge(i),o}}connect(e,t){this.prev[t]=e,this.next[e]=t}moveToTail(e){e!==this.tail&&(e===this.head?this.head=this.next[e]:this.connect(this.prev[e],this.next[e]),this.connect(this.tail,e),this.tail=e)}get del(){return f("del","delete"),this.delete}delete(e){let t=!1;if(0!==this.size){const r=this.keyMap.get(e);if(void 0!==r)if(t=!0,1===this.size)this.clear();else{this.removeItemSize(r);const t=this.valList[r];this.isBackgroundFetch(t)?t.__abortController.abort():(this.dispose(t,e,"delete"),this.disposeAfter&&this.disposed.push([t,e,"delete"])),this.keyMap.delete(e),this.keyList[r]=null,this.valList[r]=null,r===this.tail?this.tail=this.prev[r]:r===this.head?this.head=this.next[r]:(this.next[this.prev[r]]=this.next[r],this.prev[this.next[r]]=this.prev[r]),this.size--,this.free.push(r)}}if(this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift());return t}clear(){for(const e of this.rindexes({allowStale:!0})){const t=this.valList[e];if(this.isBackgroundFetch(t))t.__abortController.abort();else{const r=this.keyList[e];this.dispose(t,r,"delete"),this.disposeAfter&&this.disposed.push([t,r,"delete"])}}if(this.keyMap.clear(),this.valList.fill(null),this.keyList.fill(null),this.ttls&&(this.ttls.fill(0),this.starts.fill(0)),this.sizes&&this.sizes.fill(0),this.head=0,this.tail=0,this.initialFill=1,this.free.length=0,this.calculatedSize=0,this.size=0,this.disposed)for(;this.disposed.length;)this.disposeAfter(...this.disposed.shift())}get reset(){return f("reset","clear"),this.clear}get length(){return d("length","size"),this.size}static get AbortController(){return o}static get AbortSignal(){return u}}e.exports=w}}}},"form-builder":{"package.json":function e(t,r,e){e.exports={name:"@steedos/form-builder",version:"3.6.2-patch.5",private:!1,publishConfig:{access:"public"},main:"dist/form-builder.min.js",homepage:"https://formbuilder.online/",repository:{url:"https://github.com/kevinchappell/formBuilder.git",type:"git"},files:["dist/**/*","docs/**/*","src/**/*"],author:"Kevin Chappell ",contributors:[],bugs:"https://github.com/kevinchappell/formBuilder/issues",description:"A jQuery plugin for drag and drop form building",keywords:["jquery-plugin","forms","drag and drop","form builder","form create"],license:"MIT",ignore:["**/*","node_modules","test"],config:{files:{test:["test/**/*.spec.js"],pluginsDir:"src/js/control_plugins/",fonts:"src/fonts",sass:"src/sass",formBuilder:{js:"src/js/form-builder.js",sass:["src/sass/form-builder.scss"]},formRender:{js:"src/js/form-render.js",sass:["src/sass/form-render.scss"]},site:["demo/assets/sass/site.scss"]},fontServer:"http://fontello.com",fontelloToken:"09d648f01d6c57cb9f9b8cc55043e0c0"},babel:{presets:[["@babel/preset-env",{targets:{browsers:["> 1%"]},loose:!0}]],comments:!1,plugins:["@babel/plugin-proposal-object-rest-spread","@babel/plugin-proposal-class-properties"]},scripts:{"build:analyze":"webpack --mode production -p --progress --config tools/webpack.config --analyze","build:plugins":"webpack --mode production -p --display-entrypoints --progress --config tools/webpack.plugins.config","build:vendor":"babel-node tools/build-vendor",build:"webpack --mode production -p --progress --config tools/webpack.config","build:all":"npm-run-all build:plugins build:vendor build copy",copy:"cp -a dist/* demo/assets/js/ && cp CONTRIBUTING.md docs/contributing.md && cp LICENSE docs/license.md && npm run copy:lang","copy:lang":"babel-node tools/copy-language-files","deploy:all":"npm-run-all deploy:demo deploy:site","deploy:demo":"node tools/deploy-demo.js","deploy:site":"node tools/deploy-site.js",docs:"mkdocs build",font:"babel-node tools/icon-font",lint:"eslint ./src --ext .js || true","semantic-release":"semantic-release","start:devServer":"webpack-dev-server --mode development --config tools/webpack.config",prestart:"npm-run-all -p build:vendor copy:lang",start:"npm run start:devServer",test:"npm run-script build"},dependencies:{jquery:">=3.4.1","jquery-ui-sortable":"*"},devDependencies:{"@babel/cli":"^7.10.5","@babel/core":"^7.11.4","@babel/node":"^7.10.5","@babel/plugin-proposal-class-properties":"^7.10.4","@babel/plugin-proposal-object-rest-spread":"^7.11.0","@babel/plugin-syntax-object-rest-spread":"^7.8.3","@babel/plugin-transform-destructuring":"^7.10.4","@babel/preset-env":"^7.11.0","@semantic-release/changelog":"^5.0.1","@semantic-release/git":"^9.0.0","@semantic-release/npm":"^7.0.5",autoprefixer:"^9.8.6","babel-eslint":"^10.1.0","babel-loader":"^8.1.0","clean-webpack-plugin":"^3.0.0",clui:"^0.3.6","compression-webpack-plugin":"^5.0.1","concat-files":"^0.1.1","cross-env":"^7.0.2","css-loader":"^4.2.1",eslint:"^7.7.0","eslint-loader":"^4.0.2","formbuilder-languages":"latest","fs-extra":"^9.0.1","html-webpack-harddisk-plugin":"^1.0.2","html-webpack-plugin":"^4.3.0",inquirer:"^7.3.3",mi18n:"^0.4.8","node-sass":"6.0.1","npm-run-all":"^4.1.5",opener:"^1.5.1","postcss-loader":"^3.0.0","replace-in-file":"^6.1.0",request:"^2.88.2","sass-loader":"10.5.2","semantic-release":"^17.1.1",semver:"^7.3.2","style-loader":"^1.2.1",unzipper:"^0.10.11",webpack:"^4.44.1","webpack-bundle-analyzer":"^3.8.0","webpack-cli":"^3.3.12","webpack-dev-server":"^3.11.0","wrapper-webpack-plugin":"^2.1.0"},prettier:{singleQuote:!0,trailingComma:"all",printWidth:120,semi:!1,arrowParens:"avoid",spaceAfterFunction:!1},engines:{},release:{branch:"master",verifyConditions:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"],prepare:["@semantic-release/changelog","@semantic-release/npm","@semantic-release/git"]},browserslist:["> 1%"]}},dist:{"form-builder.min.js":function e(t,r){ /*! * jQuery formBuilder: https://formbuilder.online/ * Version: 3.6.2-patch.5 @@ -268,7 +268,7 @@ Package._define("mobile-experience"); !function(){var a=Package["ddp-client"].DDP;Package._define("ddp",{DDP:a})}(); -Package._define("ddp-server"); +!function(){var e,a,d;Package._define("ddp-server")}(); !function(){var e=Package.meteor.Meteor,t=Package.meteor.global,r=Package.meteor.meteorEnv,n=Package.minimongo.LocalCollection,o=Package.minimongo.Minimongo,i=Package.check.check,a=Package.check.Match,c=Package.ejson.EJSON,s=Package["ddp-client"].DDP,l=Package.modules.meteorInstall,d=Package.modules.meteorBabelHelpers,f=Package.promise.Promise,u,h;l({node_modules:{meteor:{"allow-deny":{"allow-deny.js":function t(){var r=Object.prototype.hasOwnProperty,o=(u={CollectionPrototype:{}}).CollectionPrototype;o.allow=function(e){h(this,"allow",e)},o.deny=function(e){h(this,"deny",e)},o._defineMutationMethods=function(t){var n=this;if(t=t||{},n._restricted=!1,n._insecure=void 0,n._validators={insert:{allow:[],deny:[]},update:{allow:[],deny:[]},remove:{allow:[],deny:[]},upsert:{allow:[],deny:[]},fetch:[],fetchAllFields:!1},n._name&&(n._prefix="/"+n._name+"/",n._connection&&(n._connection===e.server||e.isClient))){var o={};["insert","update","remove"].forEach((function(c){var s=n._prefix+c;if(t.useExisting){var l=e.isClient?"_methodHandlers":"method_handlers";if(n._connection[l]&&"function"==typeof n._connection[l][s])return}o[s]=function(){i(arguments,[a.Any]);var t=Array.from(arguments);try{var o=null;if("insert"!==c||r.call(t[0],"_id")||(o=n._makeNewID()),this.isSimulation)return null!==o&&(t[0]._id=o),n._collection[c].apply(n._collection,t);if("insert"!==c&&_(t[0],c),n._restricted){if(0===n._validators[c].allow.length)throw new e.Error(403,"Access denied. No allow validators set on restricted collection for method '"+c+"'.");var s="_validated"+c.charAt(0).toUpperCase()+c.slice(1);return t.unshift(this.userId),"insert"===c&&t.push(o),n[s].apply(n,t)}if(n._isInsecure())return null!==o&&(t[0]._id=o),n._collection[c].apply(n._collection,t);throw new e.Error(403,"Access denied")}catch(l){throw"MongoError"===l.name||"MinimongoError"===l.name?new e.Error(409,l.toString()):l}}})),n._connection.methods(o)}},o._updateFetch=function(e){var t=this;if(!this._validators.fetchAllFields)if(e){var r=Object.create(null),n=function(e){return e&&e.forEach((function(e){return r[e]=1}))};n(this._validators.fetch),n(e),this._validators.fetch=Object.keys(r)}else this._validators.fetchAllFields=!0,this._validators.fetch=null},o._isInsecure=function(){var e=this;return void 0===this._insecure?!!Package.insecure:this._insecure},o._validatedInsert=function(t,r,n){var o=this;if(this._validators.insert.deny.some((function(e){return e(t,f(e,r,n))})))throw new e.Error(403,"Access denied");if(this._validators.insert.allow.every((function(e){return!e(t,f(e,r,n))})))throw new e.Error(403,"Access denied");null!==n&&(r._id=n),this._collection.insert.call(this._collection,r)},o._validatedUpdate=function(t,o,a,c){var s=this;if(i(a,Object),c=Object.assign(Object.create(null),c),!n._selectorIsIdPerhapsAsObject(o))throw new Error("validated update should be of a single ID");if(c.upsert)throw new e.Error(403,"Access denied. Upserts not allowed in a restricted collection.");var f="Access denied. In a restricted collection you can only update documents, not replace them. Use a Mongo update operator, such as '$set'.",u=Object.keys(a),h={};if(0===u.length)throw new e.Error(403,f);u.forEach((function(t){var n=a[t];if("$"!==t.charAt(0))throw new e.Error(403,f);if(!r.call(l,t))throw new e.Error(403,"Access denied. Operator "+t+" not allowed in a restricted collection.");Object.keys(n).forEach((function(e){-1!==e.indexOf(".")&&(e=e.substring(0,e.indexOf("."))),h[e]=!0}))}));var _=Object.keys(h),v={transform:null};this._validators.fetchAllFields||(v.fields={},this._validators.fetch.forEach((function(e){v.fields[e]=1})));var m=this._collection.findOne(o,v);if(!m)return 0;if(this._validators.update.deny.some((function(e){var r=d(e,m);return e(t,r,_,a)})))throw new e.Error(403,"Access denied");if(this._validators.update.allow.every((function(e){var r=d(e,m);return!e(t,r,_,a)})))throw new e.Error(403,"Access denied");return c._forbidReplace=!0,this._collection.update.call(this._collection,o,a,c)};var l={$inc:1,$set:1,$unset:1,$addToSet:1,$pop:1,$pullAll:1,$pull:1,$pushAll:1,$push:1,$bit:1};function d(e,t){return e.transform?e.transform(t):t}function f(e,t,r){var n=t;return e.transform&&(n=c.clone(t),null!==r&&(n._id=r),n=e.transform(n)),n}function h(e,t,o){var i=/^(?:insert|update|remove|fetch|transform)$/;if(Object.keys(o).forEach((function(e){if(!i.test(e))throw new Error(t+": Invalid key: "+e)})),e._restricted=!0,["insert","update","remove"].forEach((function(i){if(r.call(o,i)){if(!(o[i]instanceof Function))throw new Error(t+": Value for `"+i+"` must be a function");void 0===o.transform?o[i].transform=e._transform:o[i].transform=n.wrapTransform(o.transform),e._validators[i][t].push(o[i])}})),o.update||o.remove||o.fetch){if(o.fetch&&!(o.fetch instanceof Array))throw new Error(t+": Value for `fetch` must be an array");e._updateFetch(o.fetch)}}function _(t,r){if(!n._selectorIsIdPerhapsAsObject(t))throw new e.Error(403,"Not permitted. Untrusted code may only "+r+" documents by ID.")}function v(){var e,t=(s._CurrentMethodInvocation||s._CurrentInvocation).get();return t&&t.isSimulation}o._validatedRemove=function(t,r){var n=this,o={transform:null};this._validators.fetchAllFields||(o.fields={},this._validators.fetch.forEach((function(e){o.fields[e]=1})));var i=this._collection.findOne(r,o);if(!i)return 0;if(this._validators.remove.deny.some((function(e){return e(t,d(e,i))})))throw new e.Error(403,"Access denied");if(this._validators.remove.allow.every((function(e){return!e(t,d(e,i))})))throw new e.Error(403,"Access denied");return this._collection.remove.call(this._collection,r)},o._callMutatorMethod=function(){function t(t,r,n){var o;!e.isClient||n||v()||(n=function(r){r&&e._debug(t+" failed: "+(r.reason||r.stack))}),("update"===t||"remove"===t)&&!v()&&_(r[0],t);var i=this._prefix+t;return this._connection.apply(i,r,{returnStubValue:!0},n)}return t}()}}}}},{extensions:[".js",".json"]})("/node_modules/meteor/allow-deny/allow-deny.js"),Package._define("allow-deny",{AllowDeny:u})}(); diff --git a/server/bundle/programs/web.cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.stats.json b/server/bundle/programs/web.cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json similarity index 99% rename from server/bundle/programs/web.cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.stats.json rename to server/bundle/programs/web.cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json index 8c5d55b9fa..554bfa5ec8 100644 --- a/server/bundle/programs/web.cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.stats.json +++ b/server/bundle/programs/web.cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json @@ -3,8 +3,8 @@ "name": "standard-minifier-js", "version": "2.6.0" }, - "totalMinifiedBytes": 4482939, - "totalMinifiedGzipBytes": 1144346, + "totalMinifiedBytes": 4482964, + "totalMinifiedGzipBytes": 1144347, "minifiedBytesByPackage": { "packages/meteor.js": 9639, "packages/coffeescript.js": 32, @@ -1317,7 +1317,7 @@ } ], "packages/ddp.js": 78, - "packages/ddp-server.js": 30, + "packages/ddp-server.js": 55, "packages/allow-deny.js": [ 6029, { diff --git a/server/bundle/programs/web.cordova/program.json b/server/bundle/programs/web.cordova/program.json index 81f1349874..24ae4eeb5a 100644 --- a/server/bundle/programs/web.cordova/program.json +++ b/server/bundle/programs/web.cordova/program.json @@ -2,24 +2,24 @@ "format": "web-program-pre1", "manifest": [ { - "path": "562208cdca3e6c297f81857edf4a42d67cc7b014.js", + "path": "717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js", "where": "client", "type": "js", "cacheable": true, - "url": "/__cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.js?meteor_js_resource=true", - "size": 4482939, - "hash": "562208cdca3e6c297f81857edf4a42d67cc7b014", - "sri": "siGUoqXR2aXnth1Dk0AjCefngPU/9OYxKzTi7YQ4ilQg39nLjtSXbFANAXLXTJlHS2pXRmo79zm1ZElKWfW4KA==" + "url": "/__cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js?meteor_js_resource=true", + "size": 4482964, + "hash": "717fd9820c5c4cf898af8b1c4a65e09c854f6d33", + "sri": "umWnr/cf2bXXD8RxsTQ8J7UvfCTN0M5R0cUUb7MEMwVlmW6IxafLb8XC1yIkZZrB/VrmhQ2aiQfyX0sorJZSMQ==" }, { - "path": "562208cdca3e6c297f81857edf4a42d67cc7b014.stats.json", + "path": "717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json", "where": "client", "type": "json", "cacheable": true, - "url": "/__cordova/562208cdca3e6c297f81857edf4a42d67cc7b014.stats.json?meteor_js_resource=true", + "url": "/__cordova/717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json?meteor_js_resource=true", "size": 82586, - "hash": "0f44998ebad4725dcb8ba71e25a03bc2bb1c877e", - "sri": "L/9Fn9V9FI0HKRTgKHvgub2YGRQC/uzKBlqHA6h60E1sqWvn7yMbKcZYy0pPzdbN1XRDluzzofDmWs8Ps5M5aQ==" + "hash": "dfc2e03a04605fe54471304f74bb304df52ec5c8", + "sri": "F50KddjLHeuM7uZ9OhrdEYHxB4FSMIb7bv26qmLWvvt5zuWBk/5BOepZu4f0bVmgeq5ETSrxRn2z0u0yAtK2vA==" }, { "path": "106b9e345091b56401f90f1c9096385cd0758cb4.css", diff --git a/server/bundle/star.json b/server/bundle/star.json index d656a54d88..665464447a 100644 --- a/server/bundle/star.json +++ b/server/bundle/star.json @@ -36,5 +36,5 @@ "meteorRelease": "METEOR@1.9.3", "nodeVersion": "12.16.1", "npmVersion": "6.13.4", - "gitCommitHash": "846f5bcd7ec32fba16adbc1f43fd4a39df37bd5b" + "gitCommitHash": "dfc5b93993de2cdc4f25fc17cd29ba7f8947c069" } \ No newline at end of file From 957145ac948fb1c17342669b1451edf987f03952 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=AD=99=E6=B5=A9=E6=9E=97?= Date: Fri, 19 Jul 2024 10:58:16 +0800 Subject: [PATCH 2/6] =?UTF-8?q?[Bug]:=20sockjs/info=20=E8=AF=B7=E6=B1=82?= =?UTF-8?q?=E4=B8=ADAccess-Control-Allow-Origin=E4=B8=BA*=EF=BC=8C?= =?UTF-8?q?=E5=AD=98=E5=9C=A8=E5=AE=89=E5=85=A8=E9=9A=90=E6=82=A3=20#6964?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- creator/packages/ddp-server/stream_server.js | 26 ++++++++++--------- .../programs/server/packages/ddp-server.js | 6 +++-- .../server/packages/ddp-server.js.map | 2 +- server/bundle/star.json | 2 +- 4 files changed, 20 insertions(+), 16 deletions(-) diff --git a/creator/packages/ddp-server/stream_server.js b/creator/packages/ddp-server/stream_server.js index 1996d9088c..85a9997e56 100644 --- a/creator/packages/ddp-server/stream_server.js +++ b/creator/packages/ddp-server/stream_server.js @@ -15,7 +15,7 @@ var websocketExtensions = _.once(function () { var extensions = []; var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION - ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {}; + ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {}; if (websocketCompressionConfig) { extensions.push(Npm.require('permessage-deflate').configure( websocketCompressionConfig @@ -25,7 +25,7 @@ var websocketExtensions = _.once(function () { return extensions; }); -var pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || ""; +var pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || ""; StreamServer = function () { var self = this; @@ -41,7 +41,7 @@ StreamServer = function () { var sockjs = Npm.require('sockjs'); var serverOptions = { prefix: self.prefix, - log: function() {}, + log: function () { }, // this is the default, but we code it explicitly because we depend // on it in stream_client:HEARTBEAT_TIMEOUT heartbeat_delay: 45000, @@ -55,7 +55,9 @@ StreamServer = function () { // Set the USE_JSESSIONID environment variable to enable setting the // JSESSIONID cookie. This is useful for setting up proxies with // session affinity. - jsessionid: !!process.env.USE_JSESSIONID + jsessionid: !!process.env.USE_JSESSIONID, + // 禁用cors，防止请求response返回Access-Control-Allow-Origin:* + disable_cors: true }; // If you know your server environment (eg, proxies) will prevent websockets @@ -98,8 +100,8 @@ StreamServer = function () { // livedata_server.js. socket.setWebsocketTimeout = function (timeout) { if ((socket.protocol === 'websocket' || - socket.protocol === 'websocket-raw') - && socket._session.recv) { + socket.protocol === 'websocket-raw') + && socket._session.recv) { socket._session.recv.connection.setTimeout(timeout); } }; @@ -118,7 +120,7 @@ StreamServer = function () { // concerned about people upgrading from a pre-0.7.0 release. Also, // remove the clause in the client that ignores the welcome message // (livedata_connection.js) - socket.send(JSON.stringify({server_id: "0"})); + socket.send(JSON.stringify({ server_id: "0" })); // call all our callbacks when we get a new socket. they will do the // work of setting up handlers and such for specific messages. @@ -148,21 +150,21 @@ _.extend(StreamServer.prototype, { // Redirect /websocket to /sockjs/websocket in order to not expose // sockjs to clients that want to use raw websockets - _redirectWebsocketEndpoint: function() { + _redirectWebsocketEndpoint: function () { var self = this; // Unfortunately we can't use a connect middleware here since // sockjs installs itself prior to all existing listeners // (meaning prior to any connect middlewares) so we need to take // an approach similar to overshadowListeners in // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee - _.each(['request', 'upgrade'], function(event) { + _.each(['request', 'upgrade'], function (event) { var httpServer = WebApp.httpServer; var oldHttpServerListeners = httpServer.listeners(event).slice(0); httpServer.removeAllListeners(event); // request and upgrade have different arguments passed but // we only care about the first one which is always request - var newListener = function(request /*, moreArguments */) { + var newListener = function (request /*, moreArguments */) { // Store arguments for use within the closure below var args = arguments; @@ -170,11 +172,11 @@ _.extend(StreamServer.prototype, { // preserving query string. var parsedUrl = url.parse(request.url); if (parsedUrl.pathname === pathPrefix + '/websocket' || - parsedUrl.pathname === pathPrefix + '/websocket/') { + parsedUrl.pathname === pathPrefix + '/websocket/') { parsedUrl.pathname = self.prefix + '/websocket'; request.url = url.format(parsedUrl); } - _.each(oldHttpServerListeners, function(oldListener) { + _.each(oldHttpServerListeners, function (oldListener) { oldListener.apply(httpServer, args); }); }; diff --git a/server/bundle/programs/server/packages/ddp-server.js b/server/bundle/programs/server/packages/ddp-server.js index 4cd5085e6d..440878eebe 100644 --- a/server/bundle/programs/server/packages/ddp-server.js +++ b/server/bundle/programs/server/packages/ddp-server.js @@ -87,7 +87,9 @@ StreamServer = function () { // Set the USE_JSESSIONID environment variable to enable setting the // JSESSIONID cookie. This is useful for setting up proxies with // session affinity. - jsessionid: !!process.env.USE_JSESSIONID + jsessionid: !!process.env.USE_JSESSIONID, + // 禁用cors，防止请求response返回Access-Control-Allow-Origin:* + disable_cors: true }; // If you know your server environment (eg, proxies) will prevent websockets // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie, // browsers) will not waste time attempting to use them. @@ -2245,4 +2247,4 @@ Package._define("ddp-server", { })(); //# sourceURL=meteor://💻app/packages/ddp-server.js -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAIA,GAAG,GAAGC,GAAG,CAACC,OAAJ,CAAY,KAAZ,CAAV,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,IAAIC,mBAAmB,GAAGC,CAAC,CAACC,IAAF,CAAO,YAAY;AAC3C,MAAIC,UAAU,GAAG,EAAjB;AAEA,MAAIC,0BAA0B,GAAGC,OAAO,CAACC,GAAR,CAAYC,4BAAZ,GACzBC,IAAI,CAACC,KAAL,CAAWJ,OAAO,CAACC,GAAR,CAAYC,4BAAvB,CADyB,GAC8B,EAD/D;;AAEA,MAAIH,0BAAJ,EAAgC;AAC9BD,cAAU,CAACO,IAAX,CAAgBZ,GAAG,CAACC,OAAJ,CAAY,oBAAZ,EAAkCY,SAAlC,CACdP,0BADc,CAAhB;AAGD;;AAED,SAAOD,UAAP;AACD,CAZyB,CAA1B;;AAcA,IAAIS,UAAU,GAAGC,yBAAyB,CAACC,oBAA1B,IAAmD,EAApE;;AAEAC,YAAY,GAAG,YAAY;AACzB,MAAIC,IAAI,GAAG,IAAX;AACAA,MAAI,CAACC,sBAAL,GAA8B,EAA9B;AACAD,MAAI,CAACE,YAAL,GAAoB,EAApB,CAHyB,CAKzB;AACA;;AACAF,MAAI,CAACG,MAAL,GAAcP,UAAU,GAAG,SAA3B;AACAQ,aAAW,CAACC,OAAZ,CAAoBL,IAAI,CAACG,MAAL,GAAc,GAAlC,EAAuC,SAAvC,EARyB,CAUzB;;AACA,MAAIG,MAAM,GAAGxB,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAb;;AACA,MAAIwB,aAAa,GAAG;AAClBJ,UAAM,EAAEH,IAAI,CAACG,MADK;AAElBK,OAAG,EAAE,YAAW,CAAE,CAFA;AAGlB;AACA;AACAC,mBAAe,EAAE,KALC;AAMlB;AACA;AACA;AACA;AACA;AACA;AACAC,oBAAgB,EAAE,KAAK,IAZL;AAalB;AACA;AACA;AACAC,cAAU,EAAE,CAAC,CAACtB,OAAO,CAACC,GAAR,CAAYsB;AAhBR,GAApB,CAZyB,CA+BzB;AACA;AACA;AACA;;AACA,MAAIvB,OAAO,CAACC,GAAR,CAAYuB,kBAAhB,EAAoC;AAClCN,iBAAa,CAACO,SAAd,GAA0B,KAA1B;AACD,GAFD,MAEO;AACLP,iBAAa,CAACQ,mBAAd,GAAoC;AAClC5B,gBAAU,EAAEH,mBAAmB;AADG,KAApC;AAGD;;AAEDgB,MAAI,CAACgB,MAAL,GAAcV,MAAM,CAACW,YAAP,CAAoBV,aAApB,CAAd,CA3CyB,CA6CzB;AACA;AACA;AACA;;AACAW,QAAM,CAACC,UAAP,CAAkBC,cAAlB,CACE,SADF,EACaF,MAAM,CAACG,iCADpB;AAEArB,MAAI,CAACgB,MAAL,CAAYM,eAAZ,CAA4BJ,MAAM,CAACC,UAAnC;AACAD,QAAM,CAACC,UAAP,CAAkBI,WAAlB,CACE,SADF,EACaL,MAAM,CAACG,iCADpB,EApDyB,CAuDzB;;AACArB,MAAI,CAACwB,0BAAL;;AAEAxB,MAAI,CAACgB,MAAL,CAAYS,EAAZ,CAAe,YAAf,EAA6B,UAAUC,MAAV,EAAkB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,UAAM,CAACC,mBAAP,GAA6B,UAAUC,OAAV,EAAmB;AAC9C,UAAI,CAACF,MAAM,CAACG,QAAP,KAAoB,WAApB,IACAH,MAAM,CAACG,QAAP,KAAoB,eADrB,KAEGH,MAAM,CAACI,QAAP,CAAgBC,IAFvB,EAE6B;AAC3BL,cAAM,CAACI,QAAP,CAAgBC,IAAhB,CAAqBC,UAArB,CAAgCC,UAAhC,CAA2CL,OAA3C;AACD;AACF,KAND;;AAOAF,UAAM,CAACC,mBAAP,CAA2B,KAAK,IAAhC;;AAEAD,UAAM,CAACQ,IAAP,GAAc,UAAUC,IAAV,EAAgB;AAC5BT,YAAM,CAACU,KAAP,CAAaD,IAAb;AACD,KAFD;;AAGAT,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7BzB,UAAI,CAACE,YAAL,GAAoBjB,CAAC,CAACoD,OAAF,CAAUrC,IAAI,CAACE,YAAf,EAA6BwB,MAA7B,CAApB;AACD,KAFD;AAGA1B,QAAI,CAACE,YAAL,CAAkBR,IAAlB,CAAuBgC,MAAvB,EA1B6C,CA4B7C;AACA;AACA;AACA;AACA;;AACAA,UAAM,CAACQ,IAAP,CAAY1C,IAAI,CAAC8C,SAAL,CAAe;AAACC,eAAS,EAAE;AAAZ,KAAf,CAAZ,EAjC6C,CAmC7C;AACA;;AACAtD,KAAC,CAACuD,IAAF,CAAOxC,IAAI,CAACC,sBAAZ,EAAoC,UAAUwC,QAAV,EAAoB;AACtDA,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAxCD;AA0CD,CApGD;;AAsGAzC,CAAC,CAACyD,MAAF,CAAS3C,YAAY,CAAC4C,SAAtB,EAAiC;AAC/B;AACA;AACAC,UAAQ,EAAE,UAAUH,QAAV,EAAoB;AAC5B,QAAIzC,IAAI,GAAG,IAAX;AACAA,QAAI,CAACC,sBAAL,CAA4BP,IAA5B,CAAiC+C,QAAjC;;AACAxD,KAAC,CAACuD,IAAF,CAAOxC,IAAI,CAAC6C,WAAL,EAAP,EAA2B,UAAUnB,MAAV,EAAkB;AAC3Ce,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAT8B;AAW/B;AACAmB,aAAW,EAAE,YAAY;AACvB,QAAI7C,IAAI,GAAG,IAAX;AACA,WAAOf,CAAC,CAAC6D,MAAF,CAAS9C,IAAI,CAACE,YAAd,CAAP;AACD,GAf8B;AAiB/B;AACA;AACAsB,4BAA0B,EAAE,YAAW;AACrC,QAAIxB,IAAI,GAAG,IAAX,CADqC,CAErC;AACA;AACA;AACA;AACA;;AACAf,KAAC,CAACuD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,CAAP,EAA+B,UAASO,KAAT,EAAgB;AAC7C,UAAI5B,UAAU,GAAGD,MAAM,CAACC,UAAxB;AACA,UAAI6B,sBAAsB,GAAG7B,UAAU,CAAC8B,SAAX,CAAqBF,KAArB,EAA4BG,KAA5B,CAAkC,CAAlC,CAA7B;AACA/B,gBAAU,CAACgC,kBAAX,CAA8BJ,KAA9B,EAH6C,CAK7C;AACA;;AACA,UAAIK,WAAW,GAAG,UAASC;AAAQ;AAAjB,QAAuC;AACvD;AACA,YAAIC,IAAI,GAAGC,SAAX,CAFuD,CAIvD;AACA;;AACA,YAAIC,SAAS,GAAG3E,GAAG,CAACY,KAAJ,CAAU4D,OAAO,CAACxE,GAAlB,CAAhB;;AACA,YAAI2E,SAAS,CAACC,QAAV,KAAuB7D,UAAU,GAAG,YAApC,IACA4D,SAAS,CAACC,QAAV,KAAuB7D,UAAU,GAAG,aADxC,EACuD;AACrD4D,mBAAS,CAACC,QAAV,GAAqBzD,IAAI,CAACG,MAAL,GAAc,YAAnC;AACAkD,iBAAO,CAACxE,GAAR,GAAcA,GAAG,CAAC6E,MAAJ,CAAWF,SAAX,CAAd;AACD;;AACDvE,SAAC,CAACuD,IAAF,CAAOQ,sBAAP,EAA+B,UAASW,WAAT,EAAsB;AACnDA,qBAAW,CAACC,KAAZ,CAAkBzC,UAAlB,EAA8BmC,IAA9B;AACD,SAFD;AAGD,OAfD;;AAgBAnC,gBAAU,CAACI,WAAX,CAAuBwB,KAAvB,EAA8BK,WAA9B;AACD,KAxBD;AAyBD;AAnD8B,CAAjC,E;;;;;;;;;;;ACnIAS,SAAS,GAAG,EAAZ;;AAEA,IAAIC,KAAK,GAAGhF,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAZ,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;AACA,IAAIgF,mBAAmB,GAAG,YAAY;AACpC,MAAI/D,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgE,QAAL,GAAgB,IAAIC,GAAJ,EAAhB,CAFoC,CAET;;AAC3BjE,MAAI,CAACkE,SAAL,GAAiB,IAAIC,GAAJ,EAAjB,CAHoC,CAGR;AAC7B,CAJD;;AAMAN,SAAS,CAACO,oBAAV,GAAiCL,mBAAjC;;AAGA9E,CAAC,CAACyD,MAAF,CAASqB,mBAAmB,CAACpB,SAA7B,EAAwC;AAEtC0B,WAAS,EAAE,YAAY;AACrB,QAAIrE,IAAI,GAAG,IAAX;AACA,QAAIsE,GAAG,GAAG,EAAV;AACAtE,QAAI,CAACkE,SAAL,CAAeK,OAAf,CAAuB,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACpDH,SAAG,CAACG,GAAD,CAAH,GAAWD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7B;AACD,KAFD;AAGA,WAAOJ,GAAP;AACD,GATqC;AAWtCK,YAAU,EAAE,UAAUC,kBAAV,EAA8BH,GAA9B,EAAmCI,eAAnC,EAAoD;AAC9D,QAAI7E,IAAI,GAAG,IAAX,CAD8D,CAE9D;;AACA,QAAIyE,GAAG,KAAK,KAAZ,EACE;AACF,QAAID,cAAc,GAAGxE,IAAI,CAACkE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB,CAL8D,CAO9D;AACA;;AACA,QAAI,CAACD,cAAL,EACE;AAEF,QAAIO,YAAY,GAAGC,SAAnB;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGT,cAAc,CAACU,MAAnC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9C,UAAIE,UAAU,GAAGX,cAAc,CAACS,CAAD,CAA/B;;AACA,UAAIE,UAAU,CAACP,kBAAX,KAAkCA,kBAAtC,EAA0D;AACxD;AACA;AACA,YAAIK,CAAC,KAAK,CAAV,EACEF,YAAY,GAAGI,UAAU,CAACT,KAA1B;AACFF,sBAAc,CAACY,MAAf,CAAsBH,CAAtB,EAAyB,CAAzB;AACA;AACD;AACF;;AACD,QAAIT,cAAc,CAACU,MAAf,KAA0B,CAA9B,EAAiC;AAC/BlF,UAAI,CAACkE,SAAL,CAAemB,MAAf,CAAsBZ,GAAtB;AACAI,qBAAe,CAACJ,GAAD,CAAf,GAAuBO,SAAvB;AACD,KAHD,MAGO,IAAID,YAAY,KAAKC,SAAjB,IACA,CAACM,KAAK,CAACC,MAAN,CAAaR,YAAb,EAA2BP,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7C,CADL,EAC0D;AAC/DG,qBAAe,CAACJ,GAAD,CAAf,GAAuBD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAAzC;AACD;AACF,GA1CqC;AA4CtCc,aAAW,EAAE,UAAUZ,kBAAV,EAA8BH,GAA9B,EAAmCC,KAAnC,EACUG,eADV,EAC2BY,KAD3B,EACkC;AAC7C,QAAIzF,IAAI,GAAG,IAAX,CAD6C,CAE7C;;AACA,QAAIyE,GAAG,KAAK,KAAZ,EACE,OAJ2C,CAM7C;;AACAC,SAAK,GAAGY,KAAK,CAACI,KAAN,CAAYhB,KAAZ,CAAR;;AAEA,QAAI,CAAC1E,IAAI,CAACkE,SAAL,CAAeyB,GAAf,CAAmBlB,GAAnB,CAAL,EAA8B;AAC5BzE,UAAI,CAACkE,SAAL,CAAe0B,GAAf,CAAmBnB,GAAnB,EAAwB,CAAC;AAACG,0BAAkB,EAAEA,kBAArB;AACCF,aAAK,EAAEA;AADR,OAAD,CAAxB;AAEAG,qBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACA;AACD;;AACD,QAAIF,cAAc,GAAGxE,IAAI,CAACkE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB;AACA,QAAIoB,GAAJ;;AACA,QAAI,CAACJ,KAAL,EAAY;AACVI,SAAG,GAAGrB,cAAc,CAACsB,IAAf,CAAoB,UAAUX,UAAV,EAAsB;AAC5C,eAAOA,UAAU,CAACP,kBAAX,KAAkCA,kBAAzC;AACH,OAFK,CAAN;AAGD;;AAED,QAAIiB,GAAJ,EAAS;AACP,UAAIA,GAAG,KAAKrB,cAAc,CAAC,CAAD,CAAtB,IAA6B,CAACc,KAAK,CAACC,MAAN,CAAab,KAAb,EAAoBmB,GAAG,CAACnB,KAAxB,CAAlC,EAAkE;AAChE;AACAG,uBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACD;;AACDmB,SAAG,CAACnB,KAAJ,GAAYA,KAAZ;AACD,KAND,MAMO;AACL;AACAF,oBAAc,CAAC9E,IAAf,CAAoB;AAACkF,0BAAkB,EAAEA,kBAArB;AAAyCF,aAAK,EAAEA;AAAhD,OAApB;AACD;AAEF;AA/EqC,CAAxC;AAkFA;;;;;;;;AAMA,IAAIqB,qBAAqB,GAAG,UAAUC,cAAV,EAA0BC,gBAA1B,EAA4C;AACtE,MAAIjG,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgG,cAAL,GAAsBA,cAAtB;AACAhG,MAAI,CAACkG,SAAL,GAAiB,IAAI/B,GAAJ,EAAjB;AACAnE,MAAI,CAACmG,SAAL,GAAiBF,gBAAjB;AACD,CALD;;AAOApC,SAAS,CAACuC,sBAAV,GAAmCL,qBAAnC;;AAGA9G,CAAC,CAACyD,MAAF,CAASqD,qBAAqB,CAACpD,SAA/B,EAA0C;AAExC0D,SAAO,EAAE,YAAY;AACnB,QAAIrG,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAACkG,SAAL,CAAeI,IAAf,KAAwB,CAA/B;AACD,GALuC;AAOxCC,MAAI,EAAE,UAAUC,QAAV,EAAoB;AACxB,QAAIxG,IAAI,GAAG,IAAX;AACAyG,gBAAY,CAACC,QAAb,CAAsBF,QAAQ,CAACN,SAA/B,EAA0ClG,IAAI,CAACkG,SAA/C,EAA0D;AACxDS,UAAI,EAAE1H,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAAC6G,YAAZ,EAA0B7G,IAA1B,CADkD;AAGxD8G,eAAS,EAAE,UAAUC,EAAV,EAAcC,KAAd,EAAqB;AAC9BhH,YAAI,CAACmG,SAAL,CAAec,KAAf,CAAqBjH,IAAI,CAACgG,cAA1B,EAA0Ce,EAA1C,EAA8CC,KAAK,CAAC3C,SAAN,EAA9C;AACD,OALuD;AAOxD6C,cAAQ,EAAE,UAAUH,EAAV,EAAcI,MAAd,EAAsB;AAC9BnH,YAAI,CAACmG,SAAL,CAAeiB,OAAf,CAAuBpH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C;AACD;AATuD,KAA1D;AAWD,GApBuC;AAsBxCF,cAAY,EAAE,UAAUE,EAAV,EAAcI,MAAd,EAAsBH,KAAtB,EAA6B;AACzC,QAAIhH,IAAI,GAAG,IAAX;AACA,QAAIqH,MAAM,GAAG,EAAb;AACAZ,gBAAY,CAACa,WAAb,CAAyBH,MAAM,CAAC9C,SAAP,EAAzB,EAA6C2C,KAAK,CAAC3C,SAAN,EAA7C,EAAgE;AAC9DsC,UAAI,EAAE,UAAUlC,GAAV,EAAe8C,IAAf,EAAqBC,GAArB,EAA0B;AAC9B,YAAI,CAAClC,KAAK,CAACC,MAAN,CAAagC,IAAb,EAAmBC,GAAnB,CAAL,EACEH,MAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACH,OAJ6D;AAK9DV,eAAS,EAAE,UAAUrC,GAAV,EAAe+C,GAAf,EAAoB;AAC7BH,cAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACD,OAP6D;AAQ9DN,cAAQ,EAAE,UAASzC,GAAT,EAAc8C,IAAd,EAAoB;AAC5BF,cAAM,CAAC5C,GAAD,CAAN,GAAcO,SAAd;AACD;AAV6D,KAAhE;AAYAhF,QAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDM,MAAhD;AACD,GAtCuC;AAwCxCJ,OAAK,EAAE,UAAUrC,kBAAV,EAA8BmC,EAA9B,EAAkCM,MAAlC,EAA0C;AAC/C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAI0H,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAIE,KAAK,GAAG,KAAZ;;AACA,QAAI,CAACS,OAAL,EAAc;AACZT,WAAK,GAAG,IAAR;AACAS,aAAO,GAAG,IAAI3D,mBAAJ,EAAV;AACA/D,UAAI,CAACkG,SAAL,CAAeN,GAAf,CAAmBmB,EAAnB,EAAuBW,OAAvB;AACD;;AACDA,WAAO,CAAC1D,QAAR,CAAiB2D,GAAjB,CAAqB/C,kBAArB;AACA,QAAIC,eAAe,GAAG,EAAtB;;AACA5F,KAAC,CAACuD,IAAF,CAAO6E,MAAP,EAAe,UAAU3C,KAAV,EAAiBD,GAAjB,EAAsB;AACnCiD,aAAO,CAAClC,WAAR,CACEZ,kBADF,EACsBH,GADtB,EAC2BC,KAD3B,EACkCG,eADlC,EACmD,IADnD;AAED,KAHD;;AAIA,QAAIoC,KAAJ,EACEjH,IAAI,CAACmG,SAAL,CAAec,KAAf,CAAqBjH,IAAI,CAACgG,cAA1B,EAA0Ce,EAA1C,EAA8ClC,eAA9C,EADF,KAGE7E,IAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDlC,eAAhD;AACH,GA3DuC;AA6DxC4C,SAAO,EAAE,UAAU7C,kBAAV,EAA8BmC,EAA9B,EAAkCU,OAAlC,EAA2C;AAClD,QAAIzH,IAAI,GAAG,IAAX;AACA,QAAI4H,aAAa,GAAG,EAApB;AACA,QAAIF,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAI,CAACW,OAAL,EACE,MAAM,IAAIG,KAAJ,CAAU,oCAAoCd,EAApC,GAAyC,YAAnD,CAAN;;AACF9H,KAAC,CAACuD,IAAF,CAAOiF,OAAP,EAAgB,UAAU/C,KAAV,EAAiBD,GAAjB,EAAsB;AACpC,UAAIC,KAAK,KAAKM,SAAd,EACE0C,OAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CmD,aAA5C,EADF,KAGEF,OAAO,CAAClC,WAAR,CAAoBZ,kBAApB,EAAwCH,GAAxC,EAA6CC,KAA7C,EAAoDkD,aAApD;AACH,KALD;;AAMA5H,QAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDa,aAAhD;AACD,GA1EuC;AA4ExCR,SAAO,EAAE,UAAUxC,kBAAV,EAA8BmC,EAA9B,EAAkC;AACzC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAI0H,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;;AACA,QAAI,CAACW,OAAL,EAAc;AACZ,UAAII,GAAG,GAAG,IAAID,KAAJ,CAAU,kCAAkCd,EAA5C,CAAV;AACA,YAAMe,GAAN;AACD;;AACDJ,WAAO,CAAC1D,QAAR,CAAiBqB,MAAjB,CAAwBT,kBAAxB;;AACA,QAAI8C,OAAO,CAAC1D,QAAR,CAAiBsC,IAAjB,KAA0B,CAA9B,EAAiC;AAC/B;AACAtG,UAAI,CAACmG,SAAL,CAAeiB,OAAf,CAAuBpH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C;AACA/G,UAAI,CAACkG,SAAL,CAAeb,MAAf,CAAsB0B,EAAtB;AACD,KAJD,MAIO;AACL,UAAIU,OAAO,GAAG,EAAd,CADK,CAEL;AACA;;AACAC,aAAO,CAACxD,SAAR,CAAkBK,OAAlB,CAA0B,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACvDiD,eAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CgD,OAA5C;AACD,OAFD;AAIAzH,UAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDU,OAAhD;AACD;AACF;AAlGuC,CAA1C;AAqGA;;AACA;;AACA;;;AAEA,IAAIM,OAAO,GAAG,UAAU/G,MAAV,EAAkBgH,OAAlB,EAA2BtG,MAA3B,EAAmCuG,OAAnC,EAA4C;AACxD,MAAIjI,IAAI,GAAG,IAAX;AACAA,MAAI,CAAC+G,EAAL,GAAUmB,MAAM,CAACnB,EAAP,EAAV;AAEA/G,MAAI,CAACgB,MAAL,GAAcA,MAAd;AACAhB,MAAI,CAACgI,OAAL,GAAeA,OAAf;AAEAhI,MAAI,CAACmI,WAAL,GAAmB,KAAnB;AACAnI,MAAI,CAAC0B,MAAL,GAAcA,MAAd,CARwD,CAUxD;AACA;;AACA1B,MAAI,CAACoI,OAAL,GAAe,IAAIC,MAAM,CAACC,iBAAX,EAAf;AAEAtI,MAAI,CAACuI,OAAL,GAAe,KAAf;AACAvI,MAAI,CAACwI,aAAL,GAAqB,KAArB,CAfwD,CAiBxD;;AACAxI,MAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACAnE,MAAI,CAAC0I,cAAL,GAAsB,EAAtB;AAEA1I,MAAI,CAAC2I,MAAL,GAAc,IAAd;AAEA3I,MAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB,CAvBwD,CAyBxD;AACA;AACA;;AACAnE,MAAI,CAAC6I,UAAL,GAAkB,IAAlB,CA5BwD,CA8BxD;AACA;;AACA7I,MAAI,CAAC8I,0BAAL,GAAkC,KAAlC,CAhCwD,CAkCxD;AACA;;AACA9I,MAAI,CAAC+I,aAAL,GAAqB,EAArB,CApCwD,CAsCxD;;AACA/I,MAAI,CAACgJ,eAAL,GAAuB,EAAvB,CAvCwD,CA0CxD;AACA;;AACAhJ,MAAI,CAACiJ,UAAL,GAAkBvH,MAAM,CAAC7C,GAAzB,CA5CwD,CA8CxD;;AACAmB,MAAI,CAACkJ,eAAL,GAAuBjB,OAAO,CAACkB,cAA/B,CA/CwD,CAiDxD;AACA;AACA;;AACAnJ,MAAI,CAACoJ,gBAAL,GAAwB;AACtBrC,MAAE,EAAE/G,IAAI,CAAC+G,EADa;AAEtBsC,SAAK,EAAE,YAAY;AACjBrJ,UAAI,CAACqJ,KAAL;AACD,KAJqB;AAKtBC,WAAO,EAAE,UAAUC,EAAV,EAAc;AACrB,UAAIC,EAAE,GAAGnB,MAAM,CAACoB,eAAP,CAAuBF,EAAvB,EAA2B,6BAA3B,CAAT;;AACA,UAAIvJ,IAAI,CAACoI,OAAT,EAAkB;AAChBpI,YAAI,CAACgJ,eAAL,CAAqBtJ,IAArB,CAA0B8J,EAA1B;AACD,OAFD,MAEO;AACL;AACAnB,cAAM,CAACqB,KAAP,CAAaF,EAAb;AACD;AACF,KAbqB;AActBG,iBAAa,EAAE3J,IAAI,CAAC4J,cAAL,EAdO;AAetBC,eAAW,EAAE7J,IAAI,CAAC0B,MAAL,CAAYoI;AAfH,GAAxB;AAkBA9J,MAAI,CAACkC,IAAL,CAAU;AAAE6H,OAAG,EAAE,WAAP;AAAoBC,WAAO,EAAEhK,IAAI,CAAC+G;AAAlC,GAAV,EAtEwD,CAwExD;;AACAjD,OAAK,CAAC,YAAY;AAChB9D,QAAI,CAACiK,kBAAL;AACD,GAFI,CAAL,CAEGC,GAFH;;AAIA,MAAIlC,OAAO,KAAK,MAAZ,IAAsBC,OAAO,CAACkC,iBAAR,KAA8B,CAAxD,EAA2D;AACzD;AACAzI,UAAM,CAACC,mBAAP,CAA2B,CAA3B;AAEA3B,QAAI,CAACoK,SAAL,GAAiB,IAAIC,SAAS,CAACC,SAAd,CAAwB;AACvCH,uBAAiB,EAAElC,OAAO,CAACkC,iBADY;AAEvCI,sBAAgB,EAAEtC,OAAO,CAACsC,gBAFa;AAGvCC,eAAS,EAAE,YAAY;AACrBxK,YAAI,CAACqJ,KAAL;AACD,OALsC;AAMvCoB,cAAQ,EAAE,YAAY;AACpBzK,YAAI,CAACkC,IAAL,CAAU;AAAC6H,aAAG,EAAE;AAAN,SAAV;AACD;AARsC,KAAxB,CAAjB;AAUA/J,QAAI,CAACoK,SAAL,CAAeM,KAAf;AACD;;AAEDC,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CADD,CAAzB;AAED,CAhGD;;AAkGA5L,CAAC,CAACyD,MAAF,CAASqF,OAAO,CAACpF,SAAjB,EAA4B;AAE1BmI,WAAS,EAAE,UAAUC,eAAV,EAA2B;AACpC,QAAI/K,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeiB,UAAI,EAAED;AAArB,KAAV,EADF,KAEK;AACH9L,OAAC,CAACuD,IAAF,CAAOuI,eAAP,EAAwB,UAAUE,cAAV,EAA0B;AAChDjL,YAAI,CAAC+I,aAAL,CAAmBrJ,IAAnB,CAAwBuL,cAAxB;AACD,OAFD;AAGD;AACF,GAXyB;AAa1BC,WAAS,EAAE,UAAUlF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC/C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeoB,gBAAU,EAAEnF,cAA3B;AAA2Ce,QAAE,EAAEA,EAA/C;AAAmDM,YAAM,EAAEA;AAA3D,KAAV;AACH,GAjByB;AAmB1B+D,aAAW,EAAE,UAAUpF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AACjD,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIf,CAAC,CAACoH,OAAF,CAAUgB,MAAV,CAAJ,EACE;;AAEF,QAAIrH,IAAI,CAAC6I,UAAT,EAAqB;AACnB7I,UAAI,CAACkC,IAAL,CAAU;AACR6H,WAAG,EAAE,SADG;AAERoB,kBAAU,EAAEnF,cAFJ;AAGRe,UAAE,EAAEA,EAHI;AAIRM,cAAM,EAAEA;AAJA,OAAV;AAMD;AACF,GAhCyB;AAkC1BgE,aAAW,EAAE,UAAUrF,cAAV,EAA0Be,EAA1B,EAA8B;AACzC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,SAAN;AAAiBoB,gBAAU,EAAEnF,cAA7B;AAA6Ce,QAAE,EAAEA;AAAjD,KAAV;AACH,GAtCyB;AAwC1BuE,kBAAgB,EAAE,YAAY;AAC5B,QAAItL,IAAI,GAAG,IAAX;AACA,WAAO;AACLiH,WAAK,EAAEhI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACkL,SAAZ,EAAuBlL,IAAvB,CADF;AAELyH,aAAO,EAAExI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACoL,WAAZ,EAAyBpL,IAAzB,CAFJ;AAGLoH,aAAO,EAAEnI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACqL,WAAZ,EAAyBrL,IAAzB;AAHJ,KAAP;AAKD,GA/CyB;AAiD1BuL,mBAAiB,EAAE,UAAUvF,cAAV,EAA0B;AAC3C,QAAIhG,IAAI,GAAG,IAAX;AACA,QAAIsE,GAAG,GAAGtE,IAAI,CAAC4I,eAAL,CAAqB9D,GAArB,CAAyBkB,cAAzB,CAAV;;AACA,QAAI,CAAC1B,GAAL,EAAU;AACRA,SAAG,GAAG,IAAIyB,qBAAJ,CAA0BC,cAA1B,EAC4BhG,IAAI,CAACsL,gBAAL,EAD5B,CAAN;AAEAtL,UAAI,CAAC4I,eAAL,CAAqBhD,GAArB,CAAyBI,cAAzB,EAAyC1B,GAAzC;AACD;;AACD,WAAOA,GAAP;AACD,GA1DyB;AA4D1B2C,OAAK,EAAE,UAAUrC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AAC/D,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACvE,KAAL,CAAWrC,kBAAX,EAA+BmC,EAA/B,EAAmCM,MAAnC;AACD,GAhEyB;AAkE1BD,SAAO,EAAE,UAAUxC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkD;AACzD,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACpE,OAAL,CAAaxC,kBAAb,EAAiCmC,EAAjC;;AACA,QAAIyE,IAAI,CAACnF,OAAL,EAAJ,EAAoB;AACjBrG,UAAI,CAAC4I,eAAL,CAAqBvD,MAArB,CAA4BW,cAA5B;AACF;AACF,GAzEyB;AA2E1ByB,SAAO,EAAE,UAAU7C,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AACjE,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAAC/D,OAAL,CAAa7C,kBAAb,EAAiCmC,EAAjC,EAAqCM,MAArC;AACD,GA/EyB;AAiF1B4C,oBAAkB,EAAE,YAAY;AAC9B,QAAIjK,IAAI,GAAG,IAAX,CAD8B,CAE9B;AACA;AACA;;AACA,QAAIyL,QAAQ,GAAGxM,CAAC,CAACyG,KAAF,CAAQ1F,IAAI,CAACgB,MAAL,CAAY0K,0BAApB,CAAf;;AACAzM,KAAC,CAACuD,IAAF,CAAOiJ,QAAP,EAAiB,UAAUE,OAAV,EAAmB;AAClC3L,UAAI,CAAC4L,kBAAL,CAAwBD,OAAxB;AACD,KAFD;AAGD,GA1FyB;AA4F1B;AACAtC,OAAK,EAAE,YAAY;AACjB,QAAIrJ,IAAI,GAAG,IAAX,CADiB,CAGjB;AACA;AACA;AAEA;;AACA,QAAI,CAAEA,IAAI,CAACoI,OAAX,EACE,OATe,CAWjB;;AACApI,QAAI,CAACoI,OAAL,GAAe,IAAf;AACApI,QAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;;AAEA,QAAInE,IAAI,CAACoK,SAAT,EAAoB;AAClBpK,UAAI,CAACoK,SAAL,CAAeyB,IAAf;AACA7L,UAAI,CAACoK,SAAL,GAAiB,IAAjB;AACD;;AAED,QAAIpK,IAAI,CAAC0B,MAAT,EAAiB;AACf1B,UAAI,CAAC0B,MAAL,CAAY2H,KAAZ;AACArJ,UAAI,CAAC0B,MAAL,CAAYoK,cAAZ,GAA6B,IAA7B;AACD;;AAEDnB,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CAAC,CADF,CAAzB;AAGAxC,UAAM,CAACqB,KAAP,CAAa,YAAY;AACvB;AACA;AACA;AACA1J,UAAI,CAAC+L,2BAAL,GAJuB,CAMvB;AACA;;;AACA9M,OAAC,CAACuD,IAAF,CAAOxC,IAAI,CAACgJ,eAAZ,EAA6B,UAAUvG,QAAV,EAAoB;AAC/CA,gBAAQ;AACT,OAFD;AAGD,KAXD,EA5BiB,CAyCjB;;AACAzC,QAAI,CAACgB,MAAL,CAAYgL,cAAZ,CAA2BhM,IAA3B;AACD,GAxIyB;AA0I1B;AACA;AACAkC,MAAI,EAAE,UAAU6H,GAAV,EAAe;AACnB,QAAI/J,IAAI,GAAG,IAAX;;AACA,QAAIA,IAAI,CAAC0B,MAAT,EAAiB;AACf,UAAI2G,MAAM,CAAC4D,aAAX,EACE5D,MAAM,CAAC6D,MAAP,CAAc,UAAd,EAA0B7B,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAA1B;AACF/J,UAAI,CAAC0B,MAAL,CAAYQ,IAAZ,CAAiBmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAjB;AACD;AACF,GAnJyB;AAqJ1B;AACAqC,WAAS,EAAE,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAC7C,QAAItM,IAAI,GAAG,IAAX;AACA,QAAI+J,GAAG,GAAG;AAACA,SAAG,EAAE,OAAN;AAAesC,YAAM,EAAEA;AAAvB,KAAV;AACA,QAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACFtM,QAAI,CAACkC,IAAL,CAAU6H,GAAV;AACD,GA5JyB;AA8J1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAwC,gBAAc,EAAE,UAAUC,MAAV,EAAkB;AAChC,QAAIxM,IAAI,GAAG,IAAX;AACA,QAAI,CAACA,IAAI,CAACoI,OAAV,EAAmB;AACjB,aAH8B,CAKhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAIpI,IAAI,CAACoK,SAAT,EAAoB;AAClBtG,WAAK,CAAC,YAAY;AAChB9D,YAAI,CAACoK,SAAL,CAAeqC,eAAf;AACD,OAFI,CAAL,CAEGvC,GAFH;AAGD;;AAED,QAAIlK,IAAI,CAACgI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD,UAAI/J,IAAI,CAACkJ,eAAT,EACElJ,IAAI,CAACkC,IAAL,CAAU;AAAC6H,WAAG,EAAE,MAAN;AAAchD,UAAE,EAAEyF,MAAM,CAACzF;AAAzB,OAAV;AACF;AACD;;AACD,QAAI/G,IAAI,CAACgI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD;AACA;AACD;;AAED/J,QAAI,CAACoI,OAAL,CAAa1I,IAAb,CAAkB8M,MAAlB;AACA,QAAIxM,IAAI,CAACwI,aAAT,EACE;AACFxI,QAAI,CAACwI,aAAL,GAAqB,IAArB;;AAEA,QAAIkE,WAAW,GAAG,YAAY;AAC5B,UAAI3C,GAAG,GAAG/J,IAAI,CAACoI,OAAL,IAAgBpI,IAAI,CAACoI,OAAL,CAAauE,KAAb,EAA1B;;AACA,UAAI,CAAC5C,GAAL,EAAU;AACR/J,YAAI,CAACwI,aAAL,GAAqB,KAArB;AACA;AACD;;AAED1E,WAAK,CAAC,YAAY;AAChB,YAAIyE,OAAO,GAAG,IAAd;;AAEA,YAAIqE,OAAO,GAAG,YAAY;AACxB,cAAI,CAACrE,OAAL,EACE,OAFsB,CAEd;;AACVA,iBAAO,GAAG,KAAV;AACAmE,qBAAW;AACZ,SALD;;AAOA1M,YAAI,CAACgB,MAAL,CAAY6L,aAAZ,CAA0BrK,IAA1B,CAA+B,UAAUC,QAAV,EAAoB;AACjDA,kBAAQ,CAACsH,GAAD,EAAM/J,IAAN,CAAR;AACA,iBAAO,IAAP;AACD,SAHD;AAKA,YAAIf,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC8M,iBAAX,EAA8B/C,GAAG,CAACA,GAAlC,CAAJ,EACE/J,IAAI,CAAC8M,iBAAL,CAAuB/C,GAAG,CAACA,GAA3B,EAAgCgD,IAAhC,CAAqC/M,IAArC,EAA2C+J,GAA3C,EAAgD6C,OAAhD,EADF,KAGE5M,IAAI,CAACoM,SAAL,CAAe,aAAf,EAA8BrC,GAA9B;AACF6C,eAAO,GAnBS,CAmBL;AACZ,OApBI,CAAL,CAoBG1C,GApBH;AAqBD,KA5BD;;AA8BAwC,eAAW;AACZ,GAlPyB;AAoP1BI,mBAAiB,EAAE;AACjBE,OAAG,EAAE,UAAUjD,GAAV,EAAe;AAClB,UAAI/J,IAAI,GAAG,IAAX,CADkB,CAGlB;;AACA,UAAI,OAAQ+J,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACkD,IAAZ,KAAsB,QADtB,IAEE,YAAYlD,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAF1B,EAE2D;AACzDnN,YAAI,CAACoM,SAAL,CAAe,wBAAf,EAAyCrC,GAAzC;AACA;AACD;;AAED,UAAI,CAAC/J,IAAI,CAACgB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAL,EAA6C;AAC3CjN,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,OADG;AACMhD,YAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,0BAAuCkC,GAAG,CAACkD,IAA3C;AAFC,SAAV;AAGA;AACD;;AAED,UAAIjN,IAAI,CAACyI,UAAL,CAAgB9C,GAAhB,CAAoBoE,GAAG,CAAChD,EAAxB,CAAJ,EACE;AACA;AACA;AACA,eAtBgB,CAwBlB;AACA;AACA;AACA;AACA;;AACA,UAAI4D,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,YAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,YAAIC,gBAAgB,GAAG;AACrB5E,gBAAM,EAAE3I,IAAI,CAAC2I,MADQ;AAErBgB,uBAAa,EAAE3J,IAAI,CAACoJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,cAAI,EAAE,cAHe;AAIrBP,cAAI,EAAElD,GAAG,CAACkD,IAJW;AAKrBQ,sBAAY,EAAEzN,IAAI,CAAC+G;AALE,SAAvB;;AAQAuG,sBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,YAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,YAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5B7N,cAAI,CAACkC,IAAL,CAAU;AACR6H,eAAG,EAAE,OADG;AACMhD,cAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,iBAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK;AAFC,WAAV;AAOA;AACD;AACF;;AAED,UAAIpC,OAAO,GAAG3L,IAAI,CAACgB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAd;;AAEAjN,UAAI,CAAC4L,kBAAL,CAAwBD,OAAxB,EAAiC5B,GAAG,CAAChD,EAArC,EAAyCgD,GAAG,CAACmD,MAA7C,EAAqDnD,GAAG,CAACkD,IAAzD;AAED,KA1DgB;AA4DjBe,SAAK,EAAE,UAAUjE,GAAV,EAAe;AACpB,UAAI/J,IAAI,GAAG,IAAX;;AAEAA,UAAI,CAACiO,iBAAL,CAAuBlE,GAAG,CAAChD,EAA3B;AACD,KAhEgB;AAkEjBmH,UAAM,EAAE,UAAUnE,GAAV,EAAe6C,OAAf,EAAwB;AAC9B,UAAI5M,IAAI,GAAG,IAAX,CAD8B,CAG9B;AACA;AACA;;AACA,UAAI,OAAQ+J,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACmE,MAAZ,KAAwB,QADxB,IAEE,YAAYnE,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAFtB,IAGE,gBAAgBpD,GAAjB,IAA0B,OAAOA,GAAG,CAACoE,UAAX,KAA0B,QAHzD,EAGqE;AACnEnO,YAAI,CAACoM,SAAL,CAAe,6BAAf,EAA8CrC,GAA9C;AACA;AACD;;AAED,UAAIoE,UAAU,GAAGpE,GAAG,CAACoE,UAAJ,IAAkB,IAAnC,CAd8B,CAgB9B;AACA;AACA;;AACA,UAAIC,KAAK,GAAG,IAAIvK,SAAS,CAACwK,WAAd,EAAZ;AACAD,WAAK,CAACE,cAAN,CAAqB,YAAY;AAC/B;AACA;AACA;AACA;AACA;AACAF,aAAK,CAACG,MAAN;AACAvO,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,SADG;AACQyE,iBAAO,EAAE,CAACzE,GAAG,CAAChD,EAAL;AADjB,SAAV;AAED,OATD,EApB8B,CA+B9B;;AACA,UAAI4E,OAAO,GAAG3L,IAAI,CAACgB,MAAL,CAAYyN,eAAZ,CAA4B1E,GAAG,CAACmE,MAAhC,CAAd;;AACA,UAAI,CAACvC,OAAL,EAAc;AACZ3L,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,QADG;AACOhD,YAAE,EAAEgD,GAAG,CAAChD,EADf;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCkC,GAAG,CAACmE,MAArC;AAFC,SAAV;AAGAE,aAAK,CAACM,GAAN;AACA;AACD;;AAED,UAAIC,SAAS,GAAG,UAAShG,MAAT,EAAiB;AAC/B3I,YAAI,CAAC4O,UAAL,CAAgBjG,MAAhB;AACD,OAFD;;AAIA,UAAIkG,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,oBAAY,EAAE,KADgC;AAE9CpG,cAAM,EAAE3I,IAAI,CAAC2I,MAFiC;AAG9CgG,iBAAS,EAAEA,SAHmC;AAI9C/B,eAAO,EAAEA,OAJqC;AAK9C5K,kBAAU,EAAEhC,IAAI,CAACoJ,gBAL6B;AAM9C+E,kBAAU,EAAEA;AANkC,OAA/B,CAAjB;AASA,YAAMa,OAAO,GAAG,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC/C;AACA;AACA;AACA;AACA,YAAIxE,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,cAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,cAAIC,gBAAgB,GAAG;AACrB5E,kBAAM,EAAE3I,IAAI,CAAC2I,MADQ;AAErBgB,yBAAa,EAAE3J,IAAI,CAACoJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,gBAAI,EAAE,QAHe;AAIrBP,gBAAI,EAAElD,GAAG,CAACmE,MAJW;AAKrBT,wBAAY,EAAEzN,IAAI,CAAC+G;AALE,WAAvB;;AAOAuG,wBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,cAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,cAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5BsB,kBAAM,CAAC,IAAI9G,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK,CAAD,CAAN;AAKA;AACD;AACF;;AAEDmB,eAAO,CAACrL,SAAS,CAACuL,kBAAV,CAA6BC,SAA7B,CACNjB,KADM,EAEN,MAAMkB,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACJR,UADI,EAEJ,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACP9E,GAAG,CAACmD,MADG,EAE5B,cAAcnD,GAAG,CAACmE,MAAlB,GAA2B,GAFC,CAF1B,CAFA,CAAD,CAAP;AAUD,OApCe,CAAhB;;AAsCA,eAASuB,MAAT,GAAkB;AAChBrB,aAAK,CAACM,GAAN;AACA9B,eAAO;AACR;;AAED,YAAM8C,OAAO,GAAG;AACd3F,WAAG,EAAE,QADS;AAEdhD,UAAE,EAAEgD,GAAG,CAAChD;AAFM,OAAhB;AAKAiI,aAAO,CAACW,IAAR,CAAcC,MAAD,IAAY;AACvBH,cAAM;;AACN,YAAIG,MAAM,KAAK5K,SAAf,EAA0B;AACxB0K,iBAAO,CAACE,MAAR,GAAiBA,MAAjB;AACD;;AACD5P,YAAI,CAACkC,IAAL,CAAUwN,OAAV;AACD,OAND,EAMIG,SAAD,IAAe;AAChBJ,cAAM;AACNC,eAAO,CAACrC,KAAR,GAAgByC,qBAAqB,CACnCD,SADmC,mCAET9F,GAAG,CAACmE,MAFK,OAArC;AAIAlO,YAAI,CAACkC,IAAL,CAAUwN,OAAV;AACD,OAbD;AAcD;AAtLgB,GApPO;AA6a1BK,UAAQ,EAAE,UAAUC,CAAV,EAAa;AACrB,QAAIhQ,IAAI,GAAG,IAAX;;AACAA,QAAI,CAACyI,UAAL,CAAgBlE,OAAhB,CAAwByL,CAAxB;;AACAhQ,QAAI,CAAC0I,cAAL,CAAoBnE,OAApB,CAA4ByL,CAA5B;AACD,GAjbyB;AAmb1BC,sBAAoB,EAAE,UAAUC,SAAV,EAAqB;AACzC,QAAIlQ,IAAI,GAAG,IAAX;AACAyG,gBAAY,CAACC,QAAb,CAAsBwJ,SAAtB,EAAiClQ,IAAI,CAAC4I,eAAtC,EAAuD;AACrDjC,UAAI,EAAE,UAAUX,cAAV,EAA0BmK,SAA1B,EAAqCC,UAArC,EAAiD;AACrDA,kBAAU,CAAC7J,IAAX,CAAgB4J,SAAhB;AACD,OAHoD;AAIrDrJ,eAAS,EAAE,UAAUd,cAAV,EAA0BoK,UAA1B,EAAsC;AAC/CA,kBAAU,CAAClK,SAAX,CAAqB3B,OAArB,CAA6B,UAAUmD,OAAV,EAAmBX,EAAnB,EAAuB;AAClD/G,cAAI,CAACkL,SAAL,CAAelF,cAAf,EAA+Be,EAA/B,EAAmCW,OAAO,CAACrD,SAAR,EAAnC;AACD,SAFD;AAGD,OARoD;AASrD6C,cAAQ,EAAE,UAAUlB,cAAV,EAA0BmK,SAA1B,EAAqC;AAC7CA,iBAAS,CAACjK,SAAV,CAAoB3B,OAApB,CAA4B,UAAU8L,GAAV,EAAetJ,EAAf,EAAmB;AAC7C/G,cAAI,CAACqL,WAAL,CAAiBrF,cAAjB,EAAiCe,EAAjC;AACD,SAFD;AAGD;AAboD,KAAvD;AAeD,GApcyB;AAsc1B;AACA;AACA6H,YAAU,EAAE,UAASjG,MAAT,EAAiB;AAC3B,QAAI3I,IAAI,GAAG,IAAX;AAEA,QAAI2I,MAAM,KAAK,IAAX,IAAmB,OAAOA,MAAP,KAAkB,QAAzC,EACE,MAAM,IAAId,KAAJ,CAAU,qDACA,OAAOc,MADjB,CAAN,CAJyB,CAO3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA3I,QAAI,CAAC8I,0BAAL,GAAkC,IAAlC,CAf2B,CAiB3B;AACA;;AACA9I,QAAI,CAAC+P,QAAL,CAAc,UAAU/C,GAAV,EAAe;AAC3BA,SAAG,CAACsD,WAAJ;AACD,KAFD,EAnB2B,CAuB3B;AACA;AACA;;;AACAtQ,QAAI,CAAC6I,UAAL,GAAkB,KAAlB;AACA,QAAIqH,SAAS,GAAGlQ,IAAI,CAAC4I,eAArB;AACA5I,QAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;AACAnE,QAAI,CAAC2I,MAAL,GAAcA,MAAd,CA7B2B,CA+B3B;AACA;AACA;AACA;;AACA2G,OAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CAAuCrK,SAAvC,EAAkD,YAAY;AAC5D;AACA,UAAIuL,YAAY,GAAGvQ,IAAI,CAACyI,UAAxB;AACAzI,UAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACAnE,UAAI,CAAC0I,cAAL,GAAsB,EAAtB;AAEA6H,kBAAY,CAAChM,OAAb,CAAqB,UAAUyI,GAAV,EAAe/B,cAAf,EAA+B;AAClD,YAAIuF,MAAM,GAAGxD,GAAG,CAACyD,SAAJ,EAAb;;AACAzQ,YAAI,CAACyI,UAAL,CAAgB7C,GAAhB,CAAoBqF,cAApB,EAAoCuF,MAApC,EAFkD,CAGlD;AACA;;;AACAA,cAAM,CAACE,WAAP;AACD,OAND,EAN4D,CAc5D;AACA;AACA;;AACA1Q,UAAI,CAAC8I,0BAAL,GAAkC,KAAlC;AACA9I,UAAI,CAACiK,kBAAL;AACD,KAnBD,EAnC2B,CAwD3B;AACA;AACA;;;AACA5B,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC3Q,UAAI,CAAC6I,UAAL,GAAkB,IAAlB;;AACA7I,UAAI,CAACiQ,oBAAL,CAA0BC,SAA1B;;AACA,UAAI,CAACjR,CAAC,CAACoH,OAAF,CAAUrG,IAAI,CAAC+I,aAAf,CAAL,EAAoC;AAClC/I,YAAI,CAAC8K,SAAL,CAAe9K,IAAI,CAAC+I,aAApB;AACA/I,YAAI,CAAC+I,aAAL,GAAqB,EAArB;AACD;AACF,KAPD;AAQD,GA3gByB;AA6gB1B6C,oBAAkB,EAAE,UAAUD,OAAV,EAAmBiF,KAAnB,EAA0B1D,MAA1B,EAAkCD,IAAlC,EAAwC;AAC1D,QAAIjN,IAAI,GAAG,IAAX;AAEA,QAAIgN,GAAG,GAAG,IAAI6D,YAAJ,CACR7Q,IADQ,EACF2L,OADE,EACOiF,KADP,EACc1D,MADd,EACsBD,IADtB,CAAV;AAEA,QAAI2D,KAAJ,EACE5Q,IAAI,CAACyI,UAAL,CAAgB7C,GAAhB,CAAoBgL,KAApB,EAA2B5D,GAA3B,EADF,KAGEhN,IAAI,CAAC0I,cAAL,CAAoBhJ,IAApB,CAAyBsN,GAAzB;;AAEFA,OAAG,CAAC0D,WAAJ;AACD,GAxhByB;AA0hB1B;AACAzC,mBAAiB,EAAE,UAAU2C,KAAV,EAAiBvD,KAAjB,EAAwB;AACzC,QAAIrN,IAAI,GAAG,IAAX;AAEA,QAAI8Q,OAAO,GAAG,IAAd;;AACA,QAAIF,KAAJ,EAAW;AACT,UAAIG,QAAQ,GAAG/Q,IAAI,CAACyI,UAAL,CAAgB3D,GAAhB,CAAoB8L,KAApB,CAAf;;AACA,UAAIG,QAAJ,EAAc;AACZD,eAAO,GAAGC,QAAQ,CAACC,KAAnB;;AACAD,gBAAQ,CAACE,mBAAT;;AACAF,gBAAQ,CAACT,WAAT;;AACAtQ,YAAI,CAACyI,UAAL,CAAgBpD,MAAhB,CAAuBuL,KAAvB;AACD;AACF;;AAED,QAAIM,QAAQ,GAAG;AAACnH,SAAG,EAAE,OAAN;AAAehD,QAAE,EAAE6J;AAAnB,KAAf;;AAEA,QAAIvD,KAAJ,EAAW;AACT6D,cAAQ,CAAC7D,KAAT,GAAiByC,qBAAqB,CACpCzC,KADoC,EAEpCyD,OAAO,GAAI,cAAcA,OAAd,GAAwB,MAAxB,GAAiCF,KAArC,GACF,iBAAiBA,KAHc,CAAtC;AAID;;AAED5Q,QAAI,CAACkC,IAAL,CAAUgP,QAAV;AACD,GAnjByB;AAqjB1B;AACA;AACAnF,6BAA2B,EAAE,YAAY;AACvC,QAAI/L,IAAI,GAAG,IAAX;;AAEAA,QAAI,CAACyI,UAAL,CAAgBlE,OAAhB,CAAwB,UAAUyI,GAAV,EAAejG,EAAf,EAAmB;AACzCiG,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAtQ,QAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;;AAEAnE,QAAI,CAAC0I,cAAL,CAAoBnE,OAApB,CAA4B,UAAUyI,GAAV,EAAe;AACzCA,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAtQ,QAAI,CAAC0I,cAAL,GAAsB,EAAtB;AACD,GAnkByB;AAqkB1B;AACA;AACA;AACAkB,gBAAc,EAAE,YAAY;AAC1B,QAAI5J,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAImR,kBAAkB,GAAGC,QAAQ,CAAC/R,OAAO,CAACC,GAAR,CAAY,sBAAZ,CAAD,CAAR,IAAiD,CAA1E;AAEA,QAAI6R,kBAAkB,KAAK,CAA3B,EACE,OAAOnR,IAAI,CAAC0B,MAAL,CAAY2P,aAAnB;AAEF,QAAIC,YAAY,GAAGtR,IAAI,CAAC0B,MAAL,CAAYoI,OAAZ,CAAoB,iBAApB,CAAnB;AACA,QAAI,CAAE7K,CAAC,CAACsS,QAAF,CAAWD,YAAX,CAAN,EACE,OAAO,IAAP;AACFA,gBAAY,GAAGA,YAAY,CAACE,IAAb,GAAoBC,KAApB,CAA0B,SAA1B,CAAf,CAlB0B,CAoB1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,QAAIN,kBAAkB,GAAG,CAArB,IAA0BA,kBAAkB,GAAGG,YAAY,CAACpM,MAAhE,EACE,OAAO,IAAP;AAEF,WAAOoM,YAAY,CAACA,YAAY,CAACpM,MAAb,GAAsBiM,kBAAvB,CAAnB;AACD;AAzmByB,CAA5B;AA4mBA;;AACA;;AACA;AAEA;AAEA;AACA;;AACA;;;;;;;;AAMA,IAAIN,YAAY,GAAG,UACf7G,OADe,EACN2B,OADM,EACGV,cADH,EACmBiC,MADnB,EAC2BD,IAD3B,EACiC;AAClD,MAAIjN,IAAI,GAAG,IAAX;AACAA,MAAI,CAAC8B,QAAL,GAAgBkI,OAAhB,CAFkD,CAEzB;;AAEzB;;;;;;;;AAOAhK,MAAI,CAACgC,UAAL,GAAkBgI,OAAO,CAACZ,gBAA1B,CAXkD,CAWN;;AAE5CpJ,MAAI,CAAC0R,QAAL,GAAgB/F,OAAhB,CAbkD,CAelD;;AACA3L,MAAI,CAAC2R,eAAL,GAAuB1G,cAAvB,CAhBkD,CAiBlD;;AACAjL,MAAI,CAACgR,KAAL,GAAa/D,IAAb;AAEAjN,MAAI,CAAC4R,OAAL,GAAe1E,MAAM,IAAI,EAAzB,CApBkD,CAsBlD;AACA;AACA;;AACA,MAAIlN,IAAI,CAAC2R,eAAT,EAA0B;AACxB3R,QAAI,CAAC6R,mBAAL,GAA2B,MAAM7R,IAAI,CAAC2R,eAAtC;AACD,GAFD,MAEO;AACL3R,QAAI,CAAC6R,mBAAL,GAA2B,MAAM3J,MAAM,CAACnB,EAAP,EAAjC;AACD,GA7BiD,CA+BlD;;;AACA/G,MAAI,CAAC8R,YAAL,GAAoB,KAApB,CAhCkD,CAkClD;;AACA9R,MAAI,CAAC+R,cAAL,GAAsB,EAAtB,CAnCkD,CAqClD;AACA;;AACA/R,MAAI,CAACgS,UAAL,GAAkB,IAAI7N,GAAJ,EAAlB,CAvCkD,CAyClD;;AACAnE,MAAI,CAACiS,MAAL,GAAc,KAAd,CA1CkD,CA4ClD;;AAEA;;;;;;;;AAOAjS,MAAI,CAAC2I,MAAL,GAAcqB,OAAO,CAACrB,MAAtB,CArDkD,CAuDlD;AACA;AACA;AAEA;AACA;AACA;AACA;;AAEA3I,MAAI,CAACkS,SAAL,GAAiB;AACfC,eAAW,EAAEC,OAAO,CAACD,WADN;AAEfE,WAAO,EAAED,OAAO,CAACC;AAFF,GAAjB;AAKA1H,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CADN,CAAzB;AAED,CAxED;;AA0EA5L,CAAC,CAACyD,MAAF,CAASmO,YAAY,CAAClO,SAAtB,EAAiC;AAC/B+N,aAAW,EAAE,YAAY;AACvB;AACA;AACA;AACA;AACA;AACA;AAEA,QAAI1Q,IAAI,GAAG,IAAX;;AACA,QAAI;AACF,UAAIsS,GAAG,GAAGhD,GAAG,CAACiD,6BAAJ,CAAkClD,SAAlC,CACRrP,IADQ,EAER,MAAMwP,wBAAwB,CAC5BxP,IAAI,CAAC0R,QADuB,EACb1R,IADa,EACPsF,KAAK,CAACI,KAAN,CAAY1F,IAAI,CAAC4R,OAAjB,CADO,EAE5B;AACA;AACA;AACA,sBAAgB5R,IAAI,CAACgR,KAArB,GAA6B,GALD,CAFtB,CAAV;AAUD,KAXD,CAWE,OAAOwB,CAAP,EAAU;AACVxS,UAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD,KAvBsB,CAyBvB;;;AACA,QAAIxS,IAAI,CAACyS,cAAL,EAAJ,EACE;;AAEFzS,QAAI,CAAC0S,qBAAL,CAA2BJ,GAA3B;AACD,GA/B8B;AAiC/BI,uBAAqB,EAAE,UAAUJ,GAAV,EAAe;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,QAAItS,IAAI,GAAG,IAAX;;AACA,QAAI2S,QAAQ,GAAG,UAAUC,CAAV,EAAa;AAC1B,aAAOA,CAAC,IAAIA,CAAC,CAACC,cAAd;AACD,KAFD;;AAGA,QAAIF,QAAQ,CAACL,GAAD,CAAZ,EAAmB;AACjB,UAAI;AACFA,WAAG,CAACO,cAAJ,CAAmB7S,IAAnB;AACD,OAFD,CAEE,OAAOwS,CAAP,EAAU;AACVxS,YAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD,OANgB,CAOjB;AACA;;;AACAxS,UAAI,CAAC8S,KAAL;AACD,KAVD,MAUO,IAAI7T,CAAC,CAAC8T,OAAF,CAAUT,GAAV,CAAJ,EAAoB;AACzB;AACA,UAAI,CAAErT,CAAC,CAAC+T,GAAF,CAAMV,GAAN,EAAWK,QAAX,CAAN,EAA4B;AAC1B3S,YAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,mDAAV,CAAX;AACA;AACD,OALwB,CAMzB;AACA;AACA;;;AACA,UAAIoL,eAAe,GAAG,EAAtB;;AACA,WAAK,IAAIhO,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqN,GAAG,CAACpN,MAAxB,EAAgC,EAAED,CAAlC,EAAqC;AACnC,YAAIe,cAAc,GAAGsM,GAAG,CAACrN,CAAD,CAAH,CAAOiO,kBAAP,EAArB;;AACA,YAAIjU,CAAC,CAAC0G,GAAF,CAAMsN,eAAN,EAAuBjN,cAAvB,CAAJ,EAA4C;AAC1ChG,cAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CACT,+DACE7B,cAFO,CAAX;AAGA;AACD;;AACDiN,uBAAe,CAACjN,cAAD,CAAf,GAAkC,IAAlC;AACD;;AAAA;;AAED,UAAI;AACF/G,SAAC,CAACuD,IAAF,CAAO8P,GAAP,EAAY,UAAUa,GAAV,EAAe;AACzBA,aAAG,CAACN,cAAJ,CAAmB7S,IAAnB;AACD,SAFD;AAGD,OAJD,CAIE,OAAOwS,CAAP,EAAU;AACVxS,YAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD;;AACDxS,UAAI,CAAC8S,KAAL;AACD,KA9BM,MA8BA,IAAIR,GAAJ,EAAS;AACd;AACA;AACA;AACAtS,UAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,kDACE,qBADZ,CAAX;AAED;AACF,GAtG8B;AAwG/B;AACA;AACA;AACA;AACA;AACAyI,aAAW,EAAE,YAAW;AACtB,QAAItQ,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC8R,YAAT,EACE;AACF9R,QAAI,CAAC8R,YAAL,GAAoB,IAApB;;AACA9R,QAAI,CAACoT,kBAAL;;AACAzI,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CAAC,CADP,CAAzB;AAED,GArH8B;AAuH/BuI,oBAAkB,EAAE,YAAY;AAC9B,QAAIpT,IAAI,GAAG,IAAX,CAD8B,CAE9B;;AACA,QAAImG,SAAS,GAAGnG,IAAI,CAAC+R,cAArB;AACA/R,QAAI,CAAC+R,cAAL,GAAsB,EAAtB;;AACA9S,KAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkB,UAAU1D,QAAV,EAAoB;AACpCA,cAAQ;AACT,KAFD;AAGD,GA/H8B;AAiI/B;AACAwO,qBAAmB,EAAE,YAAY;AAC/B,QAAIjR,IAAI,GAAG,IAAX;;AACAqI,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC3Q,UAAI,CAACgS,UAAL,CAAgBzN,OAAhB,CAAwB,UAAU8O,cAAV,EAA0BrN,cAA1B,EAA0C;AAChEqN,sBAAc,CAAC9O,OAAf,CAAuB,UAAU+O,KAAV,EAAiB;AACtCtT,cAAI,CAACoH,OAAL,CAAapB,cAAb,EAA6BhG,IAAI,CAACkS,SAAL,CAAeG,OAAf,CAAuBiB,KAAvB,CAA7B;AACD,SAFD;AAGD,OAJD;AAKD,KAND;AAOD,GA3I8B;AA6I/B;AACA;AACA;AACA;AACA;AACA7C,WAAS,EAAE,YAAY;AACrB,QAAIzQ,IAAI,GAAG,IAAX;AACA,WAAO,IAAI6Q,YAAJ,CACL7Q,IAAI,CAAC8B,QADA,EACU9B,IAAI,CAAC0R,QADf,EACyB1R,IAAI,CAAC2R,eAD9B,EAC+C3R,IAAI,CAAC4R,OADpD,EAEL5R,IAAI,CAACgR,KAFA,CAAP;AAGD,GAvJ8B;;AAyJ/B;;;;;;;AAOA3D,OAAK,EAAE,UAAUA,KAAV,EAAiB;AACtB,QAAIrN,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;;AACFzS,QAAI,CAAC8B,QAAL,CAAcmM,iBAAd,CAAgCjO,IAAI,CAAC2R,eAArC,EAAsDtE,KAAtD;AACD,GArK8B;AAuK/B;AACA;AACA;AACA;;AAEA;;;;;;AAMAxB,MAAI,EAAE,YAAY;AAChB,QAAI7L,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;;AACFzS,QAAI,CAAC8B,QAAL,CAAcmM,iBAAd,CAAgCjO,IAAI,CAAC2R,eAArC;AACD,GAvL8B;;AAyL/B;;;;;;;AAOA4B,QAAM,EAAE,UAAU9Q,QAAV,EAAoB;AAC1B,QAAIzC,IAAI,GAAG,IAAX;AACAyC,YAAQ,GAAG4F,MAAM,CAACoB,eAAP,CAAuBhH,QAAvB,EAAiC,iBAAjC,EAAoDzC,IAApD,CAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACEhQ,QAAQ,GADV,KAGEzC,IAAI,CAAC+R,cAAL,CAAoBrS,IAApB,CAAyB+C,QAAzB;AACH,GAvM8B;AAyM/B;AACA;AACA;AACAgQ,gBAAc,EAAE,YAAY;AAC1B,QAAIzS,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC8R,YAAL,IAAqB9R,IAAI,CAAC8B,QAAL,CAAcsG,OAAd,KAA0B,IAAtD;AACD,GA/M8B;;AAiN/B;;;;;;;;;AASAnB,OAAK,EAAE,UAAUjB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC3C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA,QAAIyM,GAAG,GAAGxT,IAAI,CAACgS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,CAAV;;AACA,QAAIwN,GAAG,IAAI,IAAX,EAAiB;AACfA,SAAG,GAAG,IAAIvP,GAAJ,EAAN;;AACAjE,UAAI,CAACgS,UAAL,CAAgBpM,GAAhB,CAAoBI,cAApB,EAAoCwN,GAApC;AACD;;AACDA,OAAG,CAAC7L,GAAJ,CAAQZ,EAAR;;AACA/G,QAAI,CAAC8B,QAAL,CAAcmF,KAAd,CAAoBjH,IAAI,CAAC6R,mBAAzB,EAA8C7L,cAA9C,EAA8De,EAA9D,EAAkEM,MAAlE;AACD,GAtO8B;;AAwO/B;;;;;;;;;AASAI,SAAO,EAAE,UAAUzB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC7C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA/G,QAAI,CAAC8B,QAAL,CAAc2F,OAAd,CAAsBzH,IAAI,CAAC6R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE,EAAoEM,MAApE;AACD,GAvP8B;;AAyP/B;;;;;;;;AAQAD,SAAO,EAAE,UAAUpB,cAAV,EAA0Be,EAA1B,EAA8B;AACrC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL,CAJqC,CAKrC;AACA;;AACA/G,QAAI,CAACgS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,EAAoCX,MAApC,CAA2C0B,EAA3C;;AACA/G,QAAI,CAAC8B,QAAL,CAAcsF,OAAd,CAAsBpH,IAAI,CAAC6R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE;AACD,GA1Q8B;;AA4Q/B;;;;;;AAMA+L,OAAK,EAAE,YAAY;AACjB,QAAI9S,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF,QAAI,CAACzS,IAAI,CAAC2R,eAAV,EACE,OALe,CAKN;;AACX,QAAI,CAAC3R,IAAI,CAACiS,MAAV,EAAkB;AAChBjS,UAAI,CAAC8B,QAAL,CAAcgJ,SAAd,CAAwB,CAAC9K,IAAI,CAAC2R,eAAN,CAAxB;;AACA3R,UAAI,CAACiS,MAAL,GAAc,IAAd;AACD;AACF;AA5R8B,CAAjC;AA+RA;;AACA;;AACA;;;AAEAwB,MAAM,GAAG,UAAUxL,OAAV,EAAmB;AAC1B,MAAIjI,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACAA,MAAI,CAACiI,OAAL,GAAehJ,CAAC,CAACyU,QAAF,CAAWzL,OAAO,IAAI,EAAtB,EAA0B;AACvCkC,qBAAiB,EAAE,KADoB;AAEvCI,oBAAgB,EAAE,KAFqB;AAGvC;AACApB,kBAAc,EAAE;AAJuB,GAA1B,CAAf,CAV0B,CAiB1B;AACA;AACA;AACA;;AACAnJ,MAAI,CAAC2T,gBAAL,GAAwB,IAAIC,IAAJ,CAAS;AAC/BC,wBAAoB,EAAE;AADS,GAAT,CAAxB,CArB0B,CAyB1B;;AACA7T,MAAI,CAAC6M,aAAL,GAAqB,IAAI+G,IAAJ,CAAS;AAC5BC,wBAAoB,EAAE;AADM,GAAT,CAArB;AAIA7T,MAAI,CAACoN,gBAAL,GAAwB,EAAxB;AACApN,MAAI,CAAC0L,0BAAL,GAAkC,EAAlC;AAEA1L,MAAI,CAACyO,eAAL,GAAuB,EAAvB;AAEAzO,MAAI,CAAC8T,QAAL,GAAgB,IAAI3P,GAAJ,EAAhB,CAnC0B,CAmCC;;AAE3BnE,MAAI,CAAC+T,aAAL,GAAqB,IAAIhU,YAAJ,EAArB;AAEAC,MAAI,CAAC+T,aAAL,CAAmBnR,QAAnB,CAA4B,UAAUlB,MAAV,EAAkB;AAC5C;AACAA,UAAM,CAACoK,cAAP,GAAwB,IAAxB;;AAEA,QAAIM,SAAS,GAAG,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAClD,UAAIvC,GAAG,GAAG;AAACA,WAAG,EAAE,OAAN;AAAesC,cAAM,EAAEA;AAAvB,OAAV;AACA,UAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACF5K,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAZ;AACD,KALD;;AAOArI,UAAM,CAACD,EAAP,CAAU,MAAV,EAAkB,UAAUuS,OAAV,EAAmB;AACnC,UAAI3L,MAAM,CAAC4L,iBAAX,EAA8B;AAC5B5L,cAAM,CAAC6D,MAAP,CAAc,cAAd,EAA8B8H,OAA9B;AACD;;AACD,UAAI;AACF,YAAI;AACF,cAAIjK,GAAG,GAAGM,SAAS,CAAC6J,QAAV,CAAmBF,OAAnB,CAAV;AACD,SAFD,CAEE,OAAOlM,GAAP,EAAY;AACZsE,mBAAS,CAAC,aAAD,CAAT;AACA;AACD;;AACD,YAAIrC,GAAG,KAAK,IAAR,IAAgB,CAACA,GAAG,CAACA,GAAzB,EAA8B;AAC5BqC,mBAAS,CAAC,aAAD,EAAgBrC,GAAhB,CAAT;AACA;AACD;;AAED,YAAIA,GAAG,CAACA,GAAJ,KAAY,SAAhB,EAA2B;AACzB,cAAIrI,MAAM,CAACoK,cAAX,EAA2B;AACzBM,qBAAS,CAAC,mBAAD,EAAsBrC,GAAtB,CAAT;AACA;AACD;;AACDjG,eAAK,CAAC,YAAY;AAChB9D,gBAAI,CAACmU,cAAL,CAAoBzS,MAApB,EAA4BqI,GAA5B;AACD,WAFI,CAAL,CAEGG,GAFH;AAGA;AACD;;AAED,YAAI,CAACxI,MAAM,CAACoK,cAAZ,EAA4B;AAC1BM,mBAAS,CAAC,oBAAD,EAAuBrC,GAAvB,CAAT;AACA;AACD;;AACDrI,cAAM,CAACoK,cAAP,CAAsBS,cAAtB,CAAqCxC,GAArC;AACD,OA5BD,CA4BE,OAAOyI,CAAP,EAAU;AACV;AACAnK,cAAM,CAAC6D,MAAP,CAAc,6CAAd,EAA6DnC,GAA7D,EAAkEyI,CAAlE;AACD;AACF,KApCD;AAsCA9Q,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7B,UAAIC,MAAM,CAACoK,cAAX,EAA2B;AACzBhI,aAAK,CAAC,YAAY;AAChBpC,gBAAM,CAACoK,cAAP,CAAsBzC,KAAtB;AACD,SAFI,CAAL,CAEGa,GAFH;AAGD;AACF,KAND;AAOD,GAxDD;AAyDD,CAhGD;;AAkGAjL,CAAC,CAACyD,MAAF,CAAS+Q,MAAM,CAAC9Q,SAAhB,EAA2B;AAEzB;;;;;;;AAOAyR,cAAY,EAAE,UAAU7K,EAAV,EAAc;AAC1B,QAAIvJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC2T,gBAAL,CAAsB/Q,QAAtB,CAA+B2G,EAA/B,CAAP;AACD,GAZwB;;AAczB;;;;;;;AAOA8K,WAAS,EAAE,UAAU9K,EAAV,EAAc;AACvB,QAAIvJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC6M,aAAL,CAAmBjK,QAAnB,CAA4B2G,EAA5B,CAAP;AACD,GAxBwB;AA0BzB4K,gBAAc,EAAE,UAAUzS,MAAV,EAAkBqI,GAAlB,EAAuB;AACrC,QAAI/J,IAAI,GAAG,IAAX,CADqC,CAGrC;AACA;;AACA,QAAI,EAAE,OAAQ+J,GAAG,CAAC/B,OAAZ,KAAyB,QAAzB,IACA/I,CAAC,CAAC8T,OAAF,CAAUhJ,GAAG,CAACuK,OAAd,CADA,IAEArV,CAAC,CAAC+T,GAAF,CAAMjJ,GAAG,CAACuK,OAAV,EAAmBrV,CAAC,CAACsS,QAArB,CAFA,IAGAtS,CAAC,CAACsV,QAAF,CAAWxK,GAAG,CAACuK,OAAf,EAAwBvK,GAAG,CAAC/B,OAA5B,CAHF,CAAJ,EAG6C;AAC3CtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AACT/B,eAAO,EAAEqC,SAAS,CAACmK,sBAAV,CAAiC,CAAjC;AADA,OAAvB,CAAZ;AAEA9S,YAAM,CAAC2H,KAAP;AACA;AACD,KAboC,CAerC;AACA;;;AACA,QAAIrB,OAAO,GAAGyM,gBAAgB,CAAC1K,GAAG,CAACuK,OAAL,EAAcjK,SAAS,CAACmK,sBAAxB,CAA9B;;AAEA,QAAIzK,GAAG,CAAC/B,OAAJ,KAAgBA,OAApB,EAA6B;AAC3B;AACA;AACA;AACAtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AAAgB/B,eAAO,EAAEA;AAAzB,OAAvB,CAAZ;AACAtG,YAAM,CAAC2H,KAAP;AACA;AACD,KA1BoC,CA4BrC;AACA;AACA;;;AACA3H,UAAM,CAACoK,cAAP,GAAwB,IAAI/D,OAAJ,CAAY/H,IAAZ,EAAkBgI,OAAlB,EAA2BtG,MAA3B,EAAmC1B,IAAI,CAACiI,OAAxC,CAAxB;AACAjI,QAAI,CAAC8T,QAAL,CAAclO,GAAd,CAAkBlE,MAAM,CAACoK,cAAP,CAAsB/E,EAAxC,EAA4CrF,MAAM,CAACoK,cAAnD;AACA9L,QAAI,CAAC2T,gBAAL,CAAsBnR,IAAtB,CAA2B,UAAUC,QAAV,EAAoB;AAC7C,UAAIf,MAAM,CAACoK,cAAX,EACErJ,QAAQ,CAACf,MAAM,CAACoK,cAAP,CAAsB1C,gBAAvB,CAAR;AACF,aAAO,IAAP;AACD,KAJD;AAKD,GAhEwB;;AAiEzB;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;AAQAsL,SAAO,EAAE,UAAUzH,IAAV,EAAgBtB,OAAhB,EAAyB1D,OAAzB,EAAkC;AACzC,QAAIjI,IAAI,GAAG,IAAX;;AAEA,QAAI,CAAEf,CAAC,CAAC0V,QAAF,CAAW1H,IAAX,CAAN,EAAwB;AACtBhF,aAAO,GAAGA,OAAO,IAAI,EAArB;;AAEA,UAAIgF,IAAI,IAAIA,IAAI,IAAIjN,IAAI,CAACoN,gBAAzB,EAA2C;AACzC/E,cAAM,CAAC6D,MAAP,CAAc,uCAAuCe,IAAvC,GAA8C,GAA5D;;AACA;AACD;;AAED,UAAItC,OAAO,CAACiK,WAAR,IAAuB,CAAC3M,OAAO,CAAC4M,OAApC,EAA6C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAI,CAAC7U,IAAI,CAAC8U,wBAAV,EAAoC;AAClC9U,cAAI,CAAC8U,wBAAL,GAAgC,IAAhC;;AACAzM,gBAAM,CAAC6D,MAAP,CACN,0EACA,yEADA,GAEA,uEAFA,GAGA,yCAHA,GAIA,MAJA,GAKA,gEALA,GAMA,MANA,GAOA,oCAPA,GAQA,MARA,GASA,8EATA,GAUA,wDAXM;AAYD;AACF;;AAED,UAAIe,IAAJ,EACEjN,IAAI,CAACoN,gBAAL,CAAsBH,IAAtB,IAA8BtB,OAA9B,CADF,KAEK;AACH3L,YAAI,CAAC0L,0BAAL,CAAgChM,IAAhC,CAAqCiM,OAArC,EADG,CAEH;AACA;AACA;;AACA3L,YAAI,CAAC8T,QAAL,CAAcvP,OAAd,CAAsB,UAAUyF,OAAV,EAAmB;AACvC,cAAI,CAACA,OAAO,CAAClB,0BAAb,EAAyC;AACvChF,iBAAK,CAAC,YAAW;AACfkG,qBAAO,CAAC4B,kBAAR,CAA2BD,OAA3B;AACD,aAFI,CAAL,CAEGzB,GAFH;AAGD;AACF,SAND;AAOD;AACF,KAhDD,MAiDI;AACFjL,OAAC,CAACuD,IAAF,CAAOyK,IAAP,EAAa,UAASvI,KAAT,EAAgBD,GAAhB,EAAqB;AAChCzE,YAAI,CAAC0U,OAAL,CAAajQ,GAAb,EAAkBC,KAAlB,EAAyB,EAAzB;AACD,OAFD;AAGD;AACF,GAzJwB;AA2JzBsH,gBAAc,EAAE,UAAUhC,OAAV,EAAmB;AACjC,QAAIhK,IAAI,GAAG,IAAX;AACAA,QAAI,CAAC8T,QAAL,CAAczO,MAAd,CAAqB2E,OAAO,CAACjD,EAA7B;AACD,GA9JwB;;AAgKzB;;;;;;;AAOAyH,SAAO,EAAE,UAAUA,OAAV,EAAmB;AAC1B,QAAIxO,IAAI,GAAG,IAAX;;AACAf,KAAC,CAACuD,IAAF,CAAOgM,OAAP,EAAgB,UAAUuG,IAAV,EAAgB9H,IAAhB,EAAsB;AACpC,UAAI,OAAO8H,IAAP,KAAgB,UAApB,EACE,MAAM,IAAIlN,KAAJ,CAAU,aAAaoF,IAAb,GAAoB,sBAA9B,CAAN;AACF,UAAIjN,IAAI,CAACyO,eAAL,CAAqBxB,IAArB,CAAJ,EACE,MAAM,IAAIpF,KAAJ,CAAU,qBAAqBoF,IAArB,GAA4B,sBAAtC,CAAN;AACFjN,UAAI,CAACyO,eAAL,CAAqBxB,IAArB,IAA6B8H,IAA7B;AACD,KAND;AAOD,GAhLwB;AAkLzBhI,MAAI,EAAE,UAAUE,IAAV,EAAyB;AAAA,sCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAC7B,QAAIA,IAAI,CAAC4B,MAAL,IAAe,OAAO5B,IAAI,CAACA,IAAI,CAAC4B,MAAL,GAAc,CAAf,CAAX,KAAiC,UAApD,EAAgE;AAC9D;AACA;AACA,UAAIzC,QAAQ,GAAGa,IAAI,CAAC0R,GAAL,EAAf;AACD;;AAED,WAAO,KAAKpR,KAAL,CAAWqJ,IAAX,EAAiB3J,IAAjB,EAAuBb,QAAvB,CAAP;AACD,GA1LwB;AA4LzB;AACAwS,WAAS,EAAE,UAAUhI,IAAV,EAAyB;AAAA,uCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAClC,WAAO,KAAK4R,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,CAAP;AACD,GA/LwB;AAiMzBM,OAAK,EAAE,UAAUqJ,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+BxF,QAA/B,EAAyC;AAC9C;AACA;AACA,QAAI,CAAEA,QAAF,IAAc,OAAOwF,OAAP,KAAmB,UAArC,EAAiD;AAC/CxF,cAAQ,GAAGwF,OAAX;AACAA,aAAO,GAAG,EAAV;AACD,KAHD,MAGO;AACLA,aAAO,GAAGA,OAAO,IAAI,EAArB;AACD;;AAED,UAAM+G,OAAO,GAAG,KAAKkG,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,EAA4B2E,OAA5B,CAAhB,CAV8C,CAY9C;AACA;AACA;AACA;AACA;;AACA,QAAIxF,QAAJ,EAAc;AACZuM,aAAO,CAACW,IAAR,CACEC,MAAM,IAAInN,QAAQ,CAACuC,SAAD,EAAY4K,MAAZ,CADpB,EAEEC,SAAS,IAAIpN,QAAQ,CAACoN,SAAD,CAFvB;AAID,KALD,MAKO;AACL,aAAOb,OAAO,CAACmG,KAAR,EAAP;AACD;AACF,GA1NwB;AA4NzB;AACAD,YAAU,EAAE,UAAUjI,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+B;AACzC;AACA,QAAI0D,OAAO,GAAG,KAAK8C,eAAL,CAAqBxB,IAArB,CAAd;;AACA,QAAI,CAAEtB,OAAN,EAAe;AACb,aAAOsD,OAAO,CAACE,MAAR,CACL,IAAI9G,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCoF,IAAjC,iBADK,CAAP;AAGD,KAPwC,CASzC;AACA;AACA;;;AACA,QAAItE,MAAM,GAAG,IAAb;;AACA,QAAIgG,SAAS,GAAG,YAAW;AACzB,YAAM,IAAI9G,KAAJ,CAAU,wDAAV,CAAN;AACD,KAFD;;AAGA,QAAI7F,UAAU,GAAG,IAAjB;;AACA,QAAIoT,uBAAuB,GAAG9F,GAAG,CAACC,wBAAJ,CAA6BzK,GAA7B,EAA9B;;AACA,QAAIuQ,4BAA4B,GAAG/F,GAAG,CAACiD,6BAAJ,CAAkCzN,GAAlC,EAAnC;;AACA,QAAIqJ,UAAU,GAAG,IAAjB;;AACA,QAAIiH,uBAAJ,EAA6B;AAC3BzM,YAAM,GAAGyM,uBAAuB,CAACzM,MAAjC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3ByM,+BAAuB,CAACzG,SAAxB,CAAkChG,MAAlC;AACD,OAFD;;AAGA3G,gBAAU,GAAGoT,uBAAuB,CAACpT,UAArC;AACAmM,gBAAU,GAAG9D,SAAS,CAACiL,WAAV,CAAsBF,uBAAtB,EAA+CnI,IAA/C,CAAb;AACD,KAPD,MAOO,IAAIoI,4BAAJ,EAAkC;AACvC1M,YAAM,GAAG0M,4BAA4B,CAAC1M,MAAtC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3B0M,oCAA4B,CAACvT,QAA7B,CAAsC8M,UAAtC,CAAiDjG,MAAjD;AACD,OAFD;;AAGA3G,gBAAU,GAAGqT,4BAA4B,CAACrT,UAA1C;AACD;;AAED,QAAI6M,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,kBAAY,EAAE,KADgC;AAE9CpG,YAF8C;AAG9CgG,eAH8C;AAI9C3M,gBAJ8C;AAK9CmM;AAL8C,KAA/B,CAAjB;AAQA,WAAO,IAAIc,OAAJ,CAAYC,OAAO,IAAIA,OAAO,CACnCI,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACER,UADF,EAEE,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACPvJ,KAAK,CAACI,KAAN,CAAYpC,IAAZ,CADO,EAE5B,uBAAuB2J,IAAvB,GAA8B,GAFF,CAFhC,CADmC,CAA9B,EAQJ0C,IARI,CAQCrK,KAAK,CAACI,KARP,CAAP;AASD,GAjRwB;AAmRzB6P,gBAAc,EAAE,UAAUC,SAAV,EAAqB;AACnC,QAAIxV,IAAI,GAAG,IAAX;AACA,QAAIgK,OAAO,GAAGhK,IAAI,CAAC8T,QAAL,CAAchP,GAAd,CAAkB0Q,SAAlB,CAAd;AACA,QAAIxL,OAAJ,EACE,OAAOA,OAAO,CAACf,UAAf,CADF,KAGE,OAAO,IAAP;AACH;AA1RwB,CAA3B;;AA6RA,IAAIwL,gBAAgB,GAAG,UAAUgB,uBAAV,EACUC,uBADV,EACmC;AACxD,MAAIC,cAAc,GAAG1W,CAAC,CAAC6G,IAAF,CAAO2P,uBAAP,EAAgC,UAAUzN,OAAV,EAAmB;AACtE,WAAO/I,CAAC,CAACsV,QAAF,CAAWmB,uBAAX,EAAoC1N,OAApC,CAAP;AACD,GAFoB,CAArB;;AAGA,MAAI,CAAC2N,cAAL,EAAqB;AACnBA,kBAAc,GAAGD,uBAAuB,CAAC,CAAD,CAAxC;AACD;;AACD,SAAOC,cAAP;AACD,CATD;;AAWA9R,SAAS,CAAC+R,iBAAV,GAA8BnB,gBAA9B,C,CAGA;AACA;;AACA,IAAI3E,qBAAqB,GAAG,UAAUD,SAAV,EAAqBgG,OAArB,EAA8B;AACxD,MAAI,CAAChG,SAAL,EAAgB,OAAOA,SAAP,CADwC,CAGxD;AACA;AACA;;AACA,MAAIA,SAAS,CAACiG,YAAd,EAA4B;AAC1B,QAAI,EAAEjG,SAAS,YAAYxH,MAAM,CAACR,KAA9B,CAAJ,EAA0C;AACxC,YAAMkO,eAAe,GAAGlG,SAAS,CAACmG,OAAlC;AACAnG,eAAS,GAAG,IAAIxH,MAAM,CAACR,KAAX,CAAiBgI,SAAS,CAACxC,KAA3B,EAAkCwC,SAAS,CAACxD,MAA5C,EAAoDwD,SAAS,CAACoG,OAA9D,CAAZ;AACApG,eAAS,CAACmG,OAAV,GAAoBD,eAApB;AACD;;AACD,WAAOlG,SAAP;AACD,GAbuD,CAexD;AACA;;;AACA,MAAI,CAACA,SAAS,CAACqG,eAAf,EAAgC;AAC9B7N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAA7B,EAAsChG,SAAS,CAACsG,KAAhD;;AACA,QAAItG,SAAS,CAACuG,cAAd,EAA8B;AAC5B/N,YAAM,CAAC6D,MAAP,CAAc,0CAAd,EAA0D2D,SAAS,CAACuG,cAApE;;AACA/N,YAAM,CAAC6D,MAAP;AACD;AACF,GAvBuD,CAyBxD;AACA;AACA;AACA;;;AACA,MAAI2D,SAAS,CAACuG,cAAd,EAA8B;AAC5B,QAAIvG,SAAS,CAACuG,cAAV,CAAyBN,YAA7B,EACE,OAAOjG,SAAS,CAACuG,cAAjB;;AACF/N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAAf,GAAyB,kCAAzB,GACA,mDADd;AAED;;AAED,SAAO,IAAIxN,MAAM,CAACR,KAAX,CAAiB,GAAjB,EAAsB,uBAAtB,CAAP;AACD,CArCD,C,CAwCA;AACA;;;AACA,IAAI2H,wBAAwB,GAAG,UAAUQ,CAAV,EAAa6F,OAAb,EAAsBvS,IAAtB,EAA4B+S,WAA5B,EAAyC;AACtE/S,MAAI,GAAGA,IAAI,IAAI,EAAf;;AACA,MAAIqH,OAAO,CAAC,uBAAD,CAAX,EAAsC;AACpC,WAAO2L,KAAK,CAACC,gCAAN,CACLvG,CADK,EACF6F,OADE,EACOvS,IADP,EACa+S,WADb,CAAP;AAED;;AACD,SAAOrG,CAAC,CAACpM,KAAF,CAAQiS,OAAR,EAAiBvS,IAAjB,CAAP;AACD,CAPD,C;;;;;;;;;;;ACpuDA,IAAIkT,MAAM,GAAG1X,GAAG,CAACC,OAAJ,CAAY,eAAZ,CAAb,C,CAEA;AACA;AACA;AACA;;;AACA8E,SAAS,CAACwK,WAAV,GAAwB,YAAY;AAClC,MAAIrO,IAAI,GAAG,IAAX;AAEAA,MAAI,CAACyW,KAAL,GAAa,KAAb;AACAzW,MAAI,CAAC0W,KAAL,GAAa,KAAb;AACA1W,MAAI,CAAC2W,OAAL,GAAe,KAAf;AACA3W,MAAI,CAAC4W,kBAAL,GAA0B,CAA1B;AACA5W,MAAI,CAAC6W,qBAAL,GAA6B,EAA7B;AACA7W,MAAI,CAAC8W,oBAAL,GAA4B,EAA5B;AACD,CATD,C,CAWA;AACA;AACA;AACA;;;AACAjT,SAAS,CAACuL,kBAAV,GAA+B,IAAI/G,MAAM,CAAC0O,mBAAX,EAA/B;;AAEA9X,CAAC,CAACyD,MAAF,CAASmB,SAAS,CAACwK,WAAV,CAAsB1L,SAA/B,EAA0C;AACxC;AACA;AACA;AACA;AACA;AACAqU,YAAU,EAAE,YAAY;AACtB,QAAIhX,IAAI,GAAG,IAAX;AAEA,QAAIA,IAAI,CAAC2W,OAAT,EACE,OAAO;AAAEM,eAAS,EAAE,YAAY,CAAE;AAA3B,KAAP;AAEF,QAAIjX,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,uDAAV,CAAN;AAEF7H,QAAI,CAAC4W,kBAAL;AACA,QAAIK,SAAS,GAAG,KAAhB;AACA,WAAO;AACLA,eAAS,EAAE,YAAY;AACrB,YAAIA,SAAJ,EACE,MAAM,IAAIpP,KAAJ,CAAU,0CAAV,CAAN;AACFoP,iBAAS,GAAG,IAAZ;AACAjX,YAAI,CAAC4W,kBAAL;;AACA5W,YAAI,CAACkX,UAAL;AACD;AAPI,KAAP;AASD,GA1BuC;AA4BxC;AACA;AACAxI,KAAG,EAAE,YAAY;AACf,QAAI1O,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,KAAK6D,SAAS,CAACuL,kBAAV,CAA6BtK,GAA7B,EAAb,EACE,MAAM+C,KAAK,CAAC,6BAAD,CAAX;AACF7H,QAAI,CAACyW,KAAL,GAAa,IAAb;;AACAzW,QAAI,CAACkX,UAAL;AACD,GApCuC;AAsCxC;AACA;AACA;AACAC,cAAY,EAAE,UAAUpC,IAAV,EAAgB;AAC5B,QAAI/U,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF7H,QAAI,CAAC6W,qBAAL,CAA2BnX,IAA3B,CAAgCqV,IAAhC;AACD,GA/CuC;AAiDxC;AACAzG,gBAAc,EAAE,UAAUyG,IAAV,EAAgB;AAC9B,QAAI/U,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF7H,QAAI,CAAC8W,oBAAL,CAA0BpX,IAA1B,CAA+BqV,IAA/B;AACD,GAxDuC;AA0DxC;AACAqC,YAAU,EAAE,YAAY;AACtB,QAAIpX,IAAI,GAAG,IAAX;AACA,QAAIqX,MAAM,GAAG,IAAIb,MAAJ,EAAb;AACAxW,QAAI,CAACsO,cAAL,CAAoB,YAAY;AAC9B+I,YAAM,CAAC,QAAD,CAAN;AACD,KAFD;AAGArX,QAAI,CAAC0O,GAAL;AACA2I,UAAM,CAACC,IAAP;AACD,GAnEuC;AAqExCJ,YAAU,EAAE,YAAY;AACtB,QAAIlX,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gCAAV,CAAN;;AACF,QAAI7H,IAAI,CAACyW,KAAL,IAAc,CAACzW,IAAI,CAAC4W,kBAAxB,EAA4C;AAC1C,eAASW,cAAT,CAAyBxC,IAAzB,EAA+B;AAC7B,YAAI;AACFA,cAAI,CAAC/U,IAAD,CAAJ;AACD,SAFD,CAEE,OAAO8H,GAAP,EAAY;AACZO,gBAAM,CAAC6D,MAAP,CAAc,mCAAd,EAAmDpE,GAAnD;AACD;AACF;;AAED9H,UAAI,CAAC4W,kBAAL;;AACA,aAAO5W,IAAI,CAAC6W,qBAAL,CAA2B3R,MAA3B,GAAoC,CAA3C,EAA8C;AAC5C,YAAIiB,SAAS,GAAGnG,IAAI,CAAC6W,qBAArB;AACA7W,YAAI,CAAC6W,qBAAL,GAA6B,EAA7B;;AACA5X,SAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkBoR,cAAlB;AACD;;AACDvX,UAAI,CAAC4W,kBAAL;;AAEA,UAAI,CAAC5W,IAAI,CAAC4W,kBAAV,EAA8B;AAC5B5W,YAAI,CAAC0W,KAAL,GAAa,IAAb;AACA,YAAIvQ,SAAS,GAAGnG,IAAI,CAAC8W,oBAArB;AACA9W,YAAI,CAAC8W,oBAAL,GAA4B,EAA5B;;AACA7X,SAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkBoR,cAAlB;AACD;AACF;AACF,GAjGuC;AAmGxC;AACA;AACAhJ,QAAM,EAAE,YAAY;AAClB,QAAIvO,IAAI,GAAG,IAAX;AACA,QAAI,CAAEA,IAAI,CAAC0W,KAAX,EACE,MAAM,IAAI7O,KAAJ,CAAU,yCAAV,CAAN;AACF7H,QAAI,CAAC2W,OAAL,GAAe,IAAf;AACD;AA1GuC,CAA1C,E;;;;;;;;;;;ACvBA;AACA;AACA;AAEA9S,SAAS,CAAC2T,SAAV,GAAsB,UAAUvP,OAAV,EAAmB;AACvC,MAAIjI,IAAI,GAAG,IAAX;AACAiI,SAAO,GAAGA,OAAO,IAAI,EAArB;AAEAjI,MAAI,CAACyX,MAAL,GAAc,CAAd,CAJuC,CAKvC;AACA;AACA;;AACAzX,MAAI,CAAC0X,qBAAL,GAA6B,EAA7B;AACA1X,MAAI,CAAC2X,0BAAL,GAAkC,EAAlC;AACA3X,MAAI,CAAC4X,WAAL,GAAmB3P,OAAO,CAAC2P,WAAR,IAAuB,UAA1C;AACA5X,MAAI,CAAC6X,QAAL,GAAgB5P,OAAO,CAAC4P,QAAR,IAAoB,IAApC;AACD,CAZD;;AAcA5Y,CAAC,CAACyD,MAAF,CAASmB,SAAS,CAAC2T,SAAV,CAAoB7U,SAA7B,EAAwC;AACtC;AACAmV,uBAAqB,EAAE,UAAU/N,GAAV,EAAe;AACpC,QAAI/J,IAAI,GAAG,IAAX;;AACA,QAAI,CAAEf,CAAC,CAAC0G,GAAF,CAAMoE,GAAN,EAAW,YAAX,CAAN,EAAgC;AAC9B,aAAO,EAAP;AACD,KAFD,MAEO,IAAI,OAAOA,GAAG,CAACoB,UAAX,KAA2B,QAA/B,EAAyC;AAC9C,UAAIpB,GAAG,CAACoB,UAAJ,KAAmB,EAAvB,EACE,MAAMtD,KAAK,CAAC,+BAAD,CAAX;AACF,aAAOkC,GAAG,CAACoB,UAAX;AACD,KAJM,MAIA;AACL,YAAMtD,KAAK,CAAC,oCAAD,CAAX;AACD;AACF,GAbqC;AAetC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAkQ,QAAM,EAAE,UAAUC,OAAV,EAAmBvV,QAAnB,EAA6B;AACnC,QAAIzC,IAAI,GAAG,IAAX;AACA,QAAI+G,EAAE,GAAG/G,IAAI,CAACyX,MAAL,EAAT;;AAEA,QAAItM,UAAU,GAAGnL,IAAI,CAAC8X,qBAAL,CAA2BE,OAA3B,CAAjB;;AACA,QAAIC,MAAM,GAAG;AAACD,aAAO,EAAE1S,KAAK,CAACI,KAAN,CAAYsS,OAAZ,CAAV;AAAgCvV,cAAQ,EAAEA;AAA1C,KAAb;;AACA,QAAI,CAAExD,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC0X,qBAAX,EAAkCvM,UAAlC,CAAN,EAAqD;AACnDnL,UAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,IAAyC,EAAzC;AACAnL,UAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC,IAA8C,CAA9C;AACD;;AACDnL,QAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,EAAuCpE,EAAvC,IAA6CkR,MAA7C;AACAjY,QAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC;;AAEA,QAAInL,IAAI,CAAC6X,QAAL,IAAiBlN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,aAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE7K,IAAI,CAAC4X,WADP,EACoB5X,IAAI,CAAC6X,QADzB,EACmC,CADnC;AAED;;AAED,WAAO;AACLhM,UAAI,EAAE,YAAY;AAChB,YAAI7L,IAAI,CAAC6X,QAAL,IAAiBlN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,iBAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE7K,IAAI,CAAC4X,WADP,EACoB5X,IAAI,CAAC6X,QADzB,EACmC,CAAC,CADpC;AAED;;AACD,eAAO7X,IAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,EAAuCpE,EAAvC,CAAP;AACA/G,YAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC;;AACA,YAAInL,IAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC,MAAgD,CAApD,EAAuD;AACrD,iBAAOnL,IAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,CAAP;AACA,iBAAOnL,IAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC,CAAP;AACD;AACF;AAZI,KAAP;AAcD,GAzDqC;AA2DtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA+M,MAAI,EAAE,UAAUC,YAAV,EAAwB;AAC5B,QAAInY,IAAI,GAAG,IAAX;;AAEA,QAAImL,UAAU,GAAGnL,IAAI,CAAC8X,qBAAL,CAA2BK,YAA3B,CAAjB;;AAEA,QAAI,CAAElZ,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC0X,qBAAX,EAAkCvM,UAAlC,CAAN,EAAqD;AACnD;AACD;;AAED,QAAIiN,sBAAsB,GAAGpY,IAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,CAA7B;AACA,QAAIkN,WAAW,GAAG,EAAlB;;AACApZ,KAAC,CAACuD,IAAF,CAAO4V,sBAAP,EAA+B,UAAUE,CAAV,EAAavR,EAAb,EAAiB;AAC9C,UAAI/G,IAAI,CAACuY,QAAL,CAAcJ,YAAd,EAA4BG,CAAC,CAACN,OAA9B,CAAJ,EAA4C;AAC1CK,mBAAW,CAAC3Y,IAAZ,CAAiBqH,EAAjB;AACD;AACF,KAJD,EAX4B,CAiB5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA9H,KAAC,CAACuD,IAAF,CAAO6V,WAAP,EAAoB,UAAUtR,EAAV,EAAc;AAChC,UAAI9H,CAAC,CAAC0G,GAAF,CAAMyS,sBAAN,EAA8BrR,EAA9B,CAAJ,EAAuC;AACrCqR,8BAAsB,CAACrR,EAAD,CAAtB,CAA2BtE,QAA3B,CAAoC0V,YAApC;AACD;AACF,KAJD;AAKD,GAlGqC;AAoGtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAI,UAAQ,EAAE,UAAUJ,YAAV,EAAwBH,OAAxB,EAAiC;AACzC;AACA;AACA;AACA;AACA;AACA,QAAI,OAAOG,YAAY,CAACpR,EAApB,KAA4B,QAA5B,IACA,OAAOiR,OAAO,CAACjR,EAAf,KAAuB,QADvB,IAEAoR,YAAY,CAACpR,EAAb,KAAoBiR,OAAO,CAACjR,EAFhC,EAEoC;AAClC,aAAO,KAAP;AACD;;AACD,QAAIoR,YAAY,CAACpR,EAAb,YAA2BqL,OAAO,CAACoG,QAAnC,IACAR,OAAO,CAACjR,EAAR,YAAsBqL,OAAO,CAACoG,QAD9B,IAEA,CAAEL,YAAY,CAACpR,EAAb,CAAgBxB,MAAhB,CAAuByS,OAAO,CAACjR,EAA/B,CAFN,EAE0C;AACxC,aAAO,KAAP;AACD;;AAED,WAAO9H,CAAC,CAAC+T,GAAF,CAAMgF,OAAN,EAAe,UAAUS,YAAV,EAAwBhU,GAAxB,EAA6B;AACjD,aAAO,CAACxF,CAAC,CAAC0G,GAAF,CAAMwS,YAAN,EAAoB1T,GAApB,CAAD,IACLa,KAAK,CAACC,MAAN,CAAakT,YAAb,EAA2BN,YAAY,CAAC1T,GAAD,CAAvC,CADF;AAED,KAHM,CAAP;AAID;AA1IqC,CAAxC,E,CA6IA;AACA;AACA;AACA;AACA;;;AACAZ,SAAS,CAAC6U,qBAAV,GAAkC,IAAI7U,SAAS,CAAC2T,SAAd,CAAwB;AACxDK,UAAQ,EAAE;AAD8C,CAAxB,CAAlC,C;;;;;;;;;;;ACpKA,IAAIxY,OAAO,CAACC,GAAR,CAAYqZ,0BAAhB,EAA4C;AAC1C9Y,2BAAyB,CAAC8Y,0BAA1B,GACEtZ,OAAO,CAACC,GAAR,CAAYqZ,0BADd;AAED;;AAEDtQ,MAAM,CAACrH,MAAP,GAAgB,IAAIyS,MAAJ,EAAhB;;AAEApL,MAAM,CAACuQ,OAAP,GAAiB,UAAUT,YAAV,EAAwB;AACvCtU,WAAS,CAAC6U,qBAAV,CAAgCR,IAAhC,CAAqCC,YAArC;AACD,CAFD,C,CAIA;AACA;;;AACAlZ,CAAC,CAACuD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,EAAuB,MAAvB,EAA+B,OAA/B,EAAwC,cAAxC,EAAwD,WAAxD,CAAP,EACO,UAAUyK,IAAV,EAAgB;AACd5E,QAAM,CAAC4E,IAAD,CAAN,GAAehO,CAAC,CAAC2H,IAAF,CAAOyB,MAAM,CAACrH,MAAP,CAAciM,IAAd,CAAP,EAA4B5E,MAAM,CAACrH,MAAnC,CAAf;AACD,CAHR,E,CAKA;AACA;AACA;;;AACAqH,MAAM,CAACwQ,cAAP,GAAwBxQ,MAAM,CAACrH,MAA/B,C","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n  var extensions = [];\n\n  var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n        ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n  if (websocketCompressionConfig) {\n    extensions.push(Npm.require('permessage-deflate').configure(\n      websocketCompressionConfig\n    ));\n  }\n\n  return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX ||  \"\";\n\nStreamServer = function () {\n  var self = this;\n  self.registration_callbacks = [];\n  self.open_sockets = [];\n\n  // Because we are installing directly onto WebApp.httpServer instead of using\n  // WebApp.app, we have to process the path prefix ourselves.\n  self.prefix = pathPrefix + '/sockjs';\n  RoutePolicy.declare(self.prefix + '/', 'network');\n\n  // set up sockjs\n  var sockjs = Npm.require('sockjs');\n  var serverOptions = {\n    prefix: self.prefix,\n    log: function() {},\n    // this is the default, but we code it explicitly because we depend\n    // on it in stream_client:HEARTBEAT_TIMEOUT\n    heartbeat_delay: 45000,\n    // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n    // bound for that much time, SockJS might not notice that the user has\n    // reconnected because the timer (of disconnect_delay ms) can fire before\n    // SockJS processes the new connection. Eventually we'll fix this by not\n    // combining CPU-heavy processing with SockJS termination (eg a proxy which\n    // converts to Unix sockets) but for now, raise the delay.\n    disconnect_delay: 60 * 1000,\n    // Set the USE_JSESSIONID environment variable to enable setting the\n    // JSESSIONID cookie. This is useful for setting up proxies with\n    // session affinity.\n    jsessionid: !!process.env.USE_JSESSIONID\n  };\n\n  // If you know your server environment (eg, proxies) will prevent websockets\n  // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n  // browsers) will not waste time attempting to use them.\n  // (Your server will still have a /websocket endpoint.)\n  if (process.env.DISABLE_WEBSOCKETS) {\n    serverOptions.websocket = false;\n  } else {\n    serverOptions.faye_server_options = {\n      extensions: websocketExtensions()\n    };\n  }\n\n  self.server = sockjs.createServer(serverOptions);\n\n  // Install the sockjs handlers, but we want to keep around our own particular\n  // request handler that adjusts idle timeouts while we have an outstanding\n  // request.  This compensates for the fact that sockjs removes all listeners\n  // for \"request\" to add its own.\n  WebApp.httpServer.removeListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n  self.server.installHandlers(WebApp.httpServer);\n  WebApp.httpServer.addListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n\n  // Support the /websocket endpoint\n  self._redirectWebsocketEndpoint();\n\n  self.server.on('connection', function (socket) {\n    // We want to make sure that if a client connects to us and does the initial\n    // Websocket handshake but never gets to the DDP handshake, that we\n    // eventually kill the socket.  Once the DDP handshake happens, DDP\n    // heartbeating will work. And before the Websocket handshake, the timeouts\n    // we set at the server level in webapp_server.js will work. But\n    // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n    // is an \"in between\" state where this doesn't happen.  We work around this\n    // by explicitly setting the socket timeout to a relatively large time here,\n    // and setting it back to zero when we set up the heartbeat in\n    // livedata_server.js.\n    socket.setWebsocketTimeout = function (timeout) {\n      if ((socket.protocol === 'websocket' ||\n           socket.protocol === 'websocket-raw')\n          && socket._session.recv) {\n        socket._session.recv.connection.setTimeout(timeout);\n      }\n    };\n    socket.setWebsocketTimeout(45 * 1000);\n\n    socket.send = function (data) {\n      socket.write(data);\n    };\n    socket.on('close', function () {\n      self.open_sockets = _.without(self.open_sockets, socket);\n    });\n    self.open_sockets.push(socket);\n\n    // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n    // will force old clients to reload. Remove this once we're not\n    // concerned about people upgrading from a pre-0.7.0 release. Also,\n    // remove the clause in the client that ignores the welcome message\n    // (livedata_connection.js)\n    socket.send(JSON.stringify({server_id: \"0\"}));\n\n    // call all our callbacks when we get a new socket. they will do the\n    // work of setting up handlers and such for specific messages.\n    _.each(self.registration_callbacks, function (callback) {\n      callback(socket);\n    });\n  });\n\n};\n\n_.extend(StreamServer.prototype, {\n  // call my callback when a new socket connects.\n  // also call it for all current connections.\n  register: function (callback) {\n    var self = this;\n    self.registration_callbacks.push(callback);\n    _.each(self.all_sockets(), function (socket) {\n      callback(socket);\n    });\n  },\n\n  // get a list of all sockets\n  all_sockets: function () {\n    var self = this;\n    return _.values(self.open_sockets);\n  },\n\n  // Redirect /websocket to /sockjs/websocket in order to not expose\n  // sockjs to clients that want to use raw websockets\n  _redirectWebsocketEndpoint: function() {\n    var self = this;\n    // Unfortunately we can't use a connect middleware here since\n    // sockjs installs itself prior to all existing listeners\n    // (meaning prior to any connect middlewares) so we need to take\n    // an approach similar to overshadowListeners in\n    // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n    _.each(['request', 'upgrade'], function(event) {\n      var httpServer = WebApp.httpServer;\n      var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n      httpServer.removeAllListeners(event);\n\n      // request and upgrade have different arguments passed but\n      // we only care about the first one which is always request\n      var newListener = function(request /*, moreArguments */) {\n        // Store arguments for use within the closure below\n        var args = arguments;\n\n        // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n        // preserving query string.\n        var parsedUrl = url.parse(request.url);\n        if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n            parsedUrl.pathname === pathPrefix + '/websocket/') {\n          parsedUrl.pathname = self.prefix + '/websocket';\n          request.url = url.format(parsedUrl);\n        }\n        _.each(oldHttpServerListeners, function(oldListener) {\n          oldListener.apply(httpServer, args);\n        });\n      };\n      httpServer.addListener(event, newListener);\n    });\n  }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n  var self = this;\n  self.existsIn = new Set(); // set of subscriptionHandle\n  self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n  getFields: function () {\n    var self = this;\n    var ret = {};\n    self.dataByKey.forEach(function (precedenceList, key) {\n      ret[key] = precedenceList[0].value;\n    });\n    return ret;\n  },\n\n  clearField: function (subscriptionHandle, key, changeCollector) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n    var precedenceList = self.dataByKey.get(key);\n\n    // It's okay to clear fields that didn't exist. No need to throw\n    // an error.\n    if (!precedenceList)\n      return;\n\n    var removedValue = undefined;\n    for (var i = 0; i < precedenceList.length; i++) {\n      var precedence = precedenceList[i];\n      if (precedence.subscriptionHandle === subscriptionHandle) {\n        // The view's value can only change if this subscription is the one that\n        // used to have precedence.\n        if (i === 0)\n          removedValue = precedence.value;\n        precedenceList.splice(i, 1);\n        break;\n      }\n    }\n    if (precedenceList.length === 0) {\n      self.dataByKey.delete(key);\n      changeCollector[key] = undefined;\n    } else if (removedValue !== undefined &&\n               !EJSON.equals(removedValue, precedenceList[0].value)) {\n      changeCollector[key] = precedenceList[0].value;\n    }\n  },\n\n  changeField: function (subscriptionHandle, key, value,\n                         changeCollector, isAdd) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n\n    // Don't share state with the data passed in by the user.\n    value = EJSON.clone(value);\n\n    if (!self.dataByKey.has(key)) {\n      self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n                                value: value}]);\n      changeCollector[key] = value;\n      return;\n    }\n    var precedenceList = self.dataByKey.get(key);\n    var elt;\n    if (!isAdd) {\n      elt = precedenceList.find(function (precedence) {\n          return precedence.subscriptionHandle === subscriptionHandle;\n      });\n    }\n\n    if (elt) {\n      if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n        // this subscription is changing the value of this field.\n        changeCollector[key] = value;\n      }\n      elt.value = value;\n    } else {\n      // this subscription is newly caring about this field\n      precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n    }\n\n  }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n  var self = this;\n  self.collectionName = collectionName;\n  self.documents = new Map();\n  self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n  isEmpty: function () {\n    var self = this;\n    return self.documents.size === 0;\n  },\n\n  diff: function (previous) {\n    var self = this;\n    DiffSequence.diffMaps(previous.documents, self.documents, {\n      both: _.bind(self.diffDocument, self),\n\n      rightOnly: function (id, nowDV) {\n        self.callbacks.added(self.collectionName, id, nowDV.getFields());\n      },\n\n      leftOnly: function (id, prevDV) {\n        self.callbacks.removed(self.collectionName, id);\n      }\n    });\n  },\n\n  diffDocument: function (id, prevDV, nowDV) {\n    var self = this;\n    var fields = {};\n    DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n      both: function (key, prev, now) {\n        if (!EJSON.equals(prev, now))\n          fields[key] = now;\n      },\n      rightOnly: function (key, now) {\n        fields[key] = now;\n      },\n      leftOnly: function(key, prev) {\n        fields[key] = undefined;\n      }\n    });\n    self.callbacks.changed(self.collectionName, id, fields);\n  },\n\n  added: function (subscriptionHandle, id, fields) {\n    var self = this;\n    var docView = self.documents.get(id);\n    var added = false;\n    if (!docView) {\n      added = true;\n      docView = new SessionDocumentView();\n      self.documents.set(id, docView);\n    }\n    docView.existsIn.add(subscriptionHandle);\n    var changeCollector = {};\n    _.each(fields, function (value, key) {\n      docView.changeField(\n        subscriptionHandle, key, value, changeCollector, true);\n    });\n    if (added)\n      self.callbacks.added(self.collectionName, id, changeCollector);\n    else\n      self.callbacks.changed(self.collectionName, id, changeCollector);\n  },\n\n  changed: function (subscriptionHandle, id, changed) {\n    var self = this;\n    var changedResult = {};\n    var docView = self.documents.get(id);\n    if (!docView)\n      throw new Error(\"Could not find element with id \" + id + \" to change\");\n    _.each(changed, function (value, key) {\n      if (value === undefined)\n        docView.clearField(subscriptionHandle, key, changedResult);\n      else\n        docView.changeField(subscriptionHandle, key, value, changedResult);\n    });\n    self.callbacks.changed(self.collectionName, id, changedResult);\n  },\n\n  removed: function (subscriptionHandle, id) {\n    var self = this;\n    var docView = self.documents.get(id);\n    if (!docView) {\n      var err = new Error(\"Removed nonexistent document \" + id);\n      throw err;\n    }\n    docView.existsIn.delete(subscriptionHandle);\n    if (docView.existsIn.size === 0) {\n      // it is gone from everyone\n      self.callbacks.removed(self.collectionName, id);\n      self.documents.delete(id);\n    } else {\n      var changed = {};\n      // remove this subscription from every precedence list\n      // and record the changes\n      docView.dataByKey.forEach(function (precedenceList, key) {\n        docView.clearField(subscriptionHandle, key, changed);\n      });\n\n      self.callbacks.changed(self.collectionName, id, changed);\n    }\n  }\n});\n\n/******************************************************************************/\n/* Session                                                                    */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n  var self = this;\n  self.id = Random.id();\n\n  self.server = server;\n  self.version = version;\n\n  self.initialized = false;\n  self.socket = socket;\n\n  // set to null when the session is destroyed. multiple places below\n  // use this to determine if the session is alive or not.\n  self.inQueue = new Meteor._DoubleEndedQueue();\n\n  self.blocked = false;\n  self.workerRunning = false;\n\n  // Sub objects for active subscriptions\n  self._namedSubs = new Map();\n  self._universalSubs = [];\n\n  self.userId = null;\n\n  self.collectionViews = new Map();\n\n  // Set this to false to not send messages when collectionViews are\n  // modified. This is done when rerunning subs in _setUserId and those messages\n  // are calculated via a diff instead.\n  self._isSending = true;\n\n  // If this is true, don't start a newly-created universal publisher on this\n  // session. The session will take care of starting it when appropriate.\n  self._dontStartNewUniversalSubs = false;\n\n  // when we are rerunning subscriptions, any ready messages\n  // we want to buffer up for when we are done rerunning subscriptions\n  self._pendingReady = [];\n\n  // List of callbacks to call when this connection is closed.\n  self._closeCallbacks = [];\n\n\n  // XXX HACK: If a sockjs connection, save off the URL. This is\n  // temporary and will go away in the near future.\n  self._socketUrl = socket.url;\n\n  // Allow tests to disable responding to pings.\n  self._respondToPings = options.respondToPings;\n\n  // This object is the public interface to the session. In the public\n  // API, it is called the `connection` object.  Internally we call it\n  // a `connectionHandle` to avoid ambiguity.\n  self.connectionHandle = {\n    id: self.id,\n    close: function () {\n      self.close();\n    },\n    onClose: function (fn) {\n      var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n      if (self.inQueue) {\n        self._closeCallbacks.push(cb);\n      } else {\n        // if we're already closed, call the callback.\n        Meteor.defer(cb);\n      }\n    },\n    clientAddress: self._clientAddress(),\n    httpHeaders: self.socket.headers\n  };\n\n  self.send({ msg: 'connected', session: self.id });\n\n  // On initial connect, spin up all the universal publishers.\n  Fiber(function () {\n    self.startUniversalSubs();\n  }).run();\n\n  if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n    // We no longer need the low level timeout because we have heartbeating.\n    socket.setWebsocketTimeout(0);\n\n    self.heartbeat = new DDPCommon.Heartbeat({\n      heartbeatInterval: options.heartbeatInterval,\n      heartbeatTimeout: options.heartbeatTimeout,\n      onTimeout: function () {\n        self.close();\n      },\n      sendPing: function () {\n        self.send({msg: 'ping'});\n      }\n    });\n    self.heartbeat.start();\n  }\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n  sendReady: function (subscriptionIds) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"ready\", subs: subscriptionIds});\n    else {\n      _.each(subscriptionIds, function (subscriptionId) {\n        self._pendingReady.push(subscriptionId);\n      });\n    }\n  },\n\n  sendAdded: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n  },\n\n  sendChanged: function (collectionName, id, fields) {\n    var self = this;\n    if (_.isEmpty(fields))\n      return;\n\n    if (self._isSending) {\n      self.send({\n        msg: \"changed\",\n        collection: collectionName,\n        id: id,\n        fields: fields\n      });\n    }\n  },\n\n  sendRemoved: function (collectionName, id) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"removed\", collection: collectionName, id: id});\n  },\n\n  getSendCallbacks: function () {\n    var self = this;\n    return {\n      added: _.bind(self.sendAdded, self),\n      changed: _.bind(self.sendChanged, self),\n      removed: _.bind(self.sendRemoved, self)\n    };\n  },\n\n  getCollectionView: function (collectionName) {\n    var self = this;\n    var ret = self.collectionViews.get(collectionName);\n    if (!ret) {\n      ret = new SessionCollectionView(collectionName,\n                                        self.getSendCallbacks());\n      self.collectionViews.set(collectionName, ret);\n    }\n    return ret;\n  },\n\n  added: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.added(subscriptionHandle, id, fields);\n  },\n\n  removed: function (subscriptionHandle, collectionName, id) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.removed(subscriptionHandle, id);\n    if (view.isEmpty()) {\n       self.collectionViews.delete(collectionName);\n    }\n  },\n\n  changed: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.changed(subscriptionHandle, id, fields);\n  },\n\n  startUniversalSubs: function () {\n    var self = this;\n    // Make a shallow copy of the set of universal handlers and start them. If\n    // additional universal publishers start while we're running them (due to\n    // yielding), they will run separately as part of Server.publish.\n    var handlers = _.clone(self.server.universal_publish_handlers);\n    _.each(handlers, function (handler) {\n      self._startSubscription(handler);\n    });\n  },\n\n  // Destroy this session and unregister it at the server.\n  close: function () {\n    var self = this;\n\n    // Destroy this session, even if it's not registered at the\n    // server. Stop all processing and tear everything down. If a socket\n    // was attached, close it.\n\n    // Already destroyed.\n    if (! self.inQueue)\n      return;\n\n    // Drop the merge box data immediately.\n    self.inQueue = null;\n    self.collectionViews = new Map();\n\n    if (self.heartbeat) {\n      self.heartbeat.stop();\n      self.heartbeat = null;\n    }\n\n    if (self.socket) {\n      self.socket.close();\n      self.socket._meteorSession = null;\n    }\n\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"sessions\", -1);\n\n    Meteor.defer(function () {\n      // stop callbacks can yield, so we defer this on close.\n      // sub._isDeactivated() detects that we set inQueue to null and\n      // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n      self._deactivateAllSubscriptions();\n\n      // Defer calling the close callbacks, so that the caller closing\n      // the session isn't waiting for all the callbacks to complete.\n      _.each(self._closeCallbacks, function (callback) {\n        callback();\n      });\n    });\n\n    // Unregister the session.\n    self.server._removeSession(self);\n  },\n\n  // Send a message (doing nothing if no socket is connected right now.)\n  // It should be a JSON object (it will be stringified.)\n  send: function (msg) {\n    var self = this;\n    if (self.socket) {\n      if (Meteor._printSentDDP)\n        Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n      self.socket.send(DDPCommon.stringifyDDP(msg));\n    }\n  },\n\n  // Send a connection error.\n  sendError: function (reason, offendingMessage) {\n    var self = this;\n    var msg = {msg: 'error', reason: reason};\n    if (offendingMessage)\n      msg.offendingMessage = offendingMessage;\n    self.send(msg);\n  },\n\n  // Process 'msg' as an incoming message. (But as a guard against\n  // race conditions during reconnection, ignore the message if\n  // 'socket' is not the currently connected socket.)\n  //\n  // We run the messages from the client one at a time, in the order\n  // given by the client. The message handler is passed an idempotent\n  // function 'unblock' which it may call to allow other messages to\n  // begin running in parallel in another fiber (for example, a method\n  // that wants to yield.) Otherwise, it is automatically unblocked\n  // when it returns.\n  //\n  // Actually, we don't have to 'totally order' the messages in this\n  // way, but it's the easiest thing that's correct. (unsub needs to\n  // be ordered against sub, methods need to be ordered against each\n  // other.)\n  processMessage: function (msg_in) {\n    var self = this;\n    if (!self.inQueue) // we have been destroyed.\n      return;\n\n    // Respond to ping and pong messages immediately without queuing.\n    // If the negotiated DDP version is \"pre1\" which didn't support\n    // pings, preserve the \"pre1\" behavior of responding with a \"bad\n    // request\" for the unknown messages.\n    //\n    // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n    // needs a Fiber. We could actually use regular setTimeout and avoid\n    // these new fibers, but it is easier to just make everything use\n    // Meteor.setTimeout and not think too hard.\n    //\n    // Any message counts as receiving a pong, as it demonstrates that\n    // the client is still alive.\n    if (self.heartbeat) {\n      Fiber(function () {\n        self.heartbeat.messageReceived();\n      }).run();\n    }\n\n    if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n      if (self._respondToPings)\n        self.send({msg: \"pong\", id: msg_in.id});\n      return;\n    }\n    if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n      // Since everything is a pong, nothing to do\n      return;\n    }\n\n    self.inQueue.push(msg_in);\n    if (self.workerRunning)\n      return;\n    self.workerRunning = true;\n\n    var processNext = function () {\n      var msg = self.inQueue && self.inQueue.shift();\n      if (!msg) {\n        self.workerRunning = false;\n        return;\n      }\n\n      Fiber(function () {\n        var blocked = true;\n\n        var unblock = function () {\n          if (!blocked)\n            return; // idempotent\n          blocked = false;\n          processNext();\n        };\n\n        self.server.onMessageHook.each(function (callback) {\n          callback(msg, self);\n          return true;\n        });\n\n        if (_.has(self.protocol_handlers, msg.msg))\n          self.protocol_handlers[msg.msg].call(self, msg, unblock);\n        else\n          self.sendError('Bad request', msg);\n        unblock(); // in case the handler didn't already do it\n      }).run();\n    };\n\n    processNext();\n  },\n\n  protocol_handlers: {\n    sub: function (msg) {\n      var self = this;\n\n      // reject malformed messages\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.name) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array))) {\n        self.sendError(\"Malformed subscription\", msg);\n        return;\n      }\n\n      if (!self.server.publish_handlers[msg.name]) {\n        self.send({\n          msg: 'nosub', id: msg.id,\n          error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n        return;\n      }\n\n      if (self._namedSubs.has(msg.id))\n        // subs are idempotent, or rather, they are ignored if a sub\n        // with that id already exists. this is important during\n        // reconnect.\n        return;\n\n      // XXX It'd be much better if we had generic hooks where any package can\n      // hook into subscription handling, but in the mean while we special case\n      // ddp-rate-limiter package. This is also done for weak requirements to\n      // add the ddp-rate-limiter package in case we don't have Accounts. A\n      // user trying to use the ddp-rate-limiter must explicitly require it.\n      if (Package['ddp-rate-limiter']) {\n        var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n        var rateLimiterInput = {\n          userId: self.userId,\n          clientAddress: self.connectionHandle.clientAddress,\n          type: \"subscription\",\n          name: msg.name,\n          connectionId: self.id\n        };\n\n        DDPRateLimiter._increment(rateLimiterInput);\n        var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n        if (!rateLimitResult.allowed) {\n          self.send({\n            msg: 'nosub', id: msg.id,\n            error: new Meteor.Error(\n              'too-many-requests',\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset})\n          });\n          return;\n        }\n      }\n\n      var handler = self.server.publish_handlers[msg.name];\n\n      self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n    },\n\n    unsub: function (msg) {\n      var self = this;\n\n      self._stopSubscription(msg.id);\n    },\n\n    method: function (msg, unblock) {\n      var self = this;\n\n      // reject malformed messages\n      // For now, we silently ignore unknown attributes,\n      // for forwards compatibility.\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.method) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array)) ||\n          (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n        self.sendError(\"Malformed method invocation\", msg);\n        return;\n      }\n\n      var randomSeed = msg.randomSeed || null;\n\n      // set up to mark the method as satisfied once all observers\n      // (and subscriptions) have reacted to any writes that were\n      // done.\n      var fence = new DDPServer._WriteFence;\n      fence.onAllCommitted(function () {\n        // Retire the fence so that future writes are allowed.\n        // This means that callbacks like timers are free to use\n        // the fence, and if they fire before it's armed (for\n        // example, because the method waits for them) their\n        // writes will be included in the fence.\n        fence.retire();\n        self.send({\n          msg: 'updated', methods: [msg.id]});\n      });\n\n      // find the handler\n      var handler = self.server.method_handlers[msg.method];\n      if (!handler) {\n        self.send({\n          msg: 'result', id: msg.id,\n          error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n        fence.arm();\n        return;\n      }\n\n      var setUserId = function(userId) {\n        self._setUserId(userId);\n      };\n\n      var invocation = new DDPCommon.MethodInvocation({\n        isSimulation: false,\n        userId: self.userId,\n        setUserId: setUserId,\n        unblock: unblock,\n        connection: self.connectionHandle,\n        randomSeed: randomSeed\n      });\n\n      const promise = new Promise((resolve, reject) => {\n        // XXX It'd be better if we could hook into method handlers better but\n        // for now, we need to check if the ddp-rate-limiter exists since we\n        // have a weak requirement for the ddp-rate-limiter package to be added\n        // to our application.\n        if (Package['ddp-rate-limiter']) {\n          var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n          var rateLimiterInput = {\n            userId: self.userId,\n            clientAddress: self.connectionHandle.clientAddress,\n            type: \"method\",\n            name: msg.method,\n            connectionId: self.id\n          };\n          DDPRateLimiter._increment(rateLimiterInput);\n          var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n          if (!rateLimitResult.allowed) {\n            reject(new Meteor.Error(\n              \"too-many-requests\",\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset}\n            ));\n            return;\n          }\n        }\n\n        resolve(DDPServer._CurrentWriteFence.withValue(\n          fence,\n          () => DDP._CurrentMethodInvocation.withValue(\n            invocation,\n            () => maybeAuditArgumentChecks(\n              handler, invocation, msg.params,\n              \"call to '\" + msg.method + \"'\"\n            )\n          )\n        ));\n      });\n\n      function finish() {\n        fence.arm();\n        unblock();\n      }\n\n      const payload = {\n        msg: \"result\",\n        id: msg.id\n      };\n\n      promise.then((result) => {\n        finish();\n        if (result !== undefined) {\n          payload.result = result;\n        }\n        self.send(payload);\n      }, (exception) => {\n        finish();\n        payload.error = wrapInternalException(\n          exception,\n          `while invoking method '${msg.method}'`\n        );\n        self.send(payload);\n      });\n    }\n  },\n\n  _eachSub: function (f) {\n    var self = this;\n    self._namedSubs.forEach(f);\n    self._universalSubs.forEach(f);\n  },\n\n  _diffCollectionViews: function (beforeCVs) {\n    var self = this;\n    DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n      both: function (collectionName, leftValue, rightValue) {\n        rightValue.diff(leftValue);\n      },\n      rightOnly: function (collectionName, rightValue) {\n        rightValue.documents.forEach(function (docView, id) {\n          self.sendAdded(collectionName, id, docView.getFields());\n        });\n      },\n      leftOnly: function (collectionName, leftValue) {\n        leftValue.documents.forEach(function (doc, id) {\n          self.sendRemoved(collectionName, id);\n        });\n      }\n    });\n  },\n\n  // Sets the current user id in all appropriate contexts and reruns\n  // all subscriptions\n  _setUserId: function(userId) {\n    var self = this;\n\n    if (userId !== null && typeof userId !== \"string\")\n      throw new Error(\"setUserId must be called on string or null, not \" +\n                      typeof userId);\n\n    // Prevent newly-created universal subscriptions from being added to our\n    // session; they will be found below when we call startUniversalSubs.\n    //\n    // (We don't have to worry about named subscriptions, because we only add\n    // them when we process a 'sub' message. We are currently processing a\n    // 'method' message, and the method did not unblock, because it is illegal\n    // to call setUserId after unblock. Thus we cannot be concurrently adding a\n    // new named subscription.)\n    self._dontStartNewUniversalSubs = true;\n\n    // Prevent current subs from updating our collectionViews and call their\n    // stop callbacks. This may yield.\n    self._eachSub(function (sub) {\n      sub._deactivate();\n    });\n\n    // All subs should now be deactivated. Stop sending messages to the client,\n    // save the state of the published collections, reset to an empty view, and\n    // update the userId.\n    self._isSending = false;\n    var beforeCVs = self.collectionViews;\n    self.collectionViews = new Map();\n    self.userId = userId;\n\n    // _setUserId is normally called from a Meteor method with\n    // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n    // expected to be set inside a publish function, so we temporary unset it.\n    // Inside a publish function DDP._CurrentPublicationInvocation is set.\n    DDP._CurrentMethodInvocation.withValue(undefined, function () {\n      // Save the old named subs, and reset to having no subscriptions.\n      var oldNamedSubs = self._namedSubs;\n      self._namedSubs = new Map();\n      self._universalSubs = [];\n\n      oldNamedSubs.forEach(function (sub, subscriptionId) {\n        var newSub = sub._recreate();\n        self._namedSubs.set(subscriptionId, newSub);\n        // nb: if the handler throws or calls this.error(), it will in fact\n        // immediately send its 'nosub'. This is OK, though.\n        newSub._runHandler();\n      });\n\n      // Allow newly-created universal subs to be started on our connection in\n      // parallel with the ones we're spinning up here, and spin up universal\n      // subs.\n      self._dontStartNewUniversalSubs = false;\n      self.startUniversalSubs();\n    });\n\n    // Start sending messages again, beginning with the diff from the previous\n    // state of the world to the current state. No yields are allowed during\n    // this diff, so that other changes cannot interleave.\n    Meteor._noYieldsAllowed(function () {\n      self._isSending = true;\n      self._diffCollectionViews(beforeCVs);\n      if (!_.isEmpty(self._pendingReady)) {\n        self.sendReady(self._pendingReady);\n        self._pendingReady = [];\n      }\n    });\n  },\n\n  _startSubscription: function (handler, subId, params, name) {\n    var self = this;\n\n    var sub = new Subscription(\n      self, handler, subId, params, name);\n    if (subId)\n      self._namedSubs.set(subId, sub);\n    else\n      self._universalSubs.push(sub);\n\n    sub._runHandler();\n  },\n\n  // tear down specified subscription\n  _stopSubscription: function (subId, error) {\n    var self = this;\n\n    var subName = null;\n    if (subId) {\n      var maybeSub = self._namedSubs.get(subId);\n      if (maybeSub) {\n        subName = maybeSub._name;\n        maybeSub._removeAllDocuments();\n        maybeSub._deactivate();\n        self._namedSubs.delete(subId);\n      }\n    }\n\n    var response = {msg: 'nosub', id: subId};\n\n    if (error) {\n      response.error = wrapInternalException(\n        error,\n        subName ? (\"from sub \" + subName + \" id \" + subId)\n          : (\"from sub id \" + subId));\n    }\n\n    self.send(response);\n  },\n\n  // tear down all subscriptions. Note that this does NOT send removed or nosub\n  // messages, since we assume the client is gone.\n  _deactivateAllSubscriptions: function () {\n    var self = this;\n\n    self._namedSubs.forEach(function (sub, id) {\n      sub._deactivate();\n    });\n    self._namedSubs = new Map();\n\n    self._universalSubs.forEach(function (sub) {\n      sub._deactivate();\n    });\n    self._universalSubs = [];\n  },\n\n  // Determine the remote client's IP address, based on the\n  // HTTP_FORWARDED_COUNT environment variable representing how many\n  // proxies the server is behind.\n  _clientAddress: function () {\n    var self = this;\n\n    // For the reported client address for a connection to be correct,\n    // the developer must set the HTTP_FORWARDED_COUNT environment\n    // variable to an integer representing the number of hops they\n    // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n    // server is behind one proxy.\n    //\n    // This could be computed once at startup instead of every time.\n    var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n    if (httpForwardedCount === 0)\n      return self.socket.remoteAddress;\n\n    var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n    if (! _.isString(forwardedFor))\n      return null;\n    forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n    // Typically the first value in the `x-forwarded-for` header is\n    // the original IP address of the client connecting to the first\n    // proxy.  However, the end user can easily spoof the header, in\n    // which case the first value(s) will be the fake IP address from\n    // the user pretending to be a proxy reporting the original IP\n    // address value.  By counting HTTP_FORWARDED_COUNT back from the\n    // end of the list, we ensure that we get the IP address being\n    // reported by *our* first proxy.\n\n    if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n      return null;\n\n    return forwardedFor[forwardedFor.length - httpForwardedCount];\n  }\n});\n\n/******************************************************************************/\n/* Subscription                                                               */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n    session, handler, subscriptionId, params, name) {\n  var self = this;\n  self._session = session; // type is Session\n\n  /**\n   * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n   * @locus Server\n   * @name  connection\n   * @memberOf Subscription\n   * @instance\n   */\n  self.connection = session.connectionHandle; // public API object\n\n  self._handler = handler;\n\n  // my subscription ID (generated by client, undefined for universal subs).\n  self._subscriptionId = subscriptionId;\n  // undefined for universal subs\n  self._name = name;\n\n  self._params = params || [];\n\n  // Only named subscriptions have IDs, but we need some sort of string\n  // internally to keep track of all subscriptions inside\n  // SessionDocumentViews. We use this subscriptionHandle for that.\n  if (self._subscriptionId) {\n    self._subscriptionHandle = 'N' + self._subscriptionId;\n  } else {\n    self._subscriptionHandle = 'U' + Random.id();\n  }\n\n  // has _deactivate been called?\n  self._deactivated = false;\n\n  // stop callbacks to g/c this sub.  called w/ zero arguments.\n  self._stopCallbacks = [];\n\n  // the set of (collection, documentid) that this subscription has\n  // an opinion about\n  self._documents = new Map();\n\n  // remember if we are ready.\n  self._ready = false;\n\n  // Part of the public API: the user of this sub.\n\n  /**\n   * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n   * @locus Server\n   * @memberOf Subscription\n   * @name  userId\n   * @instance\n   */\n  self.userId = session.userId;\n\n  // For now, the id filter is going to default to\n  // the to/from DDP methods on MongoID, to\n  // specifically deal with mongo/minimongo ObjectIds.\n\n  // Later, you will be able to make this be \"raw\"\n  // if you want to publish a collection that you know\n  // just has strings for keys and no funny business, to\n  // a ddp consumer that isn't minimongo\n\n  self._idFilter = {\n    idStringify: MongoID.idStringify,\n    idParse: MongoID.idParse\n  };\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n  _runHandler: function () {\n    // XXX should we unblock() here? Either before running the publish\n    // function, or before running _publishCursor.\n    //\n    // Right now, each publish function blocks all future publishes and\n    // methods waiting on data from Mongo (or whatever else the function\n    // blocks on). This probably slows page load in common cases.\n\n    var self = this;\n    try {\n      var res = DDP._CurrentPublicationInvocation.withValue(\n        self,\n        () => maybeAuditArgumentChecks(\n          self._handler, self, EJSON.clone(self._params),\n          // It's OK that this would look weird for universal subscriptions,\n          // because they have no arguments so there can never be an\n          // audit-argument-checks failure.\n          \"publisher '\" + self._name + \"'\"\n        )\n      );\n    } catch (e) {\n      self.error(e);\n      return;\n    }\n\n    // Did the handler call this.error or this.stop?\n    if (self._isDeactivated())\n      return;\n\n    self._publishHandlerResult(res);\n  },\n\n  _publishHandlerResult: function (res) {\n    // SPECIAL CASE: Instead of writing their own callbacks that invoke\n    // this.added/changed/ready/etc, the user can just return a collection\n    // cursor or array of cursors from the publish function; we call their\n    // _publishCursor method which starts observing the cursor and publishes the\n    // results. Note that _publishCursor does NOT call ready().\n    //\n    // XXX This uses an undocumented interface which only the Mongo cursor\n    // interface publishes. Should we make this interface public and encourage\n    // users to implement it themselves? Arguably, it's unnecessary; users can\n    // already write their own functions like\n    //   var publishMyReactiveThingy = function (name, handler) {\n    //     Meteor.publish(name, function () {\n    //       var reactiveThingy = handler();\n    //       reactiveThingy.publishMe();\n    //     });\n    //   };\n\n    var self = this;\n    var isCursor = function (c) {\n      return c && c._publishCursor;\n    };\n    if (isCursor(res)) {\n      try {\n        res._publishCursor(self);\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      // _publishCursor only returns after the initial added callbacks have run.\n      // mark subscription as ready.\n      self.ready();\n    } else if (_.isArray(res)) {\n      // check all the elements are cursors\n      if (! _.all(res, isCursor)) {\n        self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n        return;\n      }\n      // find duplicate collection names\n      // XXX we should support overlapping cursors, but that would require the\n      // merge box to allow overlap within a subscription\n      var collectionNames = {};\n      for (var i = 0; i < res.length; ++i) {\n        var collectionName = res[i]._getCollectionName();\n        if (_.has(collectionNames, collectionName)) {\n          self.error(new Error(\n            \"Publish function returned multiple cursors for collection \" +\n              collectionName));\n          return;\n        }\n        collectionNames[collectionName] = true;\n      };\n\n      try {\n        _.each(res, function (cur) {\n          cur._publishCursor(self);\n        });\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      self.ready();\n    } else if (res) {\n      // truthy values other than cursors or arrays are probably a\n      // user mistake (possible returning a Mongo document via, say,\n      // `coll.findOne()`).\n      self.error(new Error(\"Publish function can only return a Cursor or \"\n                           + \"an array of Cursors\"));\n    }\n  },\n\n  // This calls all stop callbacks and prevents the handler from updating any\n  // SessionCollectionViews further. It's used when the user unsubscribes or\n  // disconnects, as well as during setUserId re-runs. It does *NOT* send\n  // removed messages for the published objects; if that is necessary, call\n  // _removeAllDocuments first.\n  _deactivate: function() {\n    var self = this;\n    if (self._deactivated)\n      return;\n    self._deactivated = true;\n    self._callStopCallbacks();\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"subscriptions\", -1);\n  },\n\n  _callStopCallbacks: function () {\n    var self = this;\n    // tell listeners, so they can clean up\n    var callbacks = self._stopCallbacks;\n    self._stopCallbacks = [];\n    _.each(callbacks, function (callback) {\n      callback();\n    });\n  },\n\n  // Send remove messages for every document.\n  _removeAllDocuments: function () {\n    var self = this;\n    Meteor._noYieldsAllowed(function () {\n      self._documents.forEach(function (collectionDocs, collectionName) {\n        collectionDocs.forEach(function (strId) {\n          self.removed(collectionName, self._idFilter.idParse(strId));\n        });\n      });\n    });\n  },\n\n  // Returns a new Subscription for the same session with the same\n  // initial creation parameters. This isn't a clone: it doesn't have\n  // the same _documents cache, stopped state or callbacks; may have a\n  // different _subscriptionHandle, and gets its userId from the\n  // session, not from this object.\n  _recreate: function () {\n    var self = this;\n    return new Subscription(\n      self._session, self._handler, self._subscriptionId, self._params,\n      self._name);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n   * @locus Server\n   * @param {Error} error The error to pass to the client.\n   * @instance\n   * @memberOf Subscription\n   */\n  error: function (error) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId, error);\n  },\n\n  // Note that while our DDP client will notice that you've called stop() on the\n  // server (and clean up its _subscriptions table) we don't actually provide a\n  // mechanism for an app to notice this (the subscribe onError callback only\n  // triggers if there is an error).\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.\n   * @locus Server\n   * @instance\n   * @memberOf Subscription\n   */\n  stop: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {Function} func The callback function\n   */\n  onStop: function (callback) {\n    var self = this;\n    callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n    if (self._isDeactivated())\n      callback();\n    else\n      self._stopCallbacks.push(callback);\n  },\n\n  // This returns true if the sub has been deactivated, *OR* if the session was\n  // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n  // happened yet.\n  _isDeactivated: function () {\n    var self = this;\n    return self._deactivated || self._session.inQueue === null;\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the new document.\n   * @param {String} id The new document's ID.\n   * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.\n   */\n  added: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    let ids = self._documents.get(collectionName);\n    if (ids == null) {\n      ids = new Set();\n      self._documents.set(collectionName, ids);\n    }\n    ids.add(id);\n    self._session.added(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the changed document.\n   * @param {String} id The changed document's ID.\n   * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.\n   */\n  changed: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that the document has been removed from.\n   * @param {String} id The ID of the document that has been removed.\n   */\n  removed: function (collectionName, id) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    // We don't bother to delete sets of things in a collection if the\n    // collection is empty.  It could break _removeAllDocuments.\n    self._documents.get(collectionName).delete(id);\n    self._session.removed(self._subscriptionHandle, collectionName, id);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   */\n  ready: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    if (!self._subscriptionId)\n      return;  // unnecessary but ignored for universal sub\n    if (!self._ready) {\n      self._session.sendReady([self._subscriptionId]);\n      self._ready = true;\n    }\n  }\n});\n\n/******************************************************************************/\n/* Server                                                                     */\n/******************************************************************************/\n\nServer = function (options) {\n  var self = this;\n\n  // The default heartbeat interval is 30 seconds on the server and 35\n  // seconds on the client.  Since the client doesn't need to send a\n  // ping as long as it is receiving pings, this means that pings\n  // normally go from the server to the client.\n  //\n  // Note: Troposphere depends on the ability to mutate\n  // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n  self.options = _.defaults(options || {}, {\n    heartbeatInterval: 15000,\n    heartbeatTimeout: 15000,\n    // For testing, allow responding to pings to be disabled.\n    respondToPings: true\n  });\n\n  // Map of callbacks to call when a new connection comes in to the\n  // server and completes DDP version negotiation. Use an object instead\n  // of an array so we can safely remove one from the list while\n  // iterating over it.\n  self.onConnectionHook = new Hook({\n    debugPrintExceptions: \"onConnection callback\"\n  });\n\n  // Map of callbacks to call when a new message comes in.\n  self.onMessageHook = new Hook({\n    debugPrintExceptions: \"onMessage callback\"\n  });\n\n  self.publish_handlers = {};\n  self.universal_publish_handlers = [];\n\n  self.method_handlers = {};\n\n  self.sessions = new Map(); // map from id to session\n\n  self.stream_server = new StreamServer;\n\n  self.stream_server.register(function (socket) {\n    // socket implements the SockJSConnection interface\n    socket._meteorSession = null;\n\n    var sendError = function (reason, offendingMessage) {\n      var msg = {msg: 'error', reason: reason};\n      if (offendingMessage)\n        msg.offendingMessage = offendingMessage;\n      socket.send(DDPCommon.stringifyDDP(msg));\n    };\n\n    socket.on('data', function (raw_msg) {\n      if (Meteor._printReceivedDDP) {\n        Meteor._debug(\"Received DDP\", raw_msg);\n      }\n      try {\n        try {\n          var msg = DDPCommon.parseDDP(raw_msg);\n        } catch (err) {\n          sendError('Parse error');\n          return;\n        }\n        if (msg === null || !msg.msg) {\n          sendError('Bad request', msg);\n          return;\n        }\n\n        if (msg.msg === 'connect') {\n          if (socket._meteorSession) {\n            sendError(\"Already connected\", msg);\n            return;\n          }\n          Fiber(function () {\n            self._handleConnect(socket, msg);\n          }).run();\n          return;\n        }\n\n        if (!socket._meteorSession) {\n          sendError('Must connect first', msg);\n          return;\n        }\n        socket._meteorSession.processMessage(msg);\n      } catch (e) {\n        // XXX print stack nicely\n        Meteor._debug(\"Internal exception while processing message\", msg, e);\n      }\n    });\n\n    socket.on('close', function () {\n      if (socket._meteorSession) {\n        Fiber(function () {\n          socket._meteorSession.close();\n        }).run();\n      }\n    });\n  });\n};\n\n_.extend(Server.prototype, {\n\n  /**\n   * @summary Register a callback to be called when a new DDP connection is made to the server.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP connection is established.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onConnection: function (fn) {\n    var self = this;\n    return self.onConnectionHook.register(fn);\n  },\n\n  /**\n   * @summary Register a callback to be called when a new DDP message is received.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP message is received.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onMessage: function (fn) {\n    var self = this;\n    return self.onMessageHook.register(fn);\n  },\n\n  _handleConnect: function (socket, msg) {\n    var self = this;\n\n    // The connect message must specify a version and an array of supported\n    // versions, and it must claim to support what it is proposing.\n    if (!(typeof (msg.version) === 'string' &&\n          _.isArray(msg.support) &&\n          _.all(msg.support, _.isString) &&\n          _.contains(msg.support, msg.version))) {\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n                                version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n      socket.close();\n      return;\n    }\n\n    // In the future, handle session resumption: something like:\n    //  socket._meteorSession = self.sessions[msg.session]\n    var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n    if (msg.version !== version) {\n      // The best version to use (according to the client's stated preferences)\n      // is not the one the client is trying to use. Inform them about the best\n      // version to use.\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n      socket.close();\n      return;\n    }\n\n    // Yay, version matches! Create a new session.\n    // Note: Troposphere depends on the ability to mutate\n    // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n    socket._meteorSession = new Session(self, version, socket, self.options);\n    self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n    self.onConnectionHook.each(function (callback) {\n      if (socket._meteorSession)\n        callback(socket._meteorSession.connectionHandle);\n      return true;\n    });\n  },\n  /**\n   * Register a publish handler function.\n   *\n   * @param name {String} identifier for query\n   * @param handler {Function} publish handler\n   * @param options {Object}\n   *\n   * Server will call handler function on each new subscription,\n   * either when receiving DDP sub message for a named subscription, or on\n   * DDP connect for a universal subscription.\n   *\n   * If name is null, this will be a subscription that is\n   * automatically established and permanently on for all connected\n   * client, instead of a subscription that can be turned on and off\n   * with subscribe().\n   *\n   * options to contain:\n   *  - (mostly internal) is_auto: true if generated automatically\n   *    from an autopublish hook. this is for cosmetic purposes only\n   *    (it lets us determine whether to print a warning suggesting\n   *    that you turn off autopublish.)\n   */\n\n  /**\n   * @summary Publish a record set.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   * @locus Server\n   * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n   * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.\n   */\n  publish: function (name, handler, options) {\n    var self = this;\n\n    if (! _.isObject(name)) {\n      options = options || {};\n\n      if (name && name in self.publish_handlers) {\n        Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n        return;\n      }\n\n      if (Package.autopublish && !options.is_auto) {\n        // They have autopublish on, yet they're trying to manually\n        // picking stuff to publish. They probably should turn off\n        // autopublish. (This check isn't perfect -- if you create a\n        // publish before you turn on autopublish, it won't catch\n        // it. But this will definitely handle the simple case where\n        // you've added the autopublish package to your app, and are\n        // calling publish from your app code.)\n        if (!self.warned_about_autopublish) {\n          self.warned_about_autopublish = true;\n          Meteor._debug(\n    \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n    \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n    \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n    \"** will still be sent to all clients.\\n\" +\n    \"**\\n\" +\n    \"** Turn off autopublish by removing the autopublish package:\\n\" +\n    \"**\\n\" +\n    \"**   $ meteor remove autopublish\\n\" +\n    \"**\\n\" +\n    \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n    \"** for each collection that you want clients to see.\\n\");\n        }\n      }\n\n      if (name)\n        self.publish_handlers[name] = handler;\n      else {\n        self.universal_publish_handlers.push(handler);\n        // Spin up the new publisher on any existing session too. Run each\n        // session's subscription in a new Fiber, so that there's no change for\n        // self.sessions to change while we're running this loop.\n        self.sessions.forEach(function (session) {\n          if (!session._dontStartNewUniversalSubs) {\n            Fiber(function() {\n              session._startSubscription(handler);\n            }).run();\n          }\n        });\n      }\n    }\n    else{\n      _.each(name, function(value, key) {\n        self.publish(key, value, {});\n      });\n    }\n  },\n\n  _removeSession: function (session) {\n    var self = this;\n    self.sessions.delete(session.id);\n  },\n\n  /**\n   * @summary Defines functions that can be invoked over the network by clients.\n   * @locus Anywhere\n   * @param {Object} methods Dictionary whose keys are method names and values are functions.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  methods: function (methods) {\n    var self = this;\n    _.each(methods, function (func, name) {\n      if (typeof func !== 'function')\n        throw new Error(\"Method '\" + name + \"' must be a function\");\n      if (self.method_handlers[name])\n        throw new Error(\"A method named '\" + name + \"' is already defined\");\n      self.method_handlers[name] = func;\n    });\n  },\n\n  call: function (name, ...args) {\n    if (args.length && typeof args[args.length - 1] === \"function\") {\n      // If it's a function, the last argument is the result callback, not\n      // a parameter to the remote method.\n      var callback = args.pop();\n    }\n\n    return this.apply(name, args, callback);\n  },\n\n  // A version of the call method that always returns a Promise.\n  callAsync: function (name, ...args) {\n    return this.applyAsync(name, args);\n  },\n\n  apply: function (name, args, options, callback) {\n    // We were passed 3 arguments. They may be either (name, args, options)\n    // or (name, args, callback)\n    if (! callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    } else {\n      options = options || {};\n    }\n\n    const promise = this.applyAsync(name, args, options);\n\n    // Return the result in whichever way the caller asked for it. Note that we\n    // do NOT block on the write fence in an analogous way to how the client\n    // blocks on the relevant data being visible, so you are NOT guaranteed that\n    // cursor observe callbacks have fired when your callback is invoked. (We\n    // can change this if there's a real use case.)\n    if (callback) {\n      promise.then(\n        result => callback(undefined, result),\n        exception => callback(exception)\n      );\n    } else {\n      return promise.await();\n    }\n  },\n\n  // @param options {Optional Object}\n  applyAsync: function (name, args, options) {\n    // Run the handler\n    var handler = this.method_handlers[name];\n    if (! handler) {\n      return Promise.reject(\n        new Meteor.Error(404, `Method '${name}' not found`)\n      );\n    }\n\n    // If this is a method call from within another method or publish function,\n    // get the user state from the outer method or publish function, otherwise\n    // don't allow setUserId to be called\n    var userId = null;\n    var setUserId = function() {\n      throw new Error(\"Can't call setUserId on a server initiated method call\");\n    };\n    var connection = null;\n    var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n    var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n    var randomSeed = null;\n    if (currentMethodInvocation) {\n      userId = currentMethodInvocation.userId;\n      setUserId = function(userId) {\n        currentMethodInvocation.setUserId(userId);\n      };\n      connection = currentMethodInvocation.connection;\n      randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n    } else if (currentPublicationInvocation) {\n      userId = currentPublicationInvocation.userId;\n      setUserId = function(userId) {\n        currentPublicationInvocation._session._setUserId(userId);\n      };\n      connection = currentPublicationInvocation.connection;\n    }\n\n    var invocation = new DDPCommon.MethodInvocation({\n      isSimulation: false,\n      userId,\n      setUserId,\n      connection,\n      randomSeed\n    });\n\n    return new Promise(resolve => resolve(\n      DDP._CurrentMethodInvocation.withValue(\n        invocation,\n        () => maybeAuditArgumentChecks(\n          handler, invocation, EJSON.clone(args),\n          \"internal call to '\" + name + \"'\"\n        )\n      )\n    )).then(EJSON.clone);\n  },\n\n  _urlForSession: function (sessionId) {\n    var self = this;\n    var session = self.sessions.get(sessionId);\n    if (session)\n      return session._socketUrl;\n    else\n      return null;\n  }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n                                 serverSupportedVersions) {\n  var correctVersion = _.find(clientSupportedVersions, function (version) {\n    return _.contains(serverSupportedVersions, version);\n  });\n  if (!correctVersion) {\n    correctVersion = serverSupportedVersions[0];\n  }\n  return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n  if (!exception) return exception;\n\n  // To allow packages to throw errors intended for the client but not have to\n  // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n  // error before it is thrown.\n  if (exception.isClientSafe) {\n    if (!(exception instanceof Meteor.Error)) {\n      const originalMessage = exception.message;\n      exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n      exception.message = originalMessage;\n    }\n    return exception;\n  }\n\n  // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n  // the server log.\n  if (!exception._expectedByTest) {\n    Meteor._debug(\"Exception \" + context, exception.stack);\n    if (exception.sanitizedError) {\n      Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n      Meteor._debug();\n    }\n  }\n\n  // Did the error contain more details that could have been useful if caught in\n  // server code (or if thrown from non-client-originated code), but also\n  // provided a \"sanitized\" version with more context than 500 Internal server\n  // error? Use that.\n  if (exception.sanitizedError) {\n    if (exception.sanitizedError.isClientSafe)\n      return exception.sanitizedError;\n    Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n                  \"does not have isClientSafe property set; ignoring\");\n  }\n\n  return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n  args = args || [];\n  if (Package['audit-argument-checks']) {\n    return Match._failIfArgumentsAreNotAllChecked(\n      f, context, args, description);\n  }\n  return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n  var self = this;\n\n  self.armed = false;\n  self.fired = false;\n  self.retired = false;\n  self.outstanding_writes = 0;\n  self.before_fire_callbacks = [];\n  self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n  // Start tracking a write, and return an object to represent it. The\n  // object has a single method, committed(). This method should be\n  // called when the write is fully committed and propagated. You can\n  // continue to add writes to the WriteFence up until it is triggered\n  // (calls its callbacks because all writes have committed.)\n  beginWrite: function () {\n    var self = this;\n\n    if (self.retired)\n      return { committed: function () {} };\n\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to add writes\");\n\n    self.outstanding_writes++;\n    var committed = false;\n    return {\n      committed: function () {\n        if (committed)\n          throw new Error(\"committed called twice on the same write\");\n        committed = true;\n        self.outstanding_writes--;\n        self._maybeFire();\n      }\n    };\n  },\n\n  // Arm the fence. Once the fence is armed, and there are no more\n  // uncommitted writes, it will activate.\n  arm: function () {\n    var self = this;\n    if (self === DDPServer._CurrentWriteFence.get())\n      throw Error(\"Can't arm the current fence\");\n    self.armed = true;\n    self._maybeFire();\n  },\n\n  // Register a function to be called once before firing the fence.\n  // Callback function can add new writes to the fence, in which case\n  // it won't fire until those writes are done as well.\n  onBeforeFire: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.before_fire_callbacks.push(func);\n  },\n\n  // Register a function to be called when the fence fires.\n  onAllCommitted: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.completion_callbacks.push(func);\n  },\n\n  // Convenience function. Arms the fence, then blocks until it fires.\n  armAndWait: function () {\n    var self = this;\n    var future = new Future;\n    self.onAllCommitted(function () {\n      future['return']();\n    });\n    self.arm();\n    future.wait();\n  },\n\n  _maybeFire: function () {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"write fence already activated?\");\n    if (self.armed && !self.outstanding_writes) {\n      function invokeCallback (func) {\n        try {\n          func(self);\n        } catch (err) {\n          Meteor._debug(\"exception in write fence callback\", err);\n        }\n      }\n\n      self.outstanding_writes++;\n      while (self.before_fire_callbacks.length > 0) {\n        var callbacks = self.before_fire_callbacks;\n        self.before_fire_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n      self.outstanding_writes--;\n\n      if (!self.outstanding_writes) {\n        self.fired = true;\n        var callbacks = self.completion_callbacks;\n        self.completion_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n    }\n  },\n\n  // Deactivate this fence so that adding more writes has no effect.\n  // The fence must have already fired.\n  retire: function () {\n    var self = this;\n    if (! self.fired)\n      throw new Error(\"Can't retire a fence that hasn't fired.\");\n    self.retired = true;\n  }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n  var self = this;\n  options = options || {};\n\n  self.nextId = 1;\n  // map from collection name (string) -> listener id -> object. each object has\n  // keys 'trigger', 'callback'.  As a hack, the empty string means \"no\n  // collection\".\n  self.listenersByCollection = {};\n  self.listenersByCollectionCount = {};\n  self.factPackage = options.factPackage || \"livedata\";\n  self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n  // msg is a trigger or a notification\n  _collectionForMessage: function (msg) {\n    var self = this;\n    if (! _.has(msg, 'collection')) {\n      return '';\n    } else if (typeof(msg.collection) === 'string') {\n      if (msg.collection === '')\n        throw Error(\"Message has empty collection!\");\n      return msg.collection;\n    } else {\n      throw Error(\"Message has non-string collection!\");\n    }\n  },\n\n  // Listen for notification that match 'trigger'. A notification\n  // matches if it has the key-value pairs in trigger as a\n  // subset. When a notification matches, call 'callback', passing\n  // the actual notification.\n  //\n  // Returns a listen handle, which is an object with a method\n  // stop(). Call stop() to stop listening.\n  //\n  // XXX It should be legal to call fire() from inside a listen()\n  // callback?\n  listen: function (trigger, callback) {\n    var self = this;\n    var id = self.nextId++;\n\n    var collection = self._collectionForMessage(trigger);\n    var record = {trigger: EJSON.clone(trigger), callback: callback};\n    if (! _.has(self.listenersByCollection, collection)) {\n      self.listenersByCollection[collection] = {};\n      self.listenersByCollectionCount[collection] = 0;\n    }\n    self.listenersByCollection[collection][id] = record;\n    self.listenersByCollectionCount[collection]++;\n\n    if (self.factName && Package['facts-base']) {\n      Package['facts-base'].Facts.incrementServerFact(\n        self.factPackage, self.factName, 1);\n    }\n\n    return {\n      stop: function () {\n        if (self.factName && Package['facts-base']) {\n          Package['facts-base'].Facts.incrementServerFact(\n            self.factPackage, self.factName, -1);\n        }\n        delete self.listenersByCollection[collection][id];\n        self.listenersByCollectionCount[collection]--;\n        if (self.listenersByCollectionCount[collection] === 0) {\n          delete self.listenersByCollection[collection];\n          delete self.listenersByCollectionCount[collection];\n        }\n      }\n    };\n  },\n\n  // Fire the provided 'notification' (an object whose attribute\n  // values are all JSON-compatibile) -- inform all matching listeners\n  // (registered with listen()).\n  //\n  // If fire() is called inside a write fence, then each of the\n  // listener callbacks will be called inside the write fence as well.\n  //\n  // The listeners may be invoked in parallel, rather than serially.\n  fire: function (notification) {\n    var self = this;\n\n    var collection = self._collectionForMessage(notification);\n\n    if (! _.has(self.listenersByCollection, collection)) {\n      return;\n    }\n\n    var listenersForCollection = self.listenersByCollection[collection];\n    var callbackIds = [];\n    _.each(listenersForCollection, function (l, id) {\n      if (self._matches(notification, l.trigger)) {\n        callbackIds.push(id);\n      }\n    });\n\n    // Listener callbacks can yield, so we need to first find all the ones that\n    // match in a single iteration over self.listenersByCollection (which can't\n    // be mutated during this iteration), and then invoke the matching\n    // callbacks, checking before each call to ensure they haven't stopped.\n    // Note that we don't have to check that\n    // self.listenersByCollection[collection] still === listenersForCollection,\n    // because the only way that stops being true is if listenersForCollection\n    // first gets reduced down to the empty object (and then never gets\n    // increased again).\n    _.each(callbackIds, function (id) {\n      if (_.has(listenersForCollection, id)) {\n        listenersForCollection[id].callback(notification);\n      }\n    });\n  },\n\n  // A notification matches a trigger if all keys that exist in both are equal.\n  //\n  // Examples:\n  //  N:{collection: \"C\"} matches T:{collection: \"C\"}\n  //    (a non-targeted write to a collection matches a\n  //     non-targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n  //    (a targeted write to a collection matches a non-targeted query)\n  //  N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a non-targeted write to a collection matches a\n  //     targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a targeted write to a collection matches a targeted query targeted\n  //     at the same document)\n  //  N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n  //    (a targeted write to a collection does not match a targeted query\n  //     targeted at a different document)\n  _matches: function (notification, trigger) {\n    // Most notifications that use the crossbar have a string `collection` and\n    // maybe an `id` that is a string or ObjectID. We're already dividing up\n    // triggers by collection, but let's fast-track \"nope, different ID\" (and\n    // avoid the overly generic EJSON.equals). This makes a noticeable\n    // performance difference; see https://github.com/meteor/meteor/pull/3697\n    if (typeof(notification.id) === 'string' &&\n        typeof(trigger.id) === 'string' &&\n        notification.id !== trigger.id) {\n      return false;\n    }\n    if (notification.id instanceof MongoID.ObjectID &&\n        trigger.id instanceof MongoID.ObjectID &&\n        ! notification.id.equals(trigger.id)) {\n      return false;\n    }\n\n    return _.all(trigger, function (triggerValue, key) {\n      return !_.has(notification, key) ||\n        EJSON.equals(triggerValue, notification[key]);\n    });\n  }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n  factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n  __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n    process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n  DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n       function (name) {\n         Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n       });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","disable_cors","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n  var extensions = [];\n\n  var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n    ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n  if (websocketCompressionConfig) {\n    extensions.push(Npm.require('permessage-deflate').configure(\n      websocketCompressionConfig\n    ));\n  }\n\n  return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n  var self = this;\n  self.registration_callbacks = [];\n  self.open_sockets = [];\n\n  // Because we are installing directly onto WebApp.httpServer instead of using\n  // WebApp.app, we have to process the path prefix ourselves.\n  self.prefix = pathPrefix + '/sockjs';\n  RoutePolicy.declare(self.prefix + '/', 'network');\n\n  // set up sockjs\n  var sockjs = Npm.require('sockjs');\n  var serverOptions = {\n    prefix: self.prefix,\n    log: function () { },\n    // this is the default, but we code it explicitly because we depend\n    // on it in stream_client:HEARTBEAT_TIMEOUT\n    heartbeat_delay: 45000,\n    // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n    // bound for that much time, SockJS might not notice that the user has\n    // reconnected because the timer (of disconnect_delay ms) can fire before\n    // SockJS processes the new connection. Eventually we'll fix this by not\n    // combining CPU-heavy processing with SockJS termination (eg a proxy which\n    // converts to Unix sockets) but for now, raise the delay.\n    disconnect_delay: 60 * 1000,\n    // Set the USE_JSESSIONID environment variable to enable setting the\n    // JSESSIONID cookie. This is useful for setting up proxies with\n    // session affinity.\n    jsessionid: !!process.env.USE_JSESSIONID,\n    // 禁用cors，防止请求response返回Access-Control-Allow-Origin:*\n    disable_cors: true\n  };\n\n  // If you know your server environment (eg, proxies) will prevent websockets\n  // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n  // browsers) will not waste time attempting to use them.\n  // (Your server will still have a /websocket endpoint.)\n  if (process.env.DISABLE_WEBSOCKETS) {\n    serverOptions.websocket = false;\n  } else {\n    serverOptions.faye_server_options = {\n      extensions: websocketExtensions()\n    };\n  }\n\n  self.server = sockjs.createServer(serverOptions);\n\n  // Install the sockjs handlers, but we want to keep around our own particular\n  // request handler that adjusts idle timeouts while we have an outstanding\n  // request.  This compensates for the fact that sockjs removes all listeners\n  // for \"request\" to add its own.\n  WebApp.httpServer.removeListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n  self.server.installHandlers(WebApp.httpServer);\n  WebApp.httpServer.addListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n\n  // Support the /websocket endpoint\n  self._redirectWebsocketEndpoint();\n\n  self.server.on('connection', function (socket) {\n    // We want to make sure that if a client connects to us and does the initial\n    // Websocket handshake but never gets to the DDP handshake, that we\n    // eventually kill the socket.  Once the DDP handshake happens, DDP\n    // heartbeating will work. And before the Websocket handshake, the timeouts\n    // we set at the server level in webapp_server.js will work. But\n    // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n    // is an \"in between\" state where this doesn't happen.  We work around this\n    // by explicitly setting the socket timeout to a relatively large time here,\n    // and setting it back to zero when we set up the heartbeat in\n    // livedata_server.js.\n    socket.setWebsocketTimeout = function (timeout) {\n      if ((socket.protocol === 'websocket' ||\n        socket.protocol === 'websocket-raw')\n        && socket._session.recv) {\n        socket._session.recv.connection.setTimeout(timeout);\n      }\n    };\n    socket.setWebsocketTimeout(45 * 1000);\n\n    socket.send = function (data) {\n      socket.write(data);\n    };\n    socket.on('close', function () {\n      self.open_sockets = _.without(self.open_sockets, socket);\n    });\n    self.open_sockets.push(socket);\n\n    // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n    // will force old clients to reload. Remove this once we're not\n    // concerned about people upgrading from a pre-0.7.0 release. Also,\n    // remove the clause in the client that ignores the welcome message\n    // (livedata_connection.js)\n    socket.send(JSON.stringify({ server_id: \"0\" }));\n\n    // call all our callbacks when we get a new socket. they will do the\n    // work of setting up handlers and such for specific messages.\n    _.each(self.registration_callbacks, function (callback) {\n      callback(socket);\n    });\n  });\n\n};\n\n_.extend(StreamServer.prototype, {\n  // call my callback when a new socket connects.\n  // also call it for all current connections.\n  register: function (callback) {\n    var self = this;\n    self.registration_callbacks.push(callback);\n    _.each(self.all_sockets(), function (socket) {\n      callback(socket);\n    });\n  },\n\n  // get a list of all sockets\n  all_sockets: function () {\n    var self = this;\n    return _.values(self.open_sockets);\n  },\n\n  // Redirect /websocket to /sockjs/websocket in order to not expose\n  // sockjs to clients that want to use raw websockets\n  _redirectWebsocketEndpoint: function () {\n    var self = this;\n    // Unfortunately we can't use a connect middleware here since\n    // sockjs installs itself prior to all existing listeners\n    // (meaning prior to any connect middlewares) so we need to take\n    // an approach similar to overshadowListeners in\n    // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n    _.each(['request', 'upgrade'], function (event) {\n      var httpServer = WebApp.httpServer;\n      var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n      httpServer.removeAllListeners(event);\n\n      // request and upgrade have different arguments passed but\n      // we only care about the first one which is always request\n      var newListener = function (request /*, moreArguments */) {\n        // Store arguments for use within the closure below\n        var args = arguments;\n\n        // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n        // preserving query string.\n        var parsedUrl = url.parse(request.url);\n        if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n          parsedUrl.pathname === pathPrefix + '/websocket/') {\n          parsedUrl.pathname = self.prefix + '/websocket';\n          request.url = url.format(parsedUrl);\n        }\n        _.each(oldHttpServerListeners, function (oldListener) {\n          oldListener.apply(httpServer, args);\n        });\n      };\n      httpServer.addListener(event, newListener);\n    });\n  }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n  var self = this;\n  self.existsIn = new Set(); // set of subscriptionHandle\n  self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n  getFields: function () {\n    var self = this;\n    var ret = {};\n    self.dataByKey.forEach(function (precedenceList, key) {\n      ret[key] = precedenceList[0].value;\n    });\n    return ret;\n  },\n\n  clearField: function (subscriptionHandle, key, changeCollector) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n    var precedenceList = self.dataByKey.get(key);\n\n    // It's okay to clear fields that didn't exist. No need to throw\n    // an error.\n    if (!precedenceList)\n      return;\n\n    var removedValue = undefined;\n    for (var i = 0; i < precedenceList.length; i++) {\n      var precedence = precedenceList[i];\n      if (precedence.subscriptionHandle === subscriptionHandle) {\n        // The view's value can only change if this subscription is the one that\n        // used to have precedence.\n        if (i === 0)\n          removedValue = precedence.value;\n        precedenceList.splice(i, 1);\n        break;\n      }\n    }\n    if (precedenceList.length === 0) {\n      self.dataByKey.delete(key);\n      changeCollector[key] = undefined;\n    } else if (removedValue !== undefined &&\n               !EJSON.equals(removedValue, precedenceList[0].value)) {\n      changeCollector[key] = precedenceList[0].value;\n    }\n  },\n\n  changeField: function (subscriptionHandle, key, value,\n                         changeCollector, isAdd) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n\n    // Don't share state with the data passed in by the user.\n    value = EJSON.clone(value);\n\n    if (!self.dataByKey.has(key)) {\n      self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n                                value: value}]);\n      changeCollector[key] = value;\n      return;\n    }\n    var precedenceList = self.dataByKey.get(key);\n    var elt;\n    if (!isAdd) {\n      elt = precedenceList.find(function (precedence) {\n          return precedence.subscriptionHandle === subscriptionHandle;\n      });\n    }\n\n    if (elt) {\n      if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n        // this subscription is changing the value of this field.\n        changeCollector[key] = value;\n      }\n      elt.value = value;\n    } else {\n      // this subscription is newly caring about this field\n      precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n    }\n\n  }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n  var self = this;\n  self.collectionName = collectionName;\n  self.documents = new Map();\n  self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n  isEmpty: function () {\n    var self = this;\n    return self.documents.size === 0;\n  },\n\n  diff: function (previous) {\n    var self = this;\n    DiffSequence.diffMaps(previous.documents, self.documents, {\n      both: _.bind(self.diffDocument, self),\n\n      rightOnly: function (id, nowDV) {\n        self.callbacks.added(self.collectionName, id, nowDV.getFields());\n      },\n\n      leftOnly: function (id, prevDV) {\n        self.callbacks.removed(self.collectionName, id);\n      }\n    });\n  },\n\n  diffDocument: function (id, prevDV, nowDV) {\n    var self = this;\n    var fields = {};\n    DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n      both: function (key, prev, now) {\n        if (!EJSON.equals(prev, now))\n          fields[key] = now;\n      },\n      rightOnly: function (key, now) {\n        fields[key] = now;\n      },\n      leftOnly: function(key, prev) {\n        fields[key] = undefined;\n      }\n    });\n    self.callbacks.changed(self.collectionName, id, fields);\n  },\n\n  added: function (subscriptionHandle, id, fields) {\n    var self = this;\n    var docView = self.documents.get(id);\n    var added = false;\n    if (!docView) {\n      added = true;\n      docView = new SessionDocumentView();\n      self.documents.set(id, docView);\n    }\n    docView.existsIn.add(subscriptionHandle);\n    var changeCollector = {};\n    _.each(fields, function (value, key) {\n      docView.changeField(\n        subscriptionHandle, key, value, changeCollector, true);\n    });\n    if (added)\n      self.callbacks.added(self.collectionName, id, changeCollector);\n    else\n      self.callbacks.changed(self.collectionName, id, changeCollector);\n  },\n\n  changed: function (subscriptionHandle, id, changed) {\n    var self = this;\n    var changedResult = {};\n    var docView = self.documents.get(id);\n    if (!docView)\n      throw new Error(\"Could not find element with id \" + id + \" to change\");\n    _.each(changed, function (value, key) {\n      if (value === undefined)\n        docView.clearField(subscriptionHandle, key, changedResult);\n      else\n        docView.changeField(subscriptionHandle, key, value, changedResult);\n    });\n    self.callbacks.changed(self.collectionName, id, changedResult);\n  },\n\n  removed: function (subscriptionHandle, id) {\n    var self = this;\n    var docView = self.documents.get(id);\n    if (!docView) {\n      var err = new Error(\"Removed nonexistent document \" + id);\n      throw err;\n    }\n    docView.existsIn.delete(subscriptionHandle);\n    if (docView.existsIn.size === 0) {\n      // it is gone from everyone\n      self.callbacks.removed(self.collectionName, id);\n      self.documents.delete(id);\n    } else {\n      var changed = {};\n      // remove this subscription from every precedence list\n      // and record the changes\n      docView.dataByKey.forEach(function (precedenceList, key) {\n        docView.clearField(subscriptionHandle, key, changed);\n      });\n\n      self.callbacks.changed(self.collectionName, id, changed);\n    }\n  }\n});\n\n/******************************************************************************/\n/* Session                                                                    */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n  var self = this;\n  self.id = Random.id();\n\n  self.server = server;\n  self.version = version;\n\n  self.initialized = false;\n  self.socket = socket;\n\n  // set to null when the session is destroyed. multiple places below\n  // use this to determine if the session is alive or not.\n  self.inQueue = new Meteor._DoubleEndedQueue();\n\n  self.blocked = false;\n  self.workerRunning = false;\n\n  // Sub objects for active subscriptions\n  self._namedSubs = new Map();\n  self._universalSubs = [];\n\n  self.userId = null;\n\n  self.collectionViews = new Map();\n\n  // Set this to false to not send messages when collectionViews are\n  // modified. This is done when rerunning subs in _setUserId and those messages\n  // are calculated via a diff instead.\n  self._isSending = true;\n\n  // If this is true, don't start a newly-created universal publisher on this\n  // session. The session will take care of starting it when appropriate.\n  self._dontStartNewUniversalSubs = false;\n\n  // when we are rerunning subscriptions, any ready messages\n  // we want to buffer up for when we are done rerunning subscriptions\n  self._pendingReady = [];\n\n  // List of callbacks to call when this connection is closed.\n  self._closeCallbacks = [];\n\n\n  // XXX HACK: If a sockjs connection, save off the URL. This is\n  // temporary and will go away in the near future.\n  self._socketUrl = socket.url;\n\n  // Allow tests to disable responding to pings.\n  self._respondToPings = options.respondToPings;\n\n  // This object is the public interface to the session. In the public\n  // API, it is called the `connection` object.  Internally we call it\n  // a `connectionHandle` to avoid ambiguity.\n  self.connectionHandle = {\n    id: self.id,\n    close: function () {\n      self.close();\n    },\n    onClose: function (fn) {\n      var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n      if (self.inQueue) {\n        self._closeCallbacks.push(cb);\n      } else {\n        // if we're already closed, call the callback.\n        Meteor.defer(cb);\n      }\n    },\n    clientAddress: self._clientAddress(),\n    httpHeaders: self.socket.headers\n  };\n\n  self.send({ msg: 'connected', session: self.id });\n\n  // On initial connect, spin up all the universal publishers.\n  Fiber(function () {\n    self.startUniversalSubs();\n  }).run();\n\n  if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n    // We no longer need the low level timeout because we have heartbeating.\n    socket.setWebsocketTimeout(0);\n\n    self.heartbeat = new DDPCommon.Heartbeat({\n      heartbeatInterval: options.heartbeatInterval,\n      heartbeatTimeout: options.heartbeatTimeout,\n      onTimeout: function () {\n        self.close();\n      },\n      sendPing: function () {\n        self.send({msg: 'ping'});\n      }\n    });\n    self.heartbeat.start();\n  }\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n  sendReady: function (subscriptionIds) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"ready\", subs: subscriptionIds});\n    else {\n      _.each(subscriptionIds, function (subscriptionId) {\n        self._pendingReady.push(subscriptionId);\n      });\n    }\n  },\n\n  sendAdded: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n  },\n\n  sendChanged: function (collectionName, id, fields) {\n    var self = this;\n    if (_.isEmpty(fields))\n      return;\n\n    if (self._isSending) {\n      self.send({\n        msg: \"changed\",\n        collection: collectionName,\n        id: id,\n        fields: fields\n      });\n    }\n  },\n\n  sendRemoved: function (collectionName, id) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"removed\", collection: collectionName, id: id});\n  },\n\n  getSendCallbacks: function () {\n    var self = this;\n    return {\n      added: _.bind(self.sendAdded, self),\n      changed: _.bind(self.sendChanged, self),\n      removed: _.bind(self.sendRemoved, self)\n    };\n  },\n\n  getCollectionView: function (collectionName) {\n    var self = this;\n    var ret = self.collectionViews.get(collectionName);\n    if (!ret) {\n      ret = new SessionCollectionView(collectionName,\n                                        self.getSendCallbacks());\n      self.collectionViews.set(collectionName, ret);\n    }\n    return ret;\n  },\n\n  added: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.added(subscriptionHandle, id, fields);\n  },\n\n  removed: function (subscriptionHandle, collectionName, id) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.removed(subscriptionHandle, id);\n    if (view.isEmpty()) {\n       self.collectionViews.delete(collectionName);\n    }\n  },\n\n  changed: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.changed(subscriptionHandle, id, fields);\n  },\n\n  startUniversalSubs: function () {\n    var self = this;\n    // Make a shallow copy of the set of universal handlers and start them. If\n    // additional universal publishers start while we're running them (due to\n    // yielding), they will run separately as part of Server.publish.\n    var handlers = _.clone(self.server.universal_publish_handlers);\n    _.each(handlers, function (handler) {\n      self._startSubscription(handler);\n    });\n  },\n\n  // Destroy this session and unregister it at the server.\n  close: function () {\n    var self = this;\n\n    // Destroy this session, even if it's not registered at the\n    // server. Stop all processing and tear everything down. If a socket\n    // was attached, close it.\n\n    // Already destroyed.\n    if (! self.inQueue)\n      return;\n\n    // Drop the merge box data immediately.\n    self.inQueue = null;\n    self.collectionViews = new Map();\n\n    if (self.heartbeat) {\n      self.heartbeat.stop();\n      self.heartbeat = null;\n    }\n\n    if (self.socket) {\n      self.socket.close();\n      self.socket._meteorSession = null;\n    }\n\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"sessions\", -1);\n\n    Meteor.defer(function () {\n      // stop callbacks can yield, so we defer this on close.\n      // sub._isDeactivated() detects that we set inQueue to null and\n      // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n      self._deactivateAllSubscriptions();\n\n      // Defer calling the close callbacks, so that the caller closing\n      // the session isn't waiting for all the callbacks to complete.\n      _.each(self._closeCallbacks, function (callback) {\n        callback();\n      });\n    });\n\n    // Unregister the session.\n    self.server._removeSession(self);\n  },\n\n  // Send a message (doing nothing if no socket is connected right now.)\n  // It should be a JSON object (it will be stringified.)\n  send: function (msg) {\n    var self = this;\n    if (self.socket) {\n      if (Meteor._printSentDDP)\n        Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n      self.socket.send(DDPCommon.stringifyDDP(msg));\n    }\n  },\n\n  // Send a connection error.\n  sendError: function (reason, offendingMessage) {\n    var self = this;\n    var msg = {msg: 'error', reason: reason};\n    if (offendingMessage)\n      msg.offendingMessage = offendingMessage;\n    self.send(msg);\n  },\n\n  // Process 'msg' as an incoming message. (But as a guard against\n  // race conditions during reconnection, ignore the message if\n  // 'socket' is not the currently connected socket.)\n  //\n  // We run the messages from the client one at a time, in the order\n  // given by the client. The message handler is passed an idempotent\n  // function 'unblock' which it may call to allow other messages to\n  // begin running in parallel in another fiber (for example, a method\n  // that wants to yield.) Otherwise, it is automatically unblocked\n  // when it returns.\n  //\n  // Actually, we don't have to 'totally order' the messages in this\n  // way, but it's the easiest thing that's correct. (unsub needs to\n  // be ordered against sub, methods need to be ordered against each\n  // other.)\n  processMessage: function (msg_in) {\n    var self = this;\n    if (!self.inQueue) // we have been destroyed.\n      return;\n\n    // Respond to ping and pong messages immediately without queuing.\n    // If the negotiated DDP version is \"pre1\" which didn't support\n    // pings, preserve the \"pre1\" behavior of responding with a \"bad\n    // request\" for the unknown messages.\n    //\n    // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n    // needs a Fiber. We could actually use regular setTimeout and avoid\n    // these new fibers, but it is easier to just make everything use\n    // Meteor.setTimeout and not think too hard.\n    //\n    // Any message counts as receiving a pong, as it demonstrates that\n    // the client is still alive.\n    if (self.heartbeat) {\n      Fiber(function () {\n        self.heartbeat.messageReceived();\n      }).run();\n    }\n\n    if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n      if (self._respondToPings)\n        self.send({msg: \"pong\", id: msg_in.id});\n      return;\n    }\n    if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n      // Since everything is a pong, nothing to do\n      return;\n    }\n\n    self.inQueue.push(msg_in);\n    if (self.workerRunning)\n      return;\n    self.workerRunning = true;\n\n    var processNext = function () {\n      var msg = self.inQueue && self.inQueue.shift();\n      if (!msg) {\n        self.workerRunning = false;\n        return;\n      }\n\n      Fiber(function () {\n        var blocked = true;\n\n        var unblock = function () {\n          if (!blocked)\n            return; // idempotent\n          blocked = false;\n          processNext();\n        };\n\n        self.server.onMessageHook.each(function (callback) {\n          callback(msg, self);\n          return true;\n        });\n\n        if (_.has(self.protocol_handlers, msg.msg))\n          self.protocol_handlers[msg.msg].call(self, msg, unblock);\n        else\n          self.sendError('Bad request', msg);\n        unblock(); // in case the handler didn't already do it\n      }).run();\n    };\n\n    processNext();\n  },\n\n  protocol_handlers: {\n    sub: function (msg) {\n      var self = this;\n\n      // reject malformed messages\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.name) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array))) {\n        self.sendError(\"Malformed subscription\", msg);\n        return;\n      }\n\n      if (!self.server.publish_handlers[msg.name]) {\n        self.send({\n          msg: 'nosub', id: msg.id,\n          error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n        return;\n      }\n\n      if (self._namedSubs.has(msg.id))\n        // subs are idempotent, or rather, they are ignored if a sub\n        // with that id already exists. this is important during\n        // reconnect.\n        return;\n\n      // XXX It'd be much better if we had generic hooks where any package can\n      // hook into subscription handling, but in the mean while we special case\n      // ddp-rate-limiter package. This is also done for weak requirements to\n      // add the ddp-rate-limiter package in case we don't have Accounts. A\n      // user trying to use the ddp-rate-limiter must explicitly require it.\n      if (Package['ddp-rate-limiter']) {\n        var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n        var rateLimiterInput = {\n          userId: self.userId,\n          clientAddress: self.connectionHandle.clientAddress,\n          type: \"subscription\",\n          name: msg.name,\n          connectionId: self.id\n        };\n\n        DDPRateLimiter._increment(rateLimiterInput);\n        var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n        if (!rateLimitResult.allowed) {\n          self.send({\n            msg: 'nosub', id: msg.id,\n            error: new Meteor.Error(\n              'too-many-requests',\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset})\n          });\n          return;\n        }\n      }\n\n      var handler = self.server.publish_handlers[msg.name];\n\n      self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n    },\n\n    unsub: function (msg) {\n      var self = this;\n\n      self._stopSubscription(msg.id);\n    },\n\n    method: function (msg, unblock) {\n      var self = this;\n\n      // reject malformed messages\n      // For now, we silently ignore unknown attributes,\n      // for forwards compatibility.\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.method) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array)) ||\n          (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n        self.sendError(\"Malformed method invocation\", msg);\n        return;\n      }\n\n      var randomSeed = msg.randomSeed || null;\n\n      // set up to mark the method as satisfied once all observers\n      // (and subscriptions) have reacted to any writes that were\n      // done.\n      var fence = new DDPServer._WriteFence;\n      fence.onAllCommitted(function () {\n        // Retire the fence so that future writes are allowed.\n        // This means that callbacks like timers are free to use\n        // the fence, and if they fire before it's armed (for\n        // example, because the method waits for them) their\n        // writes will be included in the fence.\n        fence.retire();\n        self.send({\n          msg: 'updated', methods: [msg.id]});\n      });\n\n      // find the handler\n      var handler = self.server.method_handlers[msg.method];\n      if (!handler) {\n        self.send({\n          msg: 'result', id: msg.id,\n          error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n        fence.arm();\n        return;\n      }\n\n      var setUserId = function(userId) {\n        self._setUserId(userId);\n      };\n\n      var invocation = new DDPCommon.MethodInvocation({\n        isSimulation: false,\n        userId: self.userId,\n        setUserId: setUserId,\n        unblock: unblock,\n        connection: self.connectionHandle,\n        randomSeed: randomSeed\n      });\n\n      const promise = new Promise((resolve, reject) => {\n        // XXX It'd be better if we could hook into method handlers better but\n        // for now, we need to check if the ddp-rate-limiter exists since we\n        // have a weak requirement for the ddp-rate-limiter package to be added\n        // to our application.\n        if (Package['ddp-rate-limiter']) {\n          var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n          var rateLimiterInput = {\n            userId: self.userId,\n            clientAddress: self.connectionHandle.clientAddress,\n            type: \"method\",\n            name: msg.method,\n            connectionId: self.id\n          };\n          DDPRateLimiter._increment(rateLimiterInput);\n          var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n          if (!rateLimitResult.allowed) {\n            reject(new Meteor.Error(\n              \"too-many-requests\",\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset}\n            ));\n            return;\n          }\n        }\n\n        resolve(DDPServer._CurrentWriteFence.withValue(\n          fence,\n          () => DDP._CurrentMethodInvocation.withValue(\n            invocation,\n            () => maybeAuditArgumentChecks(\n              handler, invocation, msg.params,\n              \"call to '\" + msg.method + \"'\"\n            )\n          )\n        ));\n      });\n\n      function finish() {\n        fence.arm();\n        unblock();\n      }\n\n      const payload = {\n        msg: \"result\",\n        id: msg.id\n      };\n\n      promise.then((result) => {\n        finish();\n        if (result !== undefined) {\n          payload.result = result;\n        }\n        self.send(payload);\n      }, (exception) => {\n        finish();\n        payload.error = wrapInternalException(\n          exception,\n          `while invoking method '${msg.method}'`\n        );\n        self.send(payload);\n      });\n    }\n  },\n\n  _eachSub: function (f) {\n    var self = this;\n    self._namedSubs.forEach(f);\n    self._universalSubs.forEach(f);\n  },\n\n  _diffCollectionViews: function (beforeCVs) {\n    var self = this;\n    DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n      both: function (collectionName, leftValue, rightValue) {\n        rightValue.diff(leftValue);\n      },\n      rightOnly: function (collectionName, rightValue) {\n        rightValue.documents.forEach(function (docView, id) {\n          self.sendAdded(collectionName, id, docView.getFields());\n        });\n      },\n      leftOnly: function (collectionName, leftValue) {\n        leftValue.documents.forEach(function (doc, id) {\n          self.sendRemoved(collectionName, id);\n        });\n      }\n    });\n  },\n\n  // Sets the current user id in all appropriate contexts and reruns\n  // all subscriptions\n  _setUserId: function(userId) {\n    var self = this;\n\n    if (userId !== null && typeof userId !== \"string\")\n      throw new Error(\"setUserId must be called on string or null, not \" +\n                      typeof userId);\n\n    // Prevent newly-created universal subscriptions from being added to our\n    // session; they will be found below when we call startUniversalSubs.\n    //\n    // (We don't have to worry about named subscriptions, because we only add\n    // them when we process a 'sub' message. We are currently processing a\n    // 'method' message, and the method did not unblock, because it is illegal\n    // to call setUserId after unblock. Thus we cannot be concurrently adding a\n    // new named subscription.)\n    self._dontStartNewUniversalSubs = true;\n\n    // Prevent current subs from updating our collectionViews and call their\n    // stop callbacks. This may yield.\n    self._eachSub(function (sub) {\n      sub._deactivate();\n    });\n\n    // All subs should now be deactivated. Stop sending messages to the client,\n    // save the state of the published collections, reset to an empty view, and\n    // update the userId.\n    self._isSending = false;\n    var beforeCVs = self.collectionViews;\n    self.collectionViews = new Map();\n    self.userId = userId;\n\n    // _setUserId is normally called from a Meteor method with\n    // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n    // expected to be set inside a publish function, so we temporary unset it.\n    // Inside a publish function DDP._CurrentPublicationInvocation is set.\n    DDP._CurrentMethodInvocation.withValue(undefined, function () {\n      // Save the old named subs, and reset to having no subscriptions.\n      var oldNamedSubs = self._namedSubs;\n      self._namedSubs = new Map();\n      self._universalSubs = [];\n\n      oldNamedSubs.forEach(function (sub, subscriptionId) {\n        var newSub = sub._recreate();\n        self._namedSubs.set(subscriptionId, newSub);\n        // nb: if the handler throws or calls this.error(), it will in fact\n        // immediately send its 'nosub'. This is OK, though.\n        newSub._runHandler();\n      });\n\n      // Allow newly-created universal subs to be started on our connection in\n      // parallel with the ones we're spinning up here, and spin up universal\n      // subs.\n      self._dontStartNewUniversalSubs = false;\n      self.startUniversalSubs();\n    });\n\n    // Start sending messages again, beginning with the diff from the previous\n    // state of the world to the current state. No yields are allowed during\n    // this diff, so that other changes cannot interleave.\n    Meteor._noYieldsAllowed(function () {\n      self._isSending = true;\n      self._diffCollectionViews(beforeCVs);\n      if (!_.isEmpty(self._pendingReady)) {\n        self.sendReady(self._pendingReady);\n        self._pendingReady = [];\n      }\n    });\n  },\n\n  _startSubscription: function (handler, subId, params, name) {\n    var self = this;\n\n    var sub = new Subscription(\n      self, handler, subId, params, name);\n    if (subId)\n      self._namedSubs.set(subId, sub);\n    else\n      self._universalSubs.push(sub);\n\n    sub._runHandler();\n  },\n\n  // tear down specified subscription\n  _stopSubscription: function (subId, error) {\n    var self = this;\n\n    var subName = null;\n    if (subId) {\n      var maybeSub = self._namedSubs.get(subId);\n      if (maybeSub) {\n        subName = maybeSub._name;\n        maybeSub._removeAllDocuments();\n        maybeSub._deactivate();\n        self._namedSubs.delete(subId);\n      }\n    }\n\n    var response = {msg: 'nosub', id: subId};\n\n    if (error) {\n      response.error = wrapInternalException(\n        error,\n        subName ? (\"from sub \" + subName + \" id \" + subId)\n          : (\"from sub id \" + subId));\n    }\n\n    self.send(response);\n  },\n\n  // tear down all subscriptions. Note that this does NOT send removed or nosub\n  // messages, since we assume the client is gone.\n  _deactivateAllSubscriptions: function () {\n    var self = this;\n\n    self._namedSubs.forEach(function (sub, id) {\n      sub._deactivate();\n    });\n    self._namedSubs = new Map();\n\n    self._universalSubs.forEach(function (sub) {\n      sub._deactivate();\n    });\n    self._universalSubs = [];\n  },\n\n  // Determine the remote client's IP address, based on the\n  // HTTP_FORWARDED_COUNT environment variable representing how many\n  // proxies the server is behind.\n  _clientAddress: function () {\n    var self = this;\n\n    // For the reported client address for a connection to be correct,\n    // the developer must set the HTTP_FORWARDED_COUNT environment\n    // variable to an integer representing the number of hops they\n    // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n    // server is behind one proxy.\n    //\n    // This could be computed once at startup instead of every time.\n    var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n    if (httpForwardedCount === 0)\n      return self.socket.remoteAddress;\n\n    var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n    if (! _.isString(forwardedFor))\n      return null;\n    forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n    // Typically the first value in the `x-forwarded-for` header is\n    // the original IP address of the client connecting to the first\n    // proxy.  However, the end user can easily spoof the header, in\n    // which case the first value(s) will be the fake IP address from\n    // the user pretending to be a proxy reporting the original IP\n    // address value.  By counting HTTP_FORWARDED_COUNT back from the\n    // end of the list, we ensure that we get the IP address being\n    // reported by *our* first proxy.\n\n    if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n      return null;\n\n    return forwardedFor[forwardedFor.length - httpForwardedCount];\n  }\n});\n\n/******************************************************************************/\n/* Subscription                                                               */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n    session, handler, subscriptionId, params, name) {\n  var self = this;\n  self._session = session; // type is Session\n\n  /**\n   * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n   * @locus Server\n   * @name  connection\n   * @memberOf Subscription\n   * @instance\n   */\n  self.connection = session.connectionHandle; // public API object\n\n  self._handler = handler;\n\n  // my subscription ID (generated by client, undefined for universal subs).\n  self._subscriptionId = subscriptionId;\n  // undefined for universal subs\n  self._name = name;\n\n  self._params = params || [];\n\n  // Only named subscriptions have IDs, but we need some sort of string\n  // internally to keep track of all subscriptions inside\n  // SessionDocumentViews. We use this subscriptionHandle for that.\n  if (self._subscriptionId) {\n    self._subscriptionHandle = 'N' + self._subscriptionId;\n  } else {\n    self._subscriptionHandle = 'U' + Random.id();\n  }\n\n  // has _deactivate been called?\n  self._deactivated = false;\n\n  // stop callbacks to g/c this sub.  called w/ zero arguments.\n  self._stopCallbacks = [];\n\n  // the set of (collection, documentid) that this subscription has\n  // an opinion about\n  self._documents = new Map();\n\n  // remember if we are ready.\n  self._ready = false;\n\n  // Part of the public API: the user of this sub.\n\n  /**\n   * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n   * @locus Server\n   * @memberOf Subscription\n   * @name  userId\n   * @instance\n   */\n  self.userId = session.userId;\n\n  // For now, the id filter is going to default to\n  // the to/from DDP methods on MongoID, to\n  // specifically deal with mongo/minimongo ObjectIds.\n\n  // Later, you will be able to make this be \"raw\"\n  // if you want to publish a collection that you know\n  // just has strings for keys and no funny business, to\n  // a ddp consumer that isn't minimongo\n\n  self._idFilter = {\n    idStringify: MongoID.idStringify,\n    idParse: MongoID.idParse\n  };\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n  _runHandler: function () {\n    // XXX should we unblock() here? Either before running the publish\n    // function, or before running _publishCursor.\n    //\n    // Right now, each publish function blocks all future publishes and\n    // methods waiting on data from Mongo (or whatever else the function\n    // blocks on). This probably slows page load in common cases.\n\n    var self = this;\n    try {\n      var res = DDP._CurrentPublicationInvocation.withValue(\n        self,\n        () => maybeAuditArgumentChecks(\n          self._handler, self, EJSON.clone(self._params),\n          // It's OK that this would look weird for universal subscriptions,\n          // because they have no arguments so there can never be an\n          // audit-argument-checks failure.\n          \"publisher '\" + self._name + \"'\"\n        )\n      );\n    } catch (e) {\n      self.error(e);\n      return;\n    }\n\n    // Did the handler call this.error or this.stop?\n    if (self._isDeactivated())\n      return;\n\n    self._publishHandlerResult(res);\n  },\n\n  _publishHandlerResult: function (res) {\n    // SPECIAL CASE: Instead of writing their own callbacks that invoke\n    // this.added/changed/ready/etc, the user can just return a collection\n    // cursor or array of cursors from the publish function; we call their\n    // _publishCursor method which starts observing the cursor and publishes the\n    // results. Note that _publishCursor does NOT call ready().\n    //\n    // XXX This uses an undocumented interface which only the Mongo cursor\n    // interface publishes. Should we make this interface public and encourage\n    // users to implement it themselves? Arguably, it's unnecessary; users can\n    // already write their own functions like\n    //   var publishMyReactiveThingy = function (name, handler) {\n    //     Meteor.publish(name, function () {\n    //       var reactiveThingy = handler();\n    //       reactiveThingy.publishMe();\n    //     });\n    //   };\n\n    var self = this;\n    var isCursor = function (c) {\n      return c && c._publishCursor;\n    };\n    if (isCursor(res)) {\n      try {\n        res._publishCursor(self);\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      // _publishCursor only returns after the initial added callbacks have run.\n      // mark subscription as ready.\n      self.ready();\n    } else if (_.isArray(res)) {\n      // check all the elements are cursors\n      if (! _.all(res, isCursor)) {\n        self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n        return;\n      }\n      // find duplicate collection names\n      // XXX we should support overlapping cursors, but that would require the\n      // merge box to allow overlap within a subscription\n      var collectionNames = {};\n      for (var i = 0; i < res.length; ++i) {\n        var collectionName = res[i]._getCollectionName();\n        if (_.has(collectionNames, collectionName)) {\n          self.error(new Error(\n            \"Publish function returned multiple cursors for collection \" +\n              collectionName));\n          return;\n        }\n        collectionNames[collectionName] = true;\n      };\n\n      try {\n        _.each(res, function (cur) {\n          cur._publishCursor(self);\n        });\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      self.ready();\n    } else if (res) {\n      // truthy values other than cursors or arrays are probably a\n      // user mistake (possible returning a Mongo document via, say,\n      // `coll.findOne()`).\n      self.error(new Error(\"Publish function can only return a Cursor or \"\n                           + \"an array of Cursors\"));\n    }\n  },\n\n  // This calls all stop callbacks and prevents the handler from updating any\n  // SessionCollectionViews further. It's used when the user unsubscribes or\n  // disconnects, as well as during setUserId re-runs. It does *NOT* send\n  // removed messages for the published objects; if that is necessary, call\n  // _removeAllDocuments first.\n  _deactivate: function() {\n    var self = this;\n    if (self._deactivated)\n      return;\n    self._deactivated = true;\n    self._callStopCallbacks();\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"subscriptions\", -1);\n  },\n\n  _callStopCallbacks: function () {\n    var self = this;\n    // tell listeners, so they can clean up\n    var callbacks = self._stopCallbacks;\n    self._stopCallbacks = [];\n    _.each(callbacks, function (callback) {\n      callback();\n    });\n  },\n\n  // Send remove messages for every document.\n  _removeAllDocuments: function () {\n    var self = this;\n    Meteor._noYieldsAllowed(function () {\n      self._documents.forEach(function (collectionDocs, collectionName) {\n        collectionDocs.forEach(function (strId) {\n          self.removed(collectionName, self._idFilter.idParse(strId));\n        });\n      });\n    });\n  },\n\n  // Returns a new Subscription for the same session with the same\n  // initial creation parameters. This isn't a clone: it doesn't have\n  // the same _documents cache, stopped state or callbacks; may have a\n  // different _subscriptionHandle, and gets its userId from the\n  // session, not from this object.\n  _recreate: function () {\n    var self = this;\n    return new Subscription(\n      self._session, self._handler, self._subscriptionId, self._params,\n      self._name);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n   * @locus Server\n   * @param {Error} error The error to pass to the client.\n   * @instance\n   * @memberOf Subscription\n   */\n  error: function (error) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId, error);\n  },\n\n  // Note that while our DDP client will notice that you've called stop() on the\n  // server (and clean up its _subscriptions table) we don't actually provide a\n  // mechanism for an app to notice this (the subscribe onError callback only\n  // triggers if there is an error).\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.\n   * @locus Server\n   * @instance\n   * @memberOf Subscription\n   */\n  stop: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {Function} func The callback function\n   */\n  onStop: function (callback) {\n    var self = this;\n    callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n    if (self._isDeactivated())\n      callback();\n    else\n      self._stopCallbacks.push(callback);\n  },\n\n  // This returns true if the sub has been deactivated, *OR* if the session was\n  // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n  // happened yet.\n  _isDeactivated: function () {\n    var self = this;\n    return self._deactivated || self._session.inQueue === null;\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the new document.\n   * @param {String} id The new document's ID.\n   * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.\n   */\n  added: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    let ids = self._documents.get(collectionName);\n    if (ids == null) {\n      ids = new Set();\n      self._documents.set(collectionName, ids);\n    }\n    ids.add(id);\n    self._session.added(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the changed document.\n   * @param {String} id The changed document's ID.\n   * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.\n   */\n  changed: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that the document has been removed from.\n   * @param {String} id The ID of the document that has been removed.\n   */\n  removed: function (collectionName, id) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    // We don't bother to delete sets of things in a collection if the\n    // collection is empty.  It could break _removeAllDocuments.\n    self._documents.get(collectionName).delete(id);\n    self._session.removed(self._subscriptionHandle, collectionName, id);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   */\n  ready: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    if (!self._subscriptionId)\n      return;  // unnecessary but ignored for universal sub\n    if (!self._ready) {\n      self._session.sendReady([self._subscriptionId]);\n      self._ready = true;\n    }\n  }\n});\n\n/******************************************************************************/\n/* Server                                                                     */\n/******************************************************************************/\n\nServer = function (options) {\n  var self = this;\n\n  // The default heartbeat interval is 30 seconds on the server and 35\n  // seconds on the client.  Since the client doesn't need to send a\n  // ping as long as it is receiving pings, this means that pings\n  // normally go from the server to the client.\n  //\n  // Note: Troposphere depends on the ability to mutate\n  // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n  self.options = _.defaults(options || {}, {\n    heartbeatInterval: 15000,\n    heartbeatTimeout: 15000,\n    // For testing, allow responding to pings to be disabled.\n    respondToPings: true\n  });\n\n  // Map of callbacks to call when a new connection comes in to the\n  // server and completes DDP version negotiation. Use an object instead\n  // of an array so we can safely remove one from the list while\n  // iterating over it.\n  self.onConnectionHook = new Hook({\n    debugPrintExceptions: \"onConnection callback\"\n  });\n\n  // Map of callbacks to call when a new message comes in.\n  self.onMessageHook = new Hook({\n    debugPrintExceptions: \"onMessage callback\"\n  });\n\n  self.publish_handlers = {};\n  self.universal_publish_handlers = [];\n\n  self.method_handlers = {};\n\n  self.sessions = new Map(); // map from id to session\n\n  self.stream_server = new StreamServer;\n\n  self.stream_server.register(function (socket) {\n    // socket implements the SockJSConnection interface\n    socket._meteorSession = null;\n\n    var sendError = function (reason, offendingMessage) {\n      var msg = {msg: 'error', reason: reason};\n      if (offendingMessage)\n        msg.offendingMessage = offendingMessage;\n      socket.send(DDPCommon.stringifyDDP(msg));\n    };\n\n    socket.on('data', function (raw_msg) {\n      if (Meteor._printReceivedDDP) {\n        Meteor._debug(\"Received DDP\", raw_msg);\n      }\n      try {\n        try {\n          var msg = DDPCommon.parseDDP(raw_msg);\n        } catch (err) {\n          sendError('Parse error');\n          return;\n        }\n        if (msg === null || !msg.msg) {\n          sendError('Bad request', msg);\n          return;\n        }\n\n        if (msg.msg === 'connect') {\n          if (socket._meteorSession) {\n            sendError(\"Already connected\", msg);\n            return;\n          }\n          Fiber(function () {\n            self._handleConnect(socket, msg);\n          }).run();\n          return;\n        }\n\n        if (!socket._meteorSession) {\n          sendError('Must connect first', msg);\n          return;\n        }\n        socket._meteorSession.processMessage(msg);\n      } catch (e) {\n        // XXX print stack nicely\n        Meteor._debug(\"Internal exception while processing message\", msg, e);\n      }\n    });\n\n    socket.on('close', function () {\n      if (socket._meteorSession) {\n        Fiber(function () {\n          socket._meteorSession.close();\n        }).run();\n      }\n    });\n  });\n};\n\n_.extend(Server.prototype, {\n\n  /**\n   * @summary Register a callback to be called when a new DDP connection is made to the server.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP connection is established.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onConnection: function (fn) {\n    var self = this;\n    return self.onConnectionHook.register(fn);\n  },\n\n  /**\n   * @summary Register a callback to be called when a new DDP message is received.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP message is received.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onMessage: function (fn) {\n    var self = this;\n    return self.onMessageHook.register(fn);\n  },\n\n  _handleConnect: function (socket, msg) {\n    var self = this;\n\n    // The connect message must specify a version and an array of supported\n    // versions, and it must claim to support what it is proposing.\n    if (!(typeof (msg.version) === 'string' &&\n          _.isArray(msg.support) &&\n          _.all(msg.support, _.isString) &&\n          _.contains(msg.support, msg.version))) {\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n                                version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n      socket.close();\n      return;\n    }\n\n    // In the future, handle session resumption: something like:\n    //  socket._meteorSession = self.sessions[msg.session]\n    var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n    if (msg.version !== version) {\n      // The best version to use (according to the client's stated preferences)\n      // is not the one the client is trying to use. Inform them about the best\n      // version to use.\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n      socket.close();\n      return;\n    }\n\n    // Yay, version matches! Create a new session.\n    // Note: Troposphere depends on the ability to mutate\n    // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n    socket._meteorSession = new Session(self, version, socket, self.options);\n    self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n    self.onConnectionHook.each(function (callback) {\n      if (socket._meteorSession)\n        callback(socket._meteorSession.connectionHandle);\n      return true;\n    });\n  },\n  /**\n   * Register a publish handler function.\n   *\n   * @param name {String} identifier for query\n   * @param handler {Function} publish handler\n   * @param options {Object}\n   *\n   * Server will call handler function on each new subscription,\n   * either when receiving DDP sub message for a named subscription, or on\n   * DDP connect for a universal subscription.\n   *\n   * If name is null, this will be a subscription that is\n   * automatically established and permanently on for all connected\n   * client, instead of a subscription that can be turned on and off\n   * with subscribe().\n   *\n   * options to contain:\n   *  - (mostly internal) is_auto: true if generated automatically\n   *    from an autopublish hook. this is for cosmetic purposes only\n   *    (it lets us determine whether to print a warning suggesting\n   *    that you turn off autopublish.)\n   */\n\n  /**\n   * @summary Publish a record set.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   * @locus Server\n   * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n   * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.\n   */\n  publish: function (name, handler, options) {\n    var self = this;\n\n    if (! _.isObject(name)) {\n      options = options || {};\n\n      if (name && name in self.publish_handlers) {\n        Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n        return;\n      }\n\n      if (Package.autopublish && !options.is_auto) {\n        // They have autopublish on, yet they're trying to manually\n        // picking stuff to publish. They probably should turn off\n        // autopublish. (This check isn't perfect -- if you create a\n        // publish before you turn on autopublish, it won't catch\n        // it. But this will definitely handle the simple case where\n        // you've added the autopublish package to your app, and are\n        // calling publish from your app code.)\n        if (!self.warned_about_autopublish) {\n          self.warned_about_autopublish = true;\n          Meteor._debug(\n    \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n    \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n    \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n    \"** will still be sent to all clients.\\n\" +\n    \"**\\n\" +\n    \"** Turn off autopublish by removing the autopublish package:\\n\" +\n    \"**\\n\" +\n    \"**   $ meteor remove autopublish\\n\" +\n    \"**\\n\" +\n    \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n    \"** for each collection that you want clients to see.\\n\");\n        }\n      }\n\n      if (name)\n        self.publish_handlers[name] = handler;\n      else {\n        self.universal_publish_handlers.push(handler);\n        // Spin up the new publisher on any existing session too. Run each\n        // session's subscription in a new Fiber, so that there's no change for\n        // self.sessions to change while we're running this loop.\n        self.sessions.forEach(function (session) {\n          if (!session._dontStartNewUniversalSubs) {\n            Fiber(function() {\n              session._startSubscription(handler);\n            }).run();\n          }\n        });\n      }\n    }\n    else{\n      _.each(name, function(value, key) {\n        self.publish(key, value, {});\n      });\n    }\n  },\n\n  _removeSession: function (session) {\n    var self = this;\n    self.sessions.delete(session.id);\n  },\n\n  /**\n   * @summary Defines functions that can be invoked over the network by clients.\n   * @locus Anywhere\n   * @param {Object} methods Dictionary whose keys are method names and values are functions.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  methods: function (methods) {\n    var self = this;\n    _.each(methods, function (func, name) {\n      if (typeof func !== 'function')\n        throw new Error(\"Method '\" + name + \"' must be a function\");\n      if (self.method_handlers[name])\n        throw new Error(\"A method named '\" + name + \"' is already defined\");\n      self.method_handlers[name] = func;\n    });\n  },\n\n  call: function (name, ...args) {\n    if (args.length && typeof args[args.length - 1] === \"function\") {\n      // If it's a function, the last argument is the result callback, not\n      // a parameter to the remote method.\n      var callback = args.pop();\n    }\n\n    return this.apply(name, args, callback);\n  },\n\n  // A version of the call method that always returns a Promise.\n  callAsync: function (name, ...args) {\n    return this.applyAsync(name, args);\n  },\n\n  apply: function (name, args, options, callback) {\n    // We were passed 3 arguments. They may be either (name, args, options)\n    // or (name, args, callback)\n    if (! callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    } else {\n      options = options || {};\n    }\n\n    const promise = this.applyAsync(name, args, options);\n\n    // Return the result in whichever way the caller asked for it. Note that we\n    // do NOT block on the write fence in an analogous way to how the client\n    // blocks on the relevant data being visible, so you are NOT guaranteed that\n    // cursor observe callbacks have fired when your callback is invoked. (We\n    // can change this if there's a real use case.)\n    if (callback) {\n      promise.then(\n        result => callback(undefined, result),\n        exception => callback(exception)\n      );\n    } else {\n      return promise.await();\n    }\n  },\n\n  // @param options {Optional Object}\n  applyAsync: function (name, args, options) {\n    // Run the handler\n    var handler = this.method_handlers[name];\n    if (! handler) {\n      return Promise.reject(\n        new Meteor.Error(404, `Method '${name}' not found`)\n      );\n    }\n\n    // If this is a method call from within another method or publish function,\n    // get the user state from the outer method or publish function, otherwise\n    // don't allow setUserId to be called\n    var userId = null;\n    var setUserId = function() {\n      throw new Error(\"Can't call setUserId on a server initiated method call\");\n    };\n    var connection = null;\n    var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n    var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n    var randomSeed = null;\n    if (currentMethodInvocation) {\n      userId = currentMethodInvocation.userId;\n      setUserId = function(userId) {\n        currentMethodInvocation.setUserId(userId);\n      };\n      connection = currentMethodInvocation.connection;\n      randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n    } else if (currentPublicationInvocation) {\n      userId = currentPublicationInvocation.userId;\n      setUserId = function(userId) {\n        currentPublicationInvocation._session._setUserId(userId);\n      };\n      connection = currentPublicationInvocation.connection;\n    }\n\n    var invocation = new DDPCommon.MethodInvocation({\n      isSimulation: false,\n      userId,\n      setUserId,\n      connection,\n      randomSeed\n    });\n\n    return new Promise(resolve => resolve(\n      DDP._CurrentMethodInvocation.withValue(\n        invocation,\n        () => maybeAuditArgumentChecks(\n          handler, invocation, EJSON.clone(args),\n          \"internal call to '\" + name + \"'\"\n        )\n      )\n    )).then(EJSON.clone);\n  },\n\n  _urlForSession: function (sessionId) {\n    var self = this;\n    var session = self.sessions.get(sessionId);\n    if (session)\n      return session._socketUrl;\n    else\n      return null;\n  }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n                                 serverSupportedVersions) {\n  var correctVersion = _.find(clientSupportedVersions, function (version) {\n    return _.contains(serverSupportedVersions, version);\n  });\n  if (!correctVersion) {\n    correctVersion = serverSupportedVersions[0];\n  }\n  return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n  if (!exception) return exception;\n\n  // To allow packages to throw errors intended for the client but not have to\n  // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n  // error before it is thrown.\n  if (exception.isClientSafe) {\n    if (!(exception instanceof Meteor.Error)) {\n      const originalMessage = exception.message;\n      exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n      exception.message = originalMessage;\n    }\n    return exception;\n  }\n\n  // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n  // the server log.\n  if (!exception._expectedByTest) {\n    Meteor._debug(\"Exception \" + context, exception.stack);\n    if (exception.sanitizedError) {\n      Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n      Meteor._debug();\n    }\n  }\n\n  // Did the error contain more details that could have been useful if caught in\n  // server code (or if thrown from non-client-originated code), but also\n  // provided a \"sanitized\" version with more context than 500 Internal server\n  // error? Use that.\n  if (exception.sanitizedError) {\n    if (exception.sanitizedError.isClientSafe)\n      return exception.sanitizedError;\n    Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n                  \"does not have isClientSafe property set; ignoring\");\n  }\n\n  return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n  args = args || [];\n  if (Package['audit-argument-checks']) {\n    return Match._failIfArgumentsAreNotAllChecked(\n      f, context, args, description);\n  }\n  return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n  var self = this;\n\n  self.armed = false;\n  self.fired = false;\n  self.retired = false;\n  self.outstanding_writes = 0;\n  self.before_fire_callbacks = [];\n  self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n  // Start tracking a write, and return an object to represent it. The\n  // object has a single method, committed(). This method should be\n  // called when the write is fully committed and propagated. You can\n  // continue to add writes to the WriteFence up until it is triggered\n  // (calls its callbacks because all writes have committed.)\n  beginWrite: function () {\n    var self = this;\n\n    if (self.retired)\n      return { committed: function () {} };\n\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to add writes\");\n\n    self.outstanding_writes++;\n    var committed = false;\n    return {\n      committed: function () {\n        if (committed)\n          throw new Error(\"committed called twice on the same write\");\n        committed = true;\n        self.outstanding_writes--;\n        self._maybeFire();\n      }\n    };\n  },\n\n  // Arm the fence. Once the fence is armed, and there are no more\n  // uncommitted writes, it will activate.\n  arm: function () {\n    var self = this;\n    if (self === DDPServer._CurrentWriteFence.get())\n      throw Error(\"Can't arm the current fence\");\n    self.armed = true;\n    self._maybeFire();\n  },\n\n  // Register a function to be called once before firing the fence.\n  // Callback function can add new writes to the fence, in which case\n  // it won't fire until those writes are done as well.\n  onBeforeFire: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.before_fire_callbacks.push(func);\n  },\n\n  // Register a function to be called when the fence fires.\n  onAllCommitted: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.completion_callbacks.push(func);\n  },\n\n  // Convenience function. Arms the fence, then blocks until it fires.\n  armAndWait: function () {\n    var self = this;\n    var future = new Future;\n    self.onAllCommitted(function () {\n      future['return']();\n    });\n    self.arm();\n    future.wait();\n  },\n\n  _maybeFire: function () {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"write fence already activated?\");\n    if (self.armed && !self.outstanding_writes) {\n      function invokeCallback (func) {\n        try {\n          func(self);\n        } catch (err) {\n          Meteor._debug(\"exception in write fence callback\", err);\n        }\n      }\n\n      self.outstanding_writes++;\n      while (self.before_fire_callbacks.length > 0) {\n        var callbacks = self.before_fire_callbacks;\n        self.before_fire_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n      self.outstanding_writes--;\n\n      if (!self.outstanding_writes) {\n        self.fired = true;\n        var callbacks = self.completion_callbacks;\n        self.completion_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n    }\n  },\n\n  // Deactivate this fence so that adding more writes has no effect.\n  // The fence must have already fired.\n  retire: function () {\n    var self = this;\n    if (! self.fired)\n      throw new Error(\"Can't retire a fence that hasn't fired.\");\n    self.retired = true;\n  }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n  var self = this;\n  options = options || {};\n\n  self.nextId = 1;\n  // map from collection name (string) -> listener id -> object. each object has\n  // keys 'trigger', 'callback'.  As a hack, the empty string means \"no\n  // collection\".\n  self.listenersByCollection = {};\n  self.listenersByCollectionCount = {};\n  self.factPackage = options.factPackage || \"livedata\";\n  self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n  // msg is a trigger or a notification\n  _collectionForMessage: function (msg) {\n    var self = this;\n    if (! _.has(msg, 'collection')) {\n      return '';\n    } else if (typeof(msg.collection) === 'string') {\n      if (msg.collection === '')\n        throw Error(\"Message has empty collection!\");\n      return msg.collection;\n    } else {\n      throw Error(\"Message has non-string collection!\");\n    }\n  },\n\n  // Listen for notification that match 'trigger'. A notification\n  // matches if it has the key-value pairs in trigger as a\n  // subset. When a notification matches, call 'callback', passing\n  // the actual notification.\n  //\n  // Returns a listen handle, which is an object with a method\n  // stop(). Call stop() to stop listening.\n  //\n  // XXX It should be legal to call fire() from inside a listen()\n  // callback?\n  listen: function (trigger, callback) {\n    var self = this;\n    var id = self.nextId++;\n\n    var collection = self._collectionForMessage(trigger);\n    var record = {trigger: EJSON.clone(trigger), callback: callback};\n    if (! _.has(self.listenersByCollection, collection)) {\n      self.listenersByCollection[collection] = {};\n      self.listenersByCollectionCount[collection] = 0;\n    }\n    self.listenersByCollection[collection][id] = record;\n    self.listenersByCollectionCount[collection]++;\n\n    if (self.factName && Package['facts-base']) {\n      Package['facts-base'].Facts.incrementServerFact(\n        self.factPackage, self.factName, 1);\n    }\n\n    return {\n      stop: function () {\n        if (self.factName && Package['facts-base']) {\n          Package['facts-base'].Facts.incrementServerFact(\n            self.factPackage, self.factName, -1);\n        }\n        delete self.listenersByCollection[collection][id];\n        self.listenersByCollectionCount[collection]--;\n        if (self.listenersByCollectionCount[collection] === 0) {\n          delete self.listenersByCollection[collection];\n          delete self.listenersByCollectionCount[collection];\n        }\n      }\n    };\n  },\n\n  // Fire the provided 'notification' (an object whose attribute\n  // values are all JSON-compatibile) -- inform all matching listeners\n  // (registered with listen()).\n  //\n  // If fire() is called inside a write fence, then each of the\n  // listener callbacks will be called inside the write fence as well.\n  //\n  // The listeners may be invoked in parallel, rather than serially.\n  fire: function (notification) {\n    var self = this;\n\n    var collection = self._collectionForMessage(notification);\n\n    if (! _.has(self.listenersByCollection, collection)) {\n      return;\n    }\n\n    var listenersForCollection = self.listenersByCollection[collection];\n    var callbackIds = [];\n    _.each(listenersForCollection, function (l, id) {\n      if (self._matches(notification, l.trigger)) {\n        callbackIds.push(id);\n      }\n    });\n\n    // Listener callbacks can yield, so we need to first find all the ones that\n    // match in a single iteration over self.listenersByCollection (which can't\n    // be mutated during this iteration), and then invoke the matching\n    // callbacks, checking before each call to ensure they haven't stopped.\n    // Note that we don't have to check that\n    // self.listenersByCollection[collection] still === listenersForCollection,\n    // because the only way that stops being true is if listenersForCollection\n    // first gets reduced down to the empty object (and then never gets\n    // increased again).\n    _.each(callbackIds, function (id) {\n      if (_.has(listenersForCollection, id)) {\n        listenersForCollection[id].callback(notification);\n      }\n    });\n  },\n\n  // A notification matches a trigger if all keys that exist in both are equal.\n  //\n  // Examples:\n  //  N:{collection: \"C\"} matches T:{collection: \"C\"}\n  //    (a non-targeted write to a collection matches a\n  //     non-targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n  //    (a targeted write to a collection matches a non-targeted query)\n  //  N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a non-targeted write to a collection matches a\n  //     targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a targeted write to a collection matches a targeted query targeted\n  //     at the same document)\n  //  N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n  //    (a targeted write to a collection does not match a targeted query\n  //     targeted at a different document)\n  _matches: function (notification, trigger) {\n    // Most notifications that use the crossbar have a string `collection` and\n    // maybe an `id` that is a string or ObjectID. We're already dividing up\n    // triggers by collection, but let's fast-track \"nope, different ID\" (and\n    // avoid the overly generic EJSON.equals). This makes a noticeable\n    // performance difference; see https://github.com/meteor/meteor/pull/3697\n    if (typeof(notification.id) === 'string' &&\n        typeof(trigger.id) === 'string' &&\n        notification.id !== trigger.id) {\n      return false;\n    }\n    if (notification.id instanceof MongoID.ObjectID &&\n        trigger.id instanceof MongoID.ObjectID &&\n        ! notification.id.equals(trigger.id)) {\n      return false;\n    }\n\n    return _.all(trigger, function (triggerValue, key) {\n      return !_.has(notification, key) ||\n        EJSON.equals(triggerValue, notification[key]);\n    });\n  }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n  factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n  __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n    process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n  DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n       function (name) {\n         Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n       });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} diff --git a/server/bundle/programs/server/packages/ddp-server.js.map b/server/bundle/programs/server/packages/ddp-server.js.map index 96d6a02426..7f7cbe1659 100644 --- a/server/bundle/programs/server/packages/ddp-server.js.map +++ b/server/bundle/programs/server/packages/ddp-server.js.map @@ -1 +1 @@ -{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAIA,GAAG,GAAGC,GAAG,CAACC,OAAJ,CAAY,KAAZ,CAAV,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,IAAIC,mBAAmB,GAAGC,CAAC,CAACC,IAAF,CAAO,YAAY;AAC3C,MAAIC,UAAU,GAAG,EAAjB;AAEA,MAAIC,0BAA0B,GAAGC,OAAO,CAACC,GAAR,CAAYC,4BAAZ,GACzBC,IAAI,CAACC,KAAL,CAAWJ,OAAO,CAACC,GAAR,CAAYC,4BAAvB,CADyB,GAC8B,EAD/D;;AAEA,MAAIH,0BAAJ,EAAgC;AAC9BD,cAAU,CAACO,IAAX,CAAgBZ,GAAG,CAACC,OAAJ,CAAY,oBAAZ,EAAkCY,SAAlC,CACdP,0BADc,CAAhB;AAGD;;AAED,SAAOD,UAAP;AACD,CAZyB,CAA1B;;AAcA,IAAIS,UAAU,GAAGC,yBAAyB,CAACC,oBAA1B,IAAmD,EAApE;;AAEAC,YAAY,GAAG,YAAY;AACzB,MAAIC,IAAI,GAAG,IAAX;AACAA,MAAI,CAACC,sBAAL,GAA8B,EAA9B;AACAD,MAAI,CAACE,YAAL,GAAoB,EAApB,CAHyB,CAKzB;AACA;;AACAF,MAAI,CAACG,MAAL,GAAcP,UAAU,GAAG,SAA3B;AACAQ,aAAW,CAACC,OAAZ,CAAoBL,IAAI,CAACG,MAAL,GAAc,GAAlC,EAAuC,SAAvC,EARyB,CAUzB;;AACA,MAAIG,MAAM,GAAGxB,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAb;;AACA,MAAIwB,aAAa,GAAG;AAClBJ,UAAM,EAAEH,IAAI,CAACG,MADK;AAElBK,OAAG,EAAE,YAAW,CAAE,CAFA;AAGlB;AACA;AACAC,mBAAe,EAAE,KALC;AAMlB;AACA;AACA;AACA;AACA;AACA;AACAC,oBAAgB,EAAE,KAAK,IAZL;AAalB;AACA;AACA;AACAC,cAAU,EAAE,CAAC,CAACtB,OAAO,CAACC,GAAR,CAAYsB;AAhBR,GAApB,CAZyB,CA+BzB;AACA;AACA;AACA;;AACA,MAAIvB,OAAO,CAACC,GAAR,CAAYuB,kBAAhB,EAAoC;AAClCN,iBAAa,CAACO,SAAd,GAA0B,KAA1B;AACD,GAFD,MAEO;AACLP,iBAAa,CAACQ,mBAAd,GAAoC;AAClC5B,gBAAU,EAAEH,mBAAmB;AADG,KAApC;AAGD;;AAEDgB,MAAI,CAACgB,MAAL,GAAcV,MAAM,CAACW,YAAP,CAAoBV,aAApB,CAAd,CA3CyB,CA6CzB;AACA;AACA;AACA;;AACAW,QAAM,CAACC,UAAP,CAAkBC,cAAlB,CACE,SADF,EACaF,MAAM,CAACG,iCADpB;AAEArB,MAAI,CAACgB,MAAL,CAAYM,eAAZ,CAA4BJ,MAAM,CAACC,UAAnC;AACAD,QAAM,CAACC,UAAP,CAAkBI,WAAlB,CACE,SADF,EACaL,MAAM,CAACG,iCADpB,EApDyB,CAuDzB;;AACArB,MAAI,CAACwB,0BAAL;;AAEAxB,MAAI,CAACgB,MAAL,CAAYS,EAAZ,CAAe,YAAf,EAA6B,UAAUC,MAAV,EAAkB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,UAAM,CAACC,mBAAP,GAA6B,UAAUC,OAAV,EAAmB;AAC9C,UAAI,CAACF,MAAM,CAACG,QAAP,KAAoB,WAApB,IACAH,MAAM,CAACG,QAAP,KAAoB,eADrB,KAEGH,MAAM,CAACI,QAAP,CAAgBC,IAFvB,EAE6B;AAC3BL,cAAM,CAACI,QAAP,CAAgBC,IAAhB,CAAqBC,UAArB,CAAgCC,UAAhC,CAA2CL,OAA3C;AACD;AACF,KAND;;AAOAF,UAAM,CAACC,mBAAP,CAA2B,KAAK,IAAhC;;AAEAD,UAAM,CAACQ,IAAP,GAAc,UAAUC,IAAV,EAAgB;AAC5BT,YAAM,CAACU,KAAP,CAAaD,IAAb;AACD,KAFD;;AAGAT,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7BzB,UAAI,CAACE,YAAL,GAAoBjB,CAAC,CAACoD,OAAF,CAAUrC,IAAI,CAACE,YAAf,EAA6BwB,MAA7B,CAApB;AACD,KAFD;AAGA1B,QAAI,CAACE,YAAL,CAAkBR,IAAlB,CAAuBgC,MAAvB,EA1B6C,CA4B7C;AACA;AACA;AACA;AACA;;AACAA,UAAM,CAACQ,IAAP,CAAY1C,IAAI,CAAC8C,SAAL,CAAe;AAACC,eAAS,EAAE;AAAZ,KAAf,CAAZ,EAjC6C,CAmC7C;AACA;;AACAtD,KAAC,CAACuD,IAAF,CAAOxC,IAAI,CAACC,sBAAZ,EAAoC,UAAUwC,QAAV,EAAoB;AACtDA,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAxCD;AA0CD,CApGD;;AAsGAzC,CAAC,CAACyD,MAAF,CAAS3C,YAAY,CAAC4C,SAAtB,EAAiC;AAC/B;AACA;AACAC,UAAQ,EAAE,UAAUH,QAAV,EAAoB;AAC5B,QAAIzC,IAAI,GAAG,IAAX;AACAA,QAAI,CAACC,sBAAL,CAA4BP,IAA5B,CAAiC+C,QAAjC;;AACAxD,KAAC,CAACuD,IAAF,CAAOxC,IAAI,CAAC6C,WAAL,EAAP,EAA2B,UAAUnB,MAAV,EAAkB;AAC3Ce,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAT8B;AAW/B;AACAmB,aAAW,EAAE,YAAY;AACvB,QAAI7C,IAAI,GAAG,IAAX;AACA,WAAOf,CAAC,CAAC6D,MAAF,CAAS9C,IAAI,CAACE,YAAd,CAAP;AACD,GAf8B;AAiB/B;AACA;AACAsB,4BAA0B,EAAE,YAAW;AACrC,QAAIxB,IAAI,GAAG,IAAX,CADqC,CAErC;AACA;AACA;AACA;AACA;;AACAf,KAAC,CAACuD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,CAAP,EAA+B,UAASO,KAAT,EAAgB;AAC7C,UAAI5B,UAAU,GAAGD,MAAM,CAACC,UAAxB;AACA,UAAI6B,sBAAsB,GAAG7B,UAAU,CAAC8B,SAAX,CAAqBF,KAArB,EAA4BG,KAA5B,CAAkC,CAAlC,CAA7B;AACA/B,gBAAU,CAACgC,kBAAX,CAA8BJ,KAA9B,EAH6C,CAK7C;AACA;;AACA,UAAIK,WAAW,GAAG,UAASC;AAAQ;AAAjB,QAAuC;AACvD;AACA,YAAIC,IAAI,GAAGC,SAAX,CAFuD,CAIvD;AACA;;AACA,YAAIC,SAAS,GAAG3E,GAAG,CAACY,KAAJ,CAAU4D,OAAO,CAACxE,GAAlB,CAAhB;;AACA,YAAI2E,SAAS,CAACC,QAAV,KAAuB7D,UAAU,GAAG,YAApC,IACA4D,SAAS,CAACC,QAAV,KAAuB7D,UAAU,GAAG,aADxC,EACuD;AACrD4D,mBAAS,CAACC,QAAV,GAAqBzD,IAAI,CAACG,MAAL,GAAc,YAAnC;AACAkD,iBAAO,CAACxE,GAAR,GAAcA,GAAG,CAAC6E,MAAJ,CAAWF,SAAX,CAAd;AACD;;AACDvE,SAAC,CAACuD,IAAF,CAAOQ,sBAAP,EAA+B,UAASW,WAAT,EAAsB;AACnDA,qBAAW,CAACC,KAAZ,CAAkBzC,UAAlB,EAA8BmC,IAA9B;AACD,SAFD;AAGD,OAfD;;AAgBAnC,gBAAU,CAACI,WAAX,CAAuBwB,KAAvB,EAA8BK,WAA9B;AACD,KAxBD;AAyBD;AAnD8B,CAAjC,E;;;;;;;;;;;ACnIAS,SAAS,GAAG,EAAZ;;AAEA,IAAIC,KAAK,GAAGhF,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAZ,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;AACA,IAAIgF,mBAAmB,GAAG,YAAY;AACpC,MAAI/D,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgE,QAAL,GAAgB,IAAIC,GAAJ,EAAhB,CAFoC,CAET;;AAC3BjE,MAAI,CAACkE,SAAL,GAAiB,IAAIC,GAAJ,EAAjB,CAHoC,CAGR;AAC7B,CAJD;;AAMAN,SAAS,CAACO,oBAAV,GAAiCL,mBAAjC;;AAGA9E,CAAC,CAACyD,MAAF,CAASqB,mBAAmB,CAACpB,SAA7B,EAAwC;AAEtC0B,WAAS,EAAE,YAAY;AACrB,QAAIrE,IAAI,GAAG,IAAX;AACA,QAAIsE,GAAG,GAAG,EAAV;AACAtE,QAAI,CAACkE,SAAL,CAAeK,OAAf,CAAuB,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACpDH,SAAG,CAACG,GAAD,CAAH,GAAWD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7B;AACD,KAFD;AAGA,WAAOJ,GAAP;AACD,GATqC;AAWtCK,YAAU,EAAE,UAAUC,kBAAV,EAA8BH,GAA9B,EAAmCI,eAAnC,EAAoD;AAC9D,QAAI7E,IAAI,GAAG,IAAX,CAD8D,CAE9D;;AACA,QAAIyE,GAAG,KAAK,KAAZ,EACE;AACF,QAAID,cAAc,GAAGxE,IAAI,CAACkE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB,CAL8D,CAO9D;AACA;;AACA,QAAI,CAACD,cAAL,EACE;AAEF,QAAIO,YAAY,GAAGC,SAAnB;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGT,cAAc,CAACU,MAAnC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9C,UAAIE,UAAU,GAAGX,cAAc,CAACS,CAAD,CAA/B;;AACA,UAAIE,UAAU,CAACP,kBAAX,KAAkCA,kBAAtC,EAA0D;AACxD;AACA;AACA,YAAIK,CAAC,KAAK,CAAV,EACEF,YAAY,GAAGI,UAAU,CAACT,KAA1B;AACFF,sBAAc,CAACY,MAAf,CAAsBH,CAAtB,EAAyB,CAAzB;AACA;AACD;AACF;;AACD,QAAIT,cAAc,CAACU,MAAf,KAA0B,CAA9B,EAAiC;AAC/BlF,UAAI,CAACkE,SAAL,CAAemB,MAAf,CAAsBZ,GAAtB;AACAI,qBAAe,CAACJ,GAAD,CAAf,GAAuBO,SAAvB;AACD,KAHD,MAGO,IAAID,YAAY,KAAKC,SAAjB,IACA,CAACM,KAAK,CAACC,MAAN,CAAaR,YAAb,EAA2BP,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7C,CADL,EAC0D;AAC/DG,qBAAe,CAACJ,GAAD,CAAf,GAAuBD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAAzC;AACD;AACF,GA1CqC;AA4CtCc,aAAW,EAAE,UAAUZ,kBAAV,EAA8BH,GAA9B,EAAmCC,KAAnC,EACUG,eADV,EAC2BY,KAD3B,EACkC;AAC7C,QAAIzF,IAAI,GAAG,IAAX,CAD6C,CAE7C;;AACA,QAAIyE,GAAG,KAAK,KAAZ,EACE,OAJ2C,CAM7C;;AACAC,SAAK,GAAGY,KAAK,CAACI,KAAN,CAAYhB,KAAZ,CAAR;;AAEA,QAAI,CAAC1E,IAAI,CAACkE,SAAL,CAAeyB,GAAf,CAAmBlB,GAAnB,CAAL,EAA8B;AAC5BzE,UAAI,CAACkE,SAAL,CAAe0B,GAAf,CAAmBnB,GAAnB,EAAwB,CAAC;AAACG,0BAAkB,EAAEA,kBAArB;AACCF,aAAK,EAAEA;AADR,OAAD,CAAxB;AAEAG,qBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACA;AACD;;AACD,QAAIF,cAAc,GAAGxE,IAAI,CAACkE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB;AACA,QAAIoB,GAAJ;;AACA,QAAI,CAACJ,KAAL,EAAY;AACVI,SAAG,GAAGrB,cAAc,CAACsB,IAAf,CAAoB,UAAUX,UAAV,EAAsB;AAC5C,eAAOA,UAAU,CAACP,kBAAX,KAAkCA,kBAAzC;AACH,OAFK,CAAN;AAGD;;AAED,QAAIiB,GAAJ,EAAS;AACP,UAAIA,GAAG,KAAKrB,cAAc,CAAC,CAAD,CAAtB,IAA6B,CAACc,KAAK,CAACC,MAAN,CAAab,KAAb,EAAoBmB,GAAG,CAACnB,KAAxB,CAAlC,EAAkE;AAChE;AACAG,uBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACD;;AACDmB,SAAG,CAACnB,KAAJ,GAAYA,KAAZ;AACD,KAND,MAMO;AACL;AACAF,oBAAc,CAAC9E,IAAf,CAAoB;AAACkF,0BAAkB,EAAEA,kBAArB;AAAyCF,aAAK,EAAEA;AAAhD,OAApB;AACD;AAEF;AA/EqC,CAAxC;AAkFA;;;;;;;;AAMA,IAAIqB,qBAAqB,GAAG,UAAUC,cAAV,EAA0BC,gBAA1B,EAA4C;AACtE,MAAIjG,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgG,cAAL,GAAsBA,cAAtB;AACAhG,MAAI,CAACkG,SAAL,GAAiB,IAAI/B,GAAJ,EAAjB;AACAnE,MAAI,CAACmG,SAAL,GAAiBF,gBAAjB;AACD,CALD;;AAOApC,SAAS,CAACuC,sBAAV,GAAmCL,qBAAnC;;AAGA9G,CAAC,CAACyD,MAAF,CAASqD,qBAAqB,CAACpD,SAA/B,EAA0C;AAExC0D,SAAO,EAAE,YAAY;AACnB,QAAIrG,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAACkG,SAAL,CAAeI,IAAf,KAAwB,CAA/B;AACD,GALuC;AAOxCC,MAAI,EAAE,UAAUC,QAAV,EAAoB;AACxB,QAAIxG,IAAI,GAAG,IAAX;AACAyG,gBAAY,CAACC,QAAb,CAAsBF,QAAQ,CAACN,SAA/B,EAA0ClG,IAAI,CAACkG,SAA/C,EAA0D;AACxDS,UAAI,EAAE1H,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAAC6G,YAAZ,EAA0B7G,IAA1B,CADkD;AAGxD8G,eAAS,EAAE,UAAUC,EAAV,EAAcC,KAAd,EAAqB;AAC9BhH,YAAI,CAACmG,SAAL,CAAec,KAAf,CAAqBjH,IAAI,CAACgG,cAA1B,EAA0Ce,EAA1C,EAA8CC,KAAK,CAAC3C,SAAN,EAA9C;AACD,OALuD;AAOxD6C,cAAQ,EAAE,UAAUH,EAAV,EAAcI,MAAd,EAAsB;AAC9BnH,YAAI,CAACmG,SAAL,CAAeiB,OAAf,CAAuBpH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C;AACD;AATuD,KAA1D;AAWD,GApBuC;AAsBxCF,cAAY,EAAE,UAAUE,EAAV,EAAcI,MAAd,EAAsBH,KAAtB,EAA6B;AACzC,QAAIhH,IAAI,GAAG,IAAX;AACA,QAAIqH,MAAM,GAAG,EAAb;AACAZ,gBAAY,CAACa,WAAb,CAAyBH,MAAM,CAAC9C,SAAP,EAAzB,EAA6C2C,KAAK,CAAC3C,SAAN,EAA7C,EAAgE;AAC9DsC,UAAI,EAAE,UAAUlC,GAAV,EAAe8C,IAAf,EAAqBC,GAArB,EAA0B;AAC9B,YAAI,CAAClC,KAAK,CAACC,MAAN,CAAagC,IAAb,EAAmBC,GAAnB,CAAL,EACEH,MAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACH,OAJ6D;AAK9DV,eAAS,EAAE,UAAUrC,GAAV,EAAe+C,GAAf,EAAoB;AAC7BH,cAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACD,OAP6D;AAQ9DN,cAAQ,EAAE,UAASzC,GAAT,EAAc8C,IAAd,EAAoB;AAC5BF,cAAM,CAAC5C,GAAD,CAAN,GAAcO,SAAd;AACD;AAV6D,KAAhE;AAYAhF,QAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDM,MAAhD;AACD,GAtCuC;AAwCxCJ,OAAK,EAAE,UAAUrC,kBAAV,EAA8BmC,EAA9B,EAAkCM,MAAlC,EAA0C;AAC/C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAI0H,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAIE,KAAK,GAAG,KAAZ;;AACA,QAAI,CAACS,OAAL,EAAc;AACZT,WAAK,GAAG,IAAR;AACAS,aAAO,GAAG,IAAI3D,mBAAJ,EAAV;AACA/D,UAAI,CAACkG,SAAL,CAAeN,GAAf,CAAmBmB,EAAnB,EAAuBW,OAAvB;AACD;;AACDA,WAAO,CAAC1D,QAAR,CAAiB2D,GAAjB,CAAqB/C,kBAArB;AACA,QAAIC,eAAe,GAAG,EAAtB;;AACA5F,KAAC,CAACuD,IAAF,CAAO6E,MAAP,EAAe,UAAU3C,KAAV,EAAiBD,GAAjB,EAAsB;AACnCiD,aAAO,CAAClC,WAAR,CACEZ,kBADF,EACsBH,GADtB,EAC2BC,KAD3B,EACkCG,eADlC,EACmD,IADnD;AAED,KAHD;;AAIA,QAAIoC,KAAJ,EACEjH,IAAI,CAACmG,SAAL,CAAec,KAAf,CAAqBjH,IAAI,CAACgG,cAA1B,EAA0Ce,EAA1C,EAA8ClC,eAA9C,EADF,KAGE7E,IAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDlC,eAAhD;AACH,GA3DuC;AA6DxC4C,SAAO,EAAE,UAAU7C,kBAAV,EAA8BmC,EAA9B,EAAkCU,OAAlC,EAA2C;AAClD,QAAIzH,IAAI,GAAG,IAAX;AACA,QAAI4H,aAAa,GAAG,EAApB;AACA,QAAIF,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAI,CAACW,OAAL,EACE,MAAM,IAAIG,KAAJ,CAAU,oCAAoCd,EAApC,GAAyC,YAAnD,CAAN;;AACF9H,KAAC,CAACuD,IAAF,CAAOiF,OAAP,EAAgB,UAAU/C,KAAV,EAAiBD,GAAjB,EAAsB;AACpC,UAAIC,KAAK,KAAKM,SAAd,EACE0C,OAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CmD,aAA5C,EADF,KAGEF,OAAO,CAAClC,WAAR,CAAoBZ,kBAApB,EAAwCH,GAAxC,EAA6CC,KAA7C,EAAoDkD,aAApD;AACH,KALD;;AAMA5H,QAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDa,aAAhD;AACD,GA1EuC;AA4ExCR,SAAO,EAAE,UAAUxC,kBAAV,EAA8BmC,EAA9B,EAAkC;AACzC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAI0H,OAAO,GAAG1H,IAAI,CAACkG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;;AACA,QAAI,CAACW,OAAL,EAAc;AACZ,UAAII,GAAG,GAAG,IAAID,KAAJ,CAAU,kCAAkCd,EAA5C,CAAV;AACA,YAAMe,GAAN;AACD;;AACDJ,WAAO,CAAC1D,QAAR,CAAiBqB,MAAjB,CAAwBT,kBAAxB;;AACA,QAAI8C,OAAO,CAAC1D,QAAR,CAAiBsC,IAAjB,KAA0B,CAA9B,EAAiC;AAC/B;AACAtG,UAAI,CAACmG,SAAL,CAAeiB,OAAf,CAAuBpH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C;AACA/G,UAAI,CAACkG,SAAL,CAAeb,MAAf,CAAsB0B,EAAtB;AACD,KAJD,MAIO;AACL,UAAIU,OAAO,GAAG,EAAd,CADK,CAEL;AACA;;AACAC,aAAO,CAACxD,SAAR,CAAkBK,OAAlB,CAA0B,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACvDiD,eAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CgD,OAA5C;AACD,OAFD;AAIAzH,UAAI,CAACmG,SAAL,CAAesB,OAAf,CAAuBzH,IAAI,CAACgG,cAA5B,EAA4Ce,EAA5C,EAAgDU,OAAhD;AACD;AACF;AAlGuC,CAA1C;AAqGA;;AACA;;AACA;;;AAEA,IAAIM,OAAO,GAAG,UAAU/G,MAAV,EAAkBgH,OAAlB,EAA2BtG,MAA3B,EAAmCuG,OAAnC,EAA4C;AACxD,MAAIjI,IAAI,GAAG,IAAX;AACAA,MAAI,CAAC+G,EAAL,GAAUmB,MAAM,CAACnB,EAAP,EAAV;AAEA/G,MAAI,CAACgB,MAAL,GAAcA,MAAd;AACAhB,MAAI,CAACgI,OAAL,GAAeA,OAAf;AAEAhI,MAAI,CAACmI,WAAL,GAAmB,KAAnB;AACAnI,MAAI,CAAC0B,MAAL,GAAcA,MAAd,CARwD,CAUxD;AACA;;AACA1B,MAAI,CAACoI,OAAL,GAAe,IAAIC,MAAM,CAACC,iBAAX,EAAf;AAEAtI,MAAI,CAACuI,OAAL,GAAe,KAAf;AACAvI,MAAI,CAACwI,aAAL,GAAqB,KAArB,CAfwD,CAiBxD;;AACAxI,MAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACAnE,MAAI,CAAC0I,cAAL,GAAsB,EAAtB;AAEA1I,MAAI,CAAC2I,MAAL,GAAc,IAAd;AAEA3I,MAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB,CAvBwD,CAyBxD;AACA;AACA;;AACAnE,MAAI,CAAC6I,UAAL,GAAkB,IAAlB,CA5BwD,CA8BxD;AACA;;AACA7I,MAAI,CAAC8I,0BAAL,GAAkC,KAAlC,CAhCwD,CAkCxD;AACA;;AACA9I,MAAI,CAAC+I,aAAL,GAAqB,EAArB,CApCwD,CAsCxD;;AACA/I,MAAI,CAACgJ,eAAL,GAAuB,EAAvB,CAvCwD,CA0CxD;AACA;;AACAhJ,MAAI,CAACiJ,UAAL,GAAkBvH,MAAM,CAAC7C,GAAzB,CA5CwD,CA8CxD;;AACAmB,MAAI,CAACkJ,eAAL,GAAuBjB,OAAO,CAACkB,cAA/B,CA/CwD,CAiDxD;AACA;AACA;;AACAnJ,MAAI,CAACoJ,gBAAL,GAAwB;AACtBrC,MAAE,EAAE/G,IAAI,CAAC+G,EADa;AAEtBsC,SAAK,EAAE,YAAY;AACjBrJ,UAAI,CAACqJ,KAAL;AACD,KAJqB;AAKtBC,WAAO,EAAE,UAAUC,EAAV,EAAc;AACrB,UAAIC,EAAE,GAAGnB,MAAM,CAACoB,eAAP,CAAuBF,EAAvB,EAA2B,6BAA3B,CAAT;;AACA,UAAIvJ,IAAI,CAACoI,OAAT,EAAkB;AAChBpI,YAAI,CAACgJ,eAAL,CAAqBtJ,IAArB,CAA0B8J,EAA1B;AACD,OAFD,MAEO;AACL;AACAnB,cAAM,CAACqB,KAAP,CAAaF,EAAb;AACD;AACF,KAbqB;AActBG,iBAAa,EAAE3J,IAAI,CAAC4J,cAAL,EAdO;AAetBC,eAAW,EAAE7J,IAAI,CAAC0B,MAAL,CAAYoI;AAfH,GAAxB;AAkBA9J,MAAI,CAACkC,IAAL,CAAU;AAAE6H,OAAG,EAAE,WAAP;AAAoBC,WAAO,EAAEhK,IAAI,CAAC+G;AAAlC,GAAV,EAtEwD,CAwExD;;AACAjD,OAAK,CAAC,YAAY;AAChB9D,QAAI,CAACiK,kBAAL;AACD,GAFI,CAAL,CAEGC,GAFH;;AAIA,MAAIlC,OAAO,KAAK,MAAZ,IAAsBC,OAAO,CAACkC,iBAAR,KAA8B,CAAxD,EAA2D;AACzD;AACAzI,UAAM,CAACC,mBAAP,CAA2B,CAA3B;AAEA3B,QAAI,CAACoK,SAAL,GAAiB,IAAIC,SAAS,CAACC,SAAd,CAAwB;AACvCH,uBAAiB,EAAElC,OAAO,CAACkC,iBADY;AAEvCI,sBAAgB,EAAEtC,OAAO,CAACsC,gBAFa;AAGvCC,eAAS,EAAE,YAAY;AACrBxK,YAAI,CAACqJ,KAAL;AACD,OALsC;AAMvCoB,cAAQ,EAAE,YAAY;AACpBzK,YAAI,CAACkC,IAAL,CAAU;AAAC6H,aAAG,EAAE;AAAN,SAAV;AACD;AARsC,KAAxB,CAAjB;AAUA/J,QAAI,CAACoK,SAAL,CAAeM,KAAf;AACD;;AAEDC,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CADD,CAAzB;AAED,CAhGD;;AAkGA5L,CAAC,CAACyD,MAAF,CAASqF,OAAO,CAACpF,SAAjB,EAA4B;AAE1BmI,WAAS,EAAE,UAAUC,eAAV,EAA2B;AACpC,QAAI/K,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeiB,UAAI,EAAED;AAArB,KAAV,EADF,KAEK;AACH9L,OAAC,CAACuD,IAAF,CAAOuI,eAAP,EAAwB,UAAUE,cAAV,EAA0B;AAChDjL,YAAI,CAAC+I,aAAL,CAAmBrJ,IAAnB,CAAwBuL,cAAxB;AACD,OAFD;AAGD;AACF,GAXyB;AAa1BC,WAAS,EAAE,UAAUlF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC/C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeoB,gBAAU,EAAEnF,cAA3B;AAA2Ce,QAAE,EAAEA,EAA/C;AAAmDM,YAAM,EAAEA;AAA3D,KAAV;AACH,GAjByB;AAmB1B+D,aAAW,EAAE,UAAUpF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AACjD,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIf,CAAC,CAACoH,OAAF,CAAUgB,MAAV,CAAJ,EACE;;AAEF,QAAIrH,IAAI,CAAC6I,UAAT,EAAqB;AACnB7I,UAAI,CAACkC,IAAL,CAAU;AACR6H,WAAG,EAAE,SADG;AAERoB,kBAAU,EAAEnF,cAFJ;AAGRe,UAAE,EAAEA,EAHI;AAIRM,cAAM,EAAEA;AAJA,OAAV;AAMD;AACF,GAhCyB;AAkC1BgE,aAAW,EAAE,UAAUrF,cAAV,EAA0Be,EAA1B,EAA8B;AACzC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC6I,UAAT,EACE7I,IAAI,CAACkC,IAAL,CAAU;AAAC6H,SAAG,EAAE,SAAN;AAAiBoB,gBAAU,EAAEnF,cAA7B;AAA6Ce,QAAE,EAAEA;AAAjD,KAAV;AACH,GAtCyB;AAwC1BuE,kBAAgB,EAAE,YAAY;AAC5B,QAAItL,IAAI,GAAG,IAAX;AACA,WAAO;AACLiH,WAAK,EAAEhI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACkL,SAAZ,EAAuBlL,IAAvB,CADF;AAELyH,aAAO,EAAExI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACoL,WAAZ,EAAyBpL,IAAzB,CAFJ;AAGLoH,aAAO,EAAEnI,CAAC,CAAC2H,IAAF,CAAO5G,IAAI,CAACqL,WAAZ,EAAyBrL,IAAzB;AAHJ,KAAP;AAKD,GA/CyB;AAiD1BuL,mBAAiB,EAAE,UAAUvF,cAAV,EAA0B;AAC3C,QAAIhG,IAAI,GAAG,IAAX;AACA,QAAIsE,GAAG,GAAGtE,IAAI,CAAC4I,eAAL,CAAqB9D,GAArB,CAAyBkB,cAAzB,CAAV;;AACA,QAAI,CAAC1B,GAAL,EAAU;AACRA,SAAG,GAAG,IAAIyB,qBAAJ,CAA0BC,cAA1B,EAC4BhG,IAAI,CAACsL,gBAAL,EAD5B,CAAN;AAEAtL,UAAI,CAAC4I,eAAL,CAAqBhD,GAArB,CAAyBI,cAAzB,EAAyC1B,GAAzC;AACD;;AACD,WAAOA,GAAP;AACD,GA1DyB;AA4D1B2C,OAAK,EAAE,UAAUrC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AAC/D,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACvE,KAAL,CAAWrC,kBAAX,EAA+BmC,EAA/B,EAAmCM,MAAnC;AACD,GAhEyB;AAkE1BD,SAAO,EAAE,UAAUxC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkD;AACzD,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACpE,OAAL,CAAaxC,kBAAb,EAAiCmC,EAAjC;;AACA,QAAIyE,IAAI,CAACnF,OAAL,EAAJ,EAAoB;AACjBrG,UAAI,CAAC4I,eAAL,CAAqBvD,MAArB,CAA4BW,cAA5B;AACF;AACF,GAzEyB;AA2E1ByB,SAAO,EAAE,UAAU7C,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AACjE,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIwL,IAAI,GAAGxL,IAAI,CAACuL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAAC/D,OAAL,CAAa7C,kBAAb,EAAiCmC,EAAjC,EAAqCM,MAArC;AACD,GA/EyB;AAiF1B4C,oBAAkB,EAAE,YAAY;AAC9B,QAAIjK,IAAI,GAAG,IAAX,CAD8B,CAE9B;AACA;AACA;;AACA,QAAIyL,QAAQ,GAAGxM,CAAC,CAACyG,KAAF,CAAQ1F,IAAI,CAACgB,MAAL,CAAY0K,0BAApB,CAAf;;AACAzM,KAAC,CAACuD,IAAF,CAAOiJ,QAAP,EAAiB,UAAUE,OAAV,EAAmB;AAClC3L,UAAI,CAAC4L,kBAAL,CAAwBD,OAAxB;AACD,KAFD;AAGD,GA1FyB;AA4F1B;AACAtC,OAAK,EAAE,YAAY;AACjB,QAAIrJ,IAAI,GAAG,IAAX,CADiB,CAGjB;AACA;AACA;AAEA;;AACA,QAAI,CAAEA,IAAI,CAACoI,OAAX,EACE,OATe,CAWjB;;AACApI,QAAI,CAACoI,OAAL,GAAe,IAAf;AACApI,QAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;;AAEA,QAAInE,IAAI,CAACoK,SAAT,EAAoB;AAClBpK,UAAI,CAACoK,SAAL,CAAeyB,IAAf;AACA7L,UAAI,CAACoK,SAAL,GAAiB,IAAjB;AACD;;AAED,QAAIpK,IAAI,CAAC0B,MAAT,EAAiB;AACf1B,UAAI,CAAC0B,MAAL,CAAY2H,KAAZ;AACArJ,UAAI,CAAC0B,MAAL,CAAYoK,cAAZ,GAA6B,IAA7B;AACD;;AAEDnB,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CAAC,CADF,CAAzB;AAGAxC,UAAM,CAACqB,KAAP,CAAa,YAAY;AACvB;AACA;AACA;AACA1J,UAAI,CAAC+L,2BAAL,GAJuB,CAMvB;AACA;;;AACA9M,OAAC,CAACuD,IAAF,CAAOxC,IAAI,CAACgJ,eAAZ,EAA6B,UAAUvG,QAAV,EAAoB;AAC/CA,gBAAQ;AACT,OAFD;AAGD,KAXD,EA5BiB,CAyCjB;;AACAzC,QAAI,CAACgB,MAAL,CAAYgL,cAAZ,CAA2BhM,IAA3B;AACD,GAxIyB;AA0I1B;AACA;AACAkC,MAAI,EAAE,UAAU6H,GAAV,EAAe;AACnB,QAAI/J,IAAI,GAAG,IAAX;;AACA,QAAIA,IAAI,CAAC0B,MAAT,EAAiB;AACf,UAAI2G,MAAM,CAAC4D,aAAX,EACE5D,MAAM,CAAC6D,MAAP,CAAc,UAAd,EAA0B7B,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAA1B;AACF/J,UAAI,CAAC0B,MAAL,CAAYQ,IAAZ,CAAiBmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAjB;AACD;AACF,GAnJyB;AAqJ1B;AACAqC,WAAS,EAAE,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAC7C,QAAItM,IAAI,GAAG,IAAX;AACA,QAAI+J,GAAG,GAAG;AAACA,SAAG,EAAE,OAAN;AAAesC,YAAM,EAAEA;AAAvB,KAAV;AACA,QAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACFtM,QAAI,CAACkC,IAAL,CAAU6H,GAAV;AACD,GA5JyB;AA8J1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAwC,gBAAc,EAAE,UAAUC,MAAV,EAAkB;AAChC,QAAIxM,IAAI,GAAG,IAAX;AACA,QAAI,CAACA,IAAI,CAACoI,OAAV,EAAmB;AACjB,aAH8B,CAKhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAIpI,IAAI,CAACoK,SAAT,EAAoB;AAClBtG,WAAK,CAAC,YAAY;AAChB9D,YAAI,CAACoK,SAAL,CAAeqC,eAAf;AACD,OAFI,CAAL,CAEGvC,GAFH;AAGD;;AAED,QAAIlK,IAAI,CAACgI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD,UAAI/J,IAAI,CAACkJ,eAAT,EACElJ,IAAI,CAACkC,IAAL,CAAU;AAAC6H,WAAG,EAAE,MAAN;AAAchD,UAAE,EAAEyF,MAAM,CAACzF;AAAzB,OAAV;AACF;AACD;;AACD,QAAI/G,IAAI,CAACgI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD;AACA;AACD;;AAED/J,QAAI,CAACoI,OAAL,CAAa1I,IAAb,CAAkB8M,MAAlB;AACA,QAAIxM,IAAI,CAACwI,aAAT,EACE;AACFxI,QAAI,CAACwI,aAAL,GAAqB,IAArB;;AAEA,QAAIkE,WAAW,GAAG,YAAY;AAC5B,UAAI3C,GAAG,GAAG/J,IAAI,CAACoI,OAAL,IAAgBpI,IAAI,CAACoI,OAAL,CAAauE,KAAb,EAA1B;;AACA,UAAI,CAAC5C,GAAL,EAAU;AACR/J,YAAI,CAACwI,aAAL,GAAqB,KAArB;AACA;AACD;;AAED1E,WAAK,CAAC,YAAY;AAChB,YAAIyE,OAAO,GAAG,IAAd;;AAEA,YAAIqE,OAAO,GAAG,YAAY;AACxB,cAAI,CAACrE,OAAL,EACE,OAFsB,CAEd;;AACVA,iBAAO,GAAG,KAAV;AACAmE,qBAAW;AACZ,SALD;;AAOA1M,YAAI,CAACgB,MAAL,CAAY6L,aAAZ,CAA0BrK,IAA1B,CAA+B,UAAUC,QAAV,EAAoB;AACjDA,kBAAQ,CAACsH,GAAD,EAAM/J,IAAN,CAAR;AACA,iBAAO,IAAP;AACD,SAHD;AAKA,YAAIf,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC8M,iBAAX,EAA8B/C,GAAG,CAACA,GAAlC,CAAJ,EACE/J,IAAI,CAAC8M,iBAAL,CAAuB/C,GAAG,CAACA,GAA3B,EAAgCgD,IAAhC,CAAqC/M,IAArC,EAA2C+J,GAA3C,EAAgD6C,OAAhD,EADF,KAGE5M,IAAI,CAACoM,SAAL,CAAe,aAAf,EAA8BrC,GAA9B;AACF6C,eAAO,GAnBS,CAmBL;AACZ,OApBI,CAAL,CAoBG1C,GApBH;AAqBD,KA5BD;;AA8BAwC,eAAW;AACZ,GAlPyB;AAoP1BI,mBAAiB,EAAE;AACjBE,OAAG,EAAE,UAAUjD,GAAV,EAAe;AAClB,UAAI/J,IAAI,GAAG,IAAX,CADkB,CAGlB;;AACA,UAAI,OAAQ+J,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACkD,IAAZ,KAAsB,QADtB,IAEE,YAAYlD,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAF1B,EAE2D;AACzDnN,YAAI,CAACoM,SAAL,CAAe,wBAAf,EAAyCrC,GAAzC;AACA;AACD;;AAED,UAAI,CAAC/J,IAAI,CAACgB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAL,EAA6C;AAC3CjN,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,OADG;AACMhD,YAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,0BAAuCkC,GAAG,CAACkD,IAA3C;AAFC,SAAV;AAGA;AACD;;AAED,UAAIjN,IAAI,CAACyI,UAAL,CAAgB9C,GAAhB,CAAoBoE,GAAG,CAAChD,EAAxB,CAAJ,EACE;AACA;AACA;AACA,eAtBgB,CAwBlB;AACA;AACA;AACA;AACA;;AACA,UAAI4D,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,YAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,YAAIC,gBAAgB,GAAG;AACrB5E,gBAAM,EAAE3I,IAAI,CAAC2I,MADQ;AAErBgB,uBAAa,EAAE3J,IAAI,CAACoJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,cAAI,EAAE,cAHe;AAIrBP,cAAI,EAAElD,GAAG,CAACkD,IAJW;AAKrBQ,sBAAY,EAAEzN,IAAI,CAAC+G;AALE,SAAvB;;AAQAuG,sBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,YAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,YAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5B7N,cAAI,CAACkC,IAAL,CAAU;AACR6H,eAAG,EAAE,OADG;AACMhD,cAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,iBAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK;AAFC,WAAV;AAOA;AACD;AACF;;AAED,UAAIpC,OAAO,GAAG3L,IAAI,CAACgB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAd;;AAEAjN,UAAI,CAAC4L,kBAAL,CAAwBD,OAAxB,EAAiC5B,GAAG,CAAChD,EAArC,EAAyCgD,GAAG,CAACmD,MAA7C,EAAqDnD,GAAG,CAACkD,IAAzD;AAED,KA1DgB;AA4DjBe,SAAK,EAAE,UAAUjE,GAAV,EAAe;AACpB,UAAI/J,IAAI,GAAG,IAAX;;AAEAA,UAAI,CAACiO,iBAAL,CAAuBlE,GAAG,CAAChD,EAA3B;AACD,KAhEgB;AAkEjBmH,UAAM,EAAE,UAAUnE,GAAV,EAAe6C,OAAf,EAAwB;AAC9B,UAAI5M,IAAI,GAAG,IAAX,CAD8B,CAG9B;AACA;AACA;;AACA,UAAI,OAAQ+J,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACmE,MAAZ,KAAwB,QADxB,IAEE,YAAYnE,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAFtB,IAGE,gBAAgBpD,GAAjB,IAA0B,OAAOA,GAAG,CAACoE,UAAX,KAA0B,QAHzD,EAGqE;AACnEnO,YAAI,CAACoM,SAAL,CAAe,6BAAf,EAA8CrC,GAA9C;AACA;AACD;;AAED,UAAIoE,UAAU,GAAGpE,GAAG,CAACoE,UAAJ,IAAkB,IAAnC,CAd8B,CAgB9B;AACA;AACA;;AACA,UAAIC,KAAK,GAAG,IAAIvK,SAAS,CAACwK,WAAd,EAAZ;AACAD,WAAK,CAACE,cAAN,CAAqB,YAAY;AAC/B;AACA;AACA;AACA;AACA;AACAF,aAAK,CAACG,MAAN;AACAvO,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,SADG;AACQyE,iBAAO,EAAE,CAACzE,GAAG,CAAChD,EAAL;AADjB,SAAV;AAED,OATD,EApB8B,CA+B9B;;AACA,UAAI4E,OAAO,GAAG3L,IAAI,CAACgB,MAAL,CAAYyN,eAAZ,CAA4B1E,GAAG,CAACmE,MAAhC,CAAd;;AACA,UAAI,CAACvC,OAAL,EAAc;AACZ3L,YAAI,CAACkC,IAAL,CAAU;AACR6H,aAAG,EAAE,QADG;AACOhD,YAAE,EAAEgD,GAAG,CAAChD,EADf;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCkC,GAAG,CAACmE,MAArC;AAFC,SAAV;AAGAE,aAAK,CAACM,GAAN;AACA;AACD;;AAED,UAAIC,SAAS,GAAG,UAAShG,MAAT,EAAiB;AAC/B3I,YAAI,CAAC4O,UAAL,CAAgBjG,MAAhB;AACD,OAFD;;AAIA,UAAIkG,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,oBAAY,EAAE,KADgC;AAE9CpG,cAAM,EAAE3I,IAAI,CAAC2I,MAFiC;AAG9CgG,iBAAS,EAAEA,SAHmC;AAI9C/B,eAAO,EAAEA,OAJqC;AAK9C5K,kBAAU,EAAEhC,IAAI,CAACoJ,gBAL6B;AAM9C+E,kBAAU,EAAEA;AANkC,OAA/B,CAAjB;AASA,YAAMa,OAAO,GAAG,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC/C;AACA;AACA;AACA;AACA,YAAIxE,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,cAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,cAAIC,gBAAgB,GAAG;AACrB5E,kBAAM,EAAE3I,IAAI,CAAC2I,MADQ;AAErBgB,yBAAa,EAAE3J,IAAI,CAACoJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,gBAAI,EAAE,QAHe;AAIrBP,gBAAI,EAAElD,GAAG,CAACmE,MAJW;AAKrBT,wBAAY,EAAEzN,IAAI,CAAC+G;AALE,WAAvB;;AAOAuG,wBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,cAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,cAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5BsB,kBAAM,CAAC,IAAI9G,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK,CAAD,CAAN;AAKA;AACD;AACF;;AAEDmB,eAAO,CAACrL,SAAS,CAACuL,kBAAV,CAA6BC,SAA7B,CACNjB,KADM,EAEN,MAAMkB,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACJR,UADI,EAEJ,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACP9E,GAAG,CAACmD,MADG,EAE5B,cAAcnD,GAAG,CAACmE,MAAlB,GAA2B,GAFC,CAF1B,CAFA,CAAD,CAAP;AAUD,OApCe,CAAhB;;AAsCA,eAASuB,MAAT,GAAkB;AAChBrB,aAAK,CAACM,GAAN;AACA9B,eAAO;AACR;;AAED,YAAM8C,OAAO,GAAG;AACd3F,WAAG,EAAE,QADS;AAEdhD,UAAE,EAAEgD,GAAG,CAAChD;AAFM,OAAhB;AAKAiI,aAAO,CAACW,IAAR,CAAcC,MAAD,IAAY;AACvBH,cAAM;;AACN,YAAIG,MAAM,KAAK5K,SAAf,EAA0B;AACxB0K,iBAAO,CAACE,MAAR,GAAiBA,MAAjB;AACD;;AACD5P,YAAI,CAACkC,IAAL,CAAUwN,OAAV;AACD,OAND,EAMIG,SAAD,IAAe;AAChBJ,cAAM;AACNC,eAAO,CAACrC,KAAR,GAAgByC,qBAAqB,CACnCD,SADmC,mCAET9F,GAAG,CAACmE,MAFK,OAArC;AAIAlO,YAAI,CAACkC,IAAL,CAAUwN,OAAV;AACD,OAbD;AAcD;AAtLgB,GApPO;AA6a1BK,UAAQ,EAAE,UAAUC,CAAV,EAAa;AACrB,QAAIhQ,IAAI,GAAG,IAAX;;AACAA,QAAI,CAACyI,UAAL,CAAgBlE,OAAhB,CAAwByL,CAAxB;;AACAhQ,QAAI,CAAC0I,cAAL,CAAoBnE,OAApB,CAA4ByL,CAA5B;AACD,GAjbyB;AAmb1BC,sBAAoB,EAAE,UAAUC,SAAV,EAAqB;AACzC,QAAIlQ,IAAI,GAAG,IAAX;AACAyG,gBAAY,CAACC,QAAb,CAAsBwJ,SAAtB,EAAiClQ,IAAI,CAAC4I,eAAtC,EAAuD;AACrDjC,UAAI,EAAE,UAAUX,cAAV,EAA0BmK,SAA1B,EAAqCC,UAArC,EAAiD;AACrDA,kBAAU,CAAC7J,IAAX,CAAgB4J,SAAhB;AACD,OAHoD;AAIrDrJ,eAAS,EAAE,UAAUd,cAAV,EAA0BoK,UAA1B,EAAsC;AAC/CA,kBAAU,CAAClK,SAAX,CAAqB3B,OAArB,CAA6B,UAAUmD,OAAV,EAAmBX,EAAnB,EAAuB;AAClD/G,cAAI,CAACkL,SAAL,CAAelF,cAAf,EAA+Be,EAA/B,EAAmCW,OAAO,CAACrD,SAAR,EAAnC;AACD,SAFD;AAGD,OARoD;AASrD6C,cAAQ,EAAE,UAAUlB,cAAV,EAA0BmK,SAA1B,EAAqC;AAC7CA,iBAAS,CAACjK,SAAV,CAAoB3B,OAApB,CAA4B,UAAU8L,GAAV,EAAetJ,EAAf,EAAmB;AAC7C/G,cAAI,CAACqL,WAAL,CAAiBrF,cAAjB,EAAiCe,EAAjC;AACD,SAFD;AAGD;AAboD,KAAvD;AAeD,GApcyB;AAsc1B;AACA;AACA6H,YAAU,EAAE,UAASjG,MAAT,EAAiB;AAC3B,QAAI3I,IAAI,GAAG,IAAX;AAEA,QAAI2I,MAAM,KAAK,IAAX,IAAmB,OAAOA,MAAP,KAAkB,QAAzC,EACE,MAAM,IAAId,KAAJ,CAAU,qDACA,OAAOc,MADjB,CAAN,CAJyB,CAO3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA3I,QAAI,CAAC8I,0BAAL,GAAkC,IAAlC,CAf2B,CAiB3B;AACA;;AACA9I,QAAI,CAAC+P,QAAL,CAAc,UAAU/C,GAAV,EAAe;AAC3BA,SAAG,CAACsD,WAAJ;AACD,KAFD,EAnB2B,CAuB3B;AACA;AACA;;;AACAtQ,QAAI,CAAC6I,UAAL,GAAkB,KAAlB;AACA,QAAIqH,SAAS,GAAGlQ,IAAI,CAAC4I,eAArB;AACA5I,QAAI,CAAC4I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;AACAnE,QAAI,CAAC2I,MAAL,GAAcA,MAAd,CA7B2B,CA+B3B;AACA;AACA;AACA;;AACA2G,OAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CAAuCrK,SAAvC,EAAkD,YAAY;AAC5D;AACA,UAAIuL,YAAY,GAAGvQ,IAAI,CAACyI,UAAxB;AACAzI,UAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACAnE,UAAI,CAAC0I,cAAL,GAAsB,EAAtB;AAEA6H,kBAAY,CAAChM,OAAb,CAAqB,UAAUyI,GAAV,EAAe/B,cAAf,EAA+B;AAClD,YAAIuF,MAAM,GAAGxD,GAAG,CAACyD,SAAJ,EAAb;;AACAzQ,YAAI,CAACyI,UAAL,CAAgB7C,GAAhB,CAAoBqF,cAApB,EAAoCuF,MAApC,EAFkD,CAGlD;AACA;;;AACAA,cAAM,CAACE,WAAP;AACD,OAND,EAN4D,CAc5D;AACA;AACA;;AACA1Q,UAAI,CAAC8I,0BAAL,GAAkC,KAAlC;AACA9I,UAAI,CAACiK,kBAAL;AACD,KAnBD,EAnC2B,CAwD3B;AACA;AACA;;;AACA5B,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC3Q,UAAI,CAAC6I,UAAL,GAAkB,IAAlB;;AACA7I,UAAI,CAACiQ,oBAAL,CAA0BC,SAA1B;;AACA,UAAI,CAACjR,CAAC,CAACoH,OAAF,CAAUrG,IAAI,CAAC+I,aAAf,CAAL,EAAoC;AAClC/I,YAAI,CAAC8K,SAAL,CAAe9K,IAAI,CAAC+I,aAApB;AACA/I,YAAI,CAAC+I,aAAL,GAAqB,EAArB;AACD;AACF,KAPD;AAQD,GA3gByB;AA6gB1B6C,oBAAkB,EAAE,UAAUD,OAAV,EAAmBiF,KAAnB,EAA0B1D,MAA1B,EAAkCD,IAAlC,EAAwC;AAC1D,QAAIjN,IAAI,GAAG,IAAX;AAEA,QAAIgN,GAAG,GAAG,IAAI6D,YAAJ,CACR7Q,IADQ,EACF2L,OADE,EACOiF,KADP,EACc1D,MADd,EACsBD,IADtB,CAAV;AAEA,QAAI2D,KAAJ,EACE5Q,IAAI,CAACyI,UAAL,CAAgB7C,GAAhB,CAAoBgL,KAApB,EAA2B5D,GAA3B,EADF,KAGEhN,IAAI,CAAC0I,cAAL,CAAoBhJ,IAApB,CAAyBsN,GAAzB;;AAEFA,OAAG,CAAC0D,WAAJ;AACD,GAxhByB;AA0hB1B;AACAzC,mBAAiB,EAAE,UAAU2C,KAAV,EAAiBvD,KAAjB,EAAwB;AACzC,QAAIrN,IAAI,GAAG,IAAX;AAEA,QAAI8Q,OAAO,GAAG,IAAd;;AACA,QAAIF,KAAJ,EAAW;AACT,UAAIG,QAAQ,GAAG/Q,IAAI,CAACyI,UAAL,CAAgB3D,GAAhB,CAAoB8L,KAApB,CAAf;;AACA,UAAIG,QAAJ,EAAc;AACZD,eAAO,GAAGC,QAAQ,CAACC,KAAnB;;AACAD,gBAAQ,CAACE,mBAAT;;AACAF,gBAAQ,CAACT,WAAT;;AACAtQ,YAAI,CAACyI,UAAL,CAAgBpD,MAAhB,CAAuBuL,KAAvB;AACD;AACF;;AAED,QAAIM,QAAQ,GAAG;AAACnH,SAAG,EAAE,OAAN;AAAehD,QAAE,EAAE6J;AAAnB,KAAf;;AAEA,QAAIvD,KAAJ,EAAW;AACT6D,cAAQ,CAAC7D,KAAT,GAAiByC,qBAAqB,CACpCzC,KADoC,EAEpCyD,OAAO,GAAI,cAAcA,OAAd,GAAwB,MAAxB,GAAiCF,KAArC,GACF,iBAAiBA,KAHc,CAAtC;AAID;;AAED5Q,QAAI,CAACkC,IAAL,CAAUgP,QAAV;AACD,GAnjByB;AAqjB1B;AACA;AACAnF,6BAA2B,EAAE,YAAY;AACvC,QAAI/L,IAAI,GAAG,IAAX;;AAEAA,QAAI,CAACyI,UAAL,CAAgBlE,OAAhB,CAAwB,UAAUyI,GAAV,EAAejG,EAAf,EAAmB;AACzCiG,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAtQ,QAAI,CAACyI,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;;AAEAnE,QAAI,CAAC0I,cAAL,CAAoBnE,OAApB,CAA4B,UAAUyI,GAAV,EAAe;AACzCA,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAtQ,QAAI,CAAC0I,cAAL,GAAsB,EAAtB;AACD,GAnkByB;AAqkB1B;AACA;AACA;AACAkB,gBAAc,EAAE,YAAY;AAC1B,QAAI5J,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAImR,kBAAkB,GAAGC,QAAQ,CAAC/R,OAAO,CAACC,GAAR,CAAY,sBAAZ,CAAD,CAAR,IAAiD,CAA1E;AAEA,QAAI6R,kBAAkB,KAAK,CAA3B,EACE,OAAOnR,IAAI,CAAC0B,MAAL,CAAY2P,aAAnB;AAEF,QAAIC,YAAY,GAAGtR,IAAI,CAAC0B,MAAL,CAAYoI,OAAZ,CAAoB,iBAApB,CAAnB;AACA,QAAI,CAAE7K,CAAC,CAACsS,QAAF,CAAWD,YAAX,CAAN,EACE,OAAO,IAAP;AACFA,gBAAY,GAAGA,YAAY,CAACE,IAAb,GAAoBC,KAApB,CAA0B,SAA1B,CAAf,CAlB0B,CAoB1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,QAAIN,kBAAkB,GAAG,CAArB,IAA0BA,kBAAkB,GAAGG,YAAY,CAACpM,MAAhE,EACE,OAAO,IAAP;AAEF,WAAOoM,YAAY,CAACA,YAAY,CAACpM,MAAb,GAAsBiM,kBAAvB,CAAnB;AACD;AAzmByB,CAA5B;AA4mBA;;AACA;;AACA;AAEA;AAEA;AACA;;AACA;;;;;;;;AAMA,IAAIN,YAAY,GAAG,UACf7G,OADe,EACN2B,OADM,EACGV,cADH,EACmBiC,MADnB,EAC2BD,IAD3B,EACiC;AAClD,MAAIjN,IAAI,GAAG,IAAX;AACAA,MAAI,CAAC8B,QAAL,GAAgBkI,OAAhB,CAFkD,CAEzB;;AAEzB;;;;;;;;AAOAhK,MAAI,CAACgC,UAAL,GAAkBgI,OAAO,CAACZ,gBAA1B,CAXkD,CAWN;;AAE5CpJ,MAAI,CAAC0R,QAAL,GAAgB/F,OAAhB,CAbkD,CAelD;;AACA3L,MAAI,CAAC2R,eAAL,GAAuB1G,cAAvB,CAhBkD,CAiBlD;;AACAjL,MAAI,CAACgR,KAAL,GAAa/D,IAAb;AAEAjN,MAAI,CAAC4R,OAAL,GAAe1E,MAAM,IAAI,EAAzB,CApBkD,CAsBlD;AACA;AACA;;AACA,MAAIlN,IAAI,CAAC2R,eAAT,EAA0B;AACxB3R,QAAI,CAAC6R,mBAAL,GAA2B,MAAM7R,IAAI,CAAC2R,eAAtC;AACD,GAFD,MAEO;AACL3R,QAAI,CAAC6R,mBAAL,GAA2B,MAAM3J,MAAM,CAACnB,EAAP,EAAjC;AACD,GA7BiD,CA+BlD;;;AACA/G,MAAI,CAAC8R,YAAL,GAAoB,KAApB,CAhCkD,CAkClD;;AACA9R,MAAI,CAAC+R,cAAL,GAAsB,EAAtB,CAnCkD,CAqClD;AACA;;AACA/R,MAAI,CAACgS,UAAL,GAAkB,IAAI7N,GAAJ,EAAlB,CAvCkD,CAyClD;;AACAnE,MAAI,CAACiS,MAAL,GAAc,KAAd,CA1CkD,CA4ClD;;AAEA;;;;;;;;AAOAjS,MAAI,CAAC2I,MAAL,GAAcqB,OAAO,CAACrB,MAAtB,CArDkD,CAuDlD;AACA;AACA;AAEA;AACA;AACA;AACA;;AAEA3I,MAAI,CAACkS,SAAL,GAAiB;AACfC,eAAW,EAAEC,OAAO,CAACD,WADN;AAEfE,WAAO,EAAED,OAAO,CAACC;AAFF,GAAjB;AAKA1H,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CADN,CAAzB;AAED,CAxED;;AA0EA5L,CAAC,CAACyD,MAAF,CAASmO,YAAY,CAAClO,SAAtB,EAAiC;AAC/B+N,aAAW,EAAE,YAAY;AACvB;AACA;AACA;AACA;AACA;AACA;AAEA,QAAI1Q,IAAI,GAAG,IAAX;;AACA,QAAI;AACF,UAAIsS,GAAG,GAAGhD,GAAG,CAACiD,6BAAJ,CAAkClD,SAAlC,CACRrP,IADQ,EAER,MAAMwP,wBAAwB,CAC5BxP,IAAI,CAAC0R,QADuB,EACb1R,IADa,EACPsF,KAAK,CAACI,KAAN,CAAY1F,IAAI,CAAC4R,OAAjB,CADO,EAE5B;AACA;AACA;AACA,sBAAgB5R,IAAI,CAACgR,KAArB,GAA6B,GALD,CAFtB,CAAV;AAUD,KAXD,CAWE,OAAOwB,CAAP,EAAU;AACVxS,UAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD,KAvBsB,CAyBvB;;;AACA,QAAIxS,IAAI,CAACyS,cAAL,EAAJ,EACE;;AAEFzS,QAAI,CAAC0S,qBAAL,CAA2BJ,GAA3B;AACD,GA/B8B;AAiC/BI,uBAAqB,EAAE,UAAUJ,GAAV,EAAe;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,QAAItS,IAAI,GAAG,IAAX;;AACA,QAAI2S,QAAQ,GAAG,UAAUC,CAAV,EAAa;AAC1B,aAAOA,CAAC,IAAIA,CAAC,CAACC,cAAd;AACD,KAFD;;AAGA,QAAIF,QAAQ,CAACL,GAAD,CAAZ,EAAmB;AACjB,UAAI;AACFA,WAAG,CAACO,cAAJ,CAAmB7S,IAAnB;AACD,OAFD,CAEE,OAAOwS,CAAP,EAAU;AACVxS,YAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD,OANgB,CAOjB;AACA;;;AACAxS,UAAI,CAAC8S,KAAL;AACD,KAVD,MAUO,IAAI7T,CAAC,CAAC8T,OAAF,CAAUT,GAAV,CAAJ,EAAoB;AACzB;AACA,UAAI,CAAErT,CAAC,CAAC+T,GAAF,CAAMV,GAAN,EAAWK,QAAX,CAAN,EAA4B;AAC1B3S,YAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,mDAAV,CAAX;AACA;AACD,OALwB,CAMzB;AACA;AACA;;;AACA,UAAIoL,eAAe,GAAG,EAAtB;;AACA,WAAK,IAAIhO,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqN,GAAG,CAACpN,MAAxB,EAAgC,EAAED,CAAlC,EAAqC;AACnC,YAAIe,cAAc,GAAGsM,GAAG,CAACrN,CAAD,CAAH,CAAOiO,kBAAP,EAArB;;AACA,YAAIjU,CAAC,CAAC0G,GAAF,CAAMsN,eAAN,EAAuBjN,cAAvB,CAAJ,EAA4C;AAC1ChG,cAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CACT,+DACE7B,cAFO,CAAX;AAGA;AACD;;AACDiN,uBAAe,CAACjN,cAAD,CAAf,GAAkC,IAAlC;AACD;;AAAA;;AAED,UAAI;AACF/G,SAAC,CAACuD,IAAF,CAAO8P,GAAP,EAAY,UAAUa,GAAV,EAAe;AACzBA,aAAG,CAACN,cAAJ,CAAmB7S,IAAnB;AACD,SAFD;AAGD,OAJD,CAIE,OAAOwS,CAAP,EAAU;AACVxS,YAAI,CAACqN,KAAL,CAAWmF,CAAX;AACA;AACD;;AACDxS,UAAI,CAAC8S,KAAL;AACD,KA9BM,MA8BA,IAAIR,GAAJ,EAAS;AACd;AACA;AACA;AACAtS,UAAI,CAACqN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,kDACE,qBADZ,CAAX;AAED;AACF,GAtG8B;AAwG/B;AACA;AACA;AACA;AACA;AACAyI,aAAW,EAAE,YAAW;AACtB,QAAItQ,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC8R,YAAT,EACE;AACF9R,QAAI,CAAC8R,YAAL,GAAoB,IAApB;;AACA9R,QAAI,CAACoT,kBAAL;;AACAzI,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CAAC,CADP,CAAzB;AAED,GArH8B;AAuH/BuI,oBAAkB,EAAE,YAAY;AAC9B,QAAIpT,IAAI,GAAG,IAAX,CAD8B,CAE9B;;AACA,QAAImG,SAAS,GAAGnG,IAAI,CAAC+R,cAArB;AACA/R,QAAI,CAAC+R,cAAL,GAAsB,EAAtB;;AACA9S,KAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkB,UAAU1D,QAAV,EAAoB;AACpCA,cAAQ;AACT,KAFD;AAGD,GA/H8B;AAiI/B;AACAwO,qBAAmB,EAAE,YAAY;AAC/B,QAAIjR,IAAI,GAAG,IAAX;;AACAqI,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC3Q,UAAI,CAACgS,UAAL,CAAgBzN,OAAhB,CAAwB,UAAU8O,cAAV,EAA0BrN,cAA1B,EAA0C;AAChEqN,sBAAc,CAAC9O,OAAf,CAAuB,UAAU+O,KAAV,EAAiB;AACtCtT,cAAI,CAACoH,OAAL,CAAapB,cAAb,EAA6BhG,IAAI,CAACkS,SAAL,CAAeG,OAAf,CAAuBiB,KAAvB,CAA7B;AACD,SAFD;AAGD,OAJD;AAKD,KAND;AAOD,GA3I8B;AA6I/B;AACA;AACA;AACA;AACA;AACA7C,WAAS,EAAE,YAAY;AACrB,QAAIzQ,IAAI,GAAG,IAAX;AACA,WAAO,IAAI6Q,YAAJ,CACL7Q,IAAI,CAAC8B,QADA,EACU9B,IAAI,CAAC0R,QADf,EACyB1R,IAAI,CAAC2R,eAD9B,EAC+C3R,IAAI,CAAC4R,OADpD,EAEL5R,IAAI,CAACgR,KAFA,CAAP;AAGD,GAvJ8B;;AAyJ/B;;;;;;;AAOA3D,OAAK,EAAE,UAAUA,KAAV,EAAiB;AACtB,QAAIrN,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;;AACFzS,QAAI,CAAC8B,QAAL,CAAcmM,iBAAd,CAAgCjO,IAAI,CAAC2R,eAArC,EAAsDtE,KAAtD;AACD,GArK8B;AAuK/B;AACA;AACA;AACA;;AAEA;;;;;;AAMAxB,MAAI,EAAE,YAAY;AAChB,QAAI7L,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;;AACFzS,QAAI,CAAC8B,QAAL,CAAcmM,iBAAd,CAAgCjO,IAAI,CAAC2R,eAArC;AACD,GAvL8B;;AAyL/B;;;;;;;AAOA4B,QAAM,EAAE,UAAU9Q,QAAV,EAAoB;AAC1B,QAAIzC,IAAI,GAAG,IAAX;AACAyC,YAAQ,GAAG4F,MAAM,CAACoB,eAAP,CAAuBhH,QAAvB,EAAiC,iBAAjC,EAAoDzC,IAApD,CAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACEhQ,QAAQ,GADV,KAGEzC,IAAI,CAAC+R,cAAL,CAAoBrS,IAApB,CAAyB+C,QAAzB;AACH,GAvM8B;AAyM/B;AACA;AACA;AACAgQ,gBAAc,EAAE,YAAY;AAC1B,QAAIzS,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC8R,YAAL,IAAqB9R,IAAI,CAAC8B,QAAL,CAAcsG,OAAd,KAA0B,IAAtD;AACD,GA/M8B;;AAiN/B;;;;;;;;;AASAnB,OAAK,EAAE,UAAUjB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC3C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA,QAAIyM,GAAG,GAAGxT,IAAI,CAACgS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,CAAV;;AACA,QAAIwN,GAAG,IAAI,IAAX,EAAiB;AACfA,SAAG,GAAG,IAAIvP,GAAJ,EAAN;;AACAjE,UAAI,CAACgS,UAAL,CAAgBpM,GAAhB,CAAoBI,cAApB,EAAoCwN,GAApC;AACD;;AACDA,OAAG,CAAC7L,GAAJ,CAAQZ,EAAR;;AACA/G,QAAI,CAAC8B,QAAL,CAAcmF,KAAd,CAAoBjH,IAAI,CAAC6R,mBAAzB,EAA8C7L,cAA9C,EAA8De,EAA9D,EAAkEM,MAAlE;AACD,GAtO8B;;AAwO/B;;;;;;;;;AASAI,SAAO,EAAE,UAAUzB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC7C,QAAIrH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA/G,QAAI,CAAC8B,QAAL,CAAc2F,OAAd,CAAsBzH,IAAI,CAAC6R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE,EAAoEM,MAApE;AACD,GAvP8B;;AAyP/B;;;;;;;;AAQAD,SAAO,EAAE,UAAUpB,cAAV,EAA0Be,EAA1B,EAA8B;AACrC,QAAI/G,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAG/G,IAAI,CAACkS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL,CAJqC,CAKrC;AACA;;AACA/G,QAAI,CAACgS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,EAAoCX,MAApC,CAA2C0B,EAA3C;;AACA/G,QAAI,CAAC8B,QAAL,CAAcsF,OAAd,CAAsBpH,IAAI,CAAC6R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE;AACD,GA1Q8B;;AA4Q/B;;;;;;AAMA+L,OAAK,EAAE,YAAY;AACjB,QAAI9S,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACyS,cAAL,EAAJ,EACE;AACF,QAAI,CAACzS,IAAI,CAAC2R,eAAV,EACE,OALe,CAKN;;AACX,QAAI,CAAC3R,IAAI,CAACiS,MAAV,EAAkB;AAChBjS,UAAI,CAAC8B,QAAL,CAAcgJ,SAAd,CAAwB,CAAC9K,IAAI,CAAC2R,eAAN,CAAxB;;AACA3R,UAAI,CAACiS,MAAL,GAAc,IAAd;AACD;AACF;AA5R8B,CAAjC;AA+RA;;AACA;;AACA;;;AAEAwB,MAAM,GAAG,UAAUxL,OAAV,EAAmB;AAC1B,MAAIjI,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACAA,MAAI,CAACiI,OAAL,GAAehJ,CAAC,CAACyU,QAAF,CAAWzL,OAAO,IAAI,EAAtB,EAA0B;AACvCkC,qBAAiB,EAAE,KADoB;AAEvCI,oBAAgB,EAAE,KAFqB;AAGvC;AACApB,kBAAc,EAAE;AAJuB,GAA1B,CAAf,CAV0B,CAiB1B;AACA;AACA;AACA;;AACAnJ,MAAI,CAAC2T,gBAAL,GAAwB,IAAIC,IAAJ,CAAS;AAC/BC,wBAAoB,EAAE;AADS,GAAT,CAAxB,CArB0B,CAyB1B;;AACA7T,MAAI,CAAC6M,aAAL,GAAqB,IAAI+G,IAAJ,CAAS;AAC5BC,wBAAoB,EAAE;AADM,GAAT,CAArB;AAIA7T,MAAI,CAACoN,gBAAL,GAAwB,EAAxB;AACApN,MAAI,CAAC0L,0BAAL,GAAkC,EAAlC;AAEA1L,MAAI,CAACyO,eAAL,GAAuB,EAAvB;AAEAzO,MAAI,CAAC8T,QAAL,GAAgB,IAAI3P,GAAJ,EAAhB,CAnC0B,CAmCC;;AAE3BnE,MAAI,CAAC+T,aAAL,GAAqB,IAAIhU,YAAJ,EAArB;AAEAC,MAAI,CAAC+T,aAAL,CAAmBnR,QAAnB,CAA4B,UAAUlB,MAAV,EAAkB;AAC5C;AACAA,UAAM,CAACoK,cAAP,GAAwB,IAAxB;;AAEA,QAAIM,SAAS,GAAG,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAClD,UAAIvC,GAAG,GAAG;AAACA,WAAG,EAAE,OAAN;AAAesC,cAAM,EAAEA;AAAvB,OAAV;AACA,UAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACF5K,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAZ;AACD,KALD;;AAOArI,UAAM,CAACD,EAAP,CAAU,MAAV,EAAkB,UAAUuS,OAAV,EAAmB;AACnC,UAAI3L,MAAM,CAAC4L,iBAAX,EAA8B;AAC5B5L,cAAM,CAAC6D,MAAP,CAAc,cAAd,EAA8B8H,OAA9B;AACD;;AACD,UAAI;AACF,YAAI;AACF,cAAIjK,GAAG,GAAGM,SAAS,CAAC6J,QAAV,CAAmBF,OAAnB,CAAV;AACD,SAFD,CAEE,OAAOlM,GAAP,EAAY;AACZsE,mBAAS,CAAC,aAAD,CAAT;AACA;AACD;;AACD,YAAIrC,GAAG,KAAK,IAAR,IAAgB,CAACA,GAAG,CAACA,GAAzB,EAA8B;AAC5BqC,mBAAS,CAAC,aAAD,EAAgBrC,GAAhB,CAAT;AACA;AACD;;AAED,YAAIA,GAAG,CAACA,GAAJ,KAAY,SAAhB,EAA2B;AACzB,cAAIrI,MAAM,CAACoK,cAAX,EAA2B;AACzBM,qBAAS,CAAC,mBAAD,EAAsBrC,GAAtB,CAAT;AACA;AACD;;AACDjG,eAAK,CAAC,YAAY;AAChB9D,gBAAI,CAACmU,cAAL,CAAoBzS,MAApB,EAA4BqI,GAA5B;AACD,WAFI,CAAL,CAEGG,GAFH;AAGA;AACD;;AAED,YAAI,CAACxI,MAAM,CAACoK,cAAZ,EAA4B;AAC1BM,mBAAS,CAAC,oBAAD,EAAuBrC,GAAvB,CAAT;AACA;AACD;;AACDrI,cAAM,CAACoK,cAAP,CAAsBS,cAAtB,CAAqCxC,GAArC;AACD,OA5BD,CA4BE,OAAOyI,CAAP,EAAU;AACV;AACAnK,cAAM,CAAC6D,MAAP,CAAc,6CAAd,EAA6DnC,GAA7D,EAAkEyI,CAAlE;AACD;AACF,KApCD;AAsCA9Q,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7B,UAAIC,MAAM,CAACoK,cAAX,EAA2B;AACzBhI,aAAK,CAAC,YAAY;AAChBpC,gBAAM,CAACoK,cAAP,CAAsBzC,KAAtB;AACD,SAFI,CAAL,CAEGa,GAFH;AAGD;AACF,KAND;AAOD,GAxDD;AAyDD,CAhGD;;AAkGAjL,CAAC,CAACyD,MAAF,CAAS+Q,MAAM,CAAC9Q,SAAhB,EAA2B;AAEzB;;;;;;;AAOAyR,cAAY,EAAE,UAAU7K,EAAV,EAAc;AAC1B,QAAIvJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC2T,gBAAL,CAAsB/Q,QAAtB,CAA+B2G,EAA/B,CAAP;AACD,GAZwB;;AAczB;;;;;;;AAOA8K,WAAS,EAAE,UAAU9K,EAAV,EAAc;AACvB,QAAIvJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC6M,aAAL,CAAmBjK,QAAnB,CAA4B2G,EAA5B,CAAP;AACD,GAxBwB;AA0BzB4K,gBAAc,EAAE,UAAUzS,MAAV,EAAkBqI,GAAlB,EAAuB;AACrC,QAAI/J,IAAI,GAAG,IAAX,CADqC,CAGrC;AACA;;AACA,QAAI,EAAE,OAAQ+J,GAAG,CAAC/B,OAAZ,KAAyB,QAAzB,IACA/I,CAAC,CAAC8T,OAAF,CAAUhJ,GAAG,CAACuK,OAAd,CADA,IAEArV,CAAC,CAAC+T,GAAF,CAAMjJ,GAAG,CAACuK,OAAV,EAAmBrV,CAAC,CAACsS,QAArB,CAFA,IAGAtS,CAAC,CAACsV,QAAF,CAAWxK,GAAG,CAACuK,OAAf,EAAwBvK,GAAG,CAAC/B,OAA5B,CAHF,CAAJ,EAG6C;AAC3CtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AACT/B,eAAO,EAAEqC,SAAS,CAACmK,sBAAV,CAAiC,CAAjC;AADA,OAAvB,CAAZ;AAEA9S,YAAM,CAAC2H,KAAP;AACA;AACD,KAboC,CAerC;AACA;;;AACA,QAAIrB,OAAO,GAAGyM,gBAAgB,CAAC1K,GAAG,CAACuK,OAAL,EAAcjK,SAAS,CAACmK,sBAAxB,CAA9B;;AAEA,QAAIzK,GAAG,CAAC/B,OAAJ,KAAgBA,OAApB,EAA6B;AAC3B;AACA;AACA;AACAtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AAAgB/B,eAAO,EAAEA;AAAzB,OAAvB,CAAZ;AACAtG,YAAM,CAAC2H,KAAP;AACA;AACD,KA1BoC,CA4BrC;AACA;AACA;;;AACA3H,UAAM,CAACoK,cAAP,GAAwB,IAAI/D,OAAJ,CAAY/H,IAAZ,EAAkBgI,OAAlB,EAA2BtG,MAA3B,EAAmC1B,IAAI,CAACiI,OAAxC,CAAxB;AACAjI,QAAI,CAAC8T,QAAL,CAAclO,GAAd,CAAkBlE,MAAM,CAACoK,cAAP,CAAsB/E,EAAxC,EAA4CrF,MAAM,CAACoK,cAAnD;AACA9L,QAAI,CAAC2T,gBAAL,CAAsBnR,IAAtB,CAA2B,UAAUC,QAAV,EAAoB;AAC7C,UAAIf,MAAM,CAACoK,cAAX,EACErJ,QAAQ,CAACf,MAAM,CAACoK,cAAP,CAAsB1C,gBAAvB,CAAR;AACF,aAAO,IAAP;AACD,KAJD;AAKD,GAhEwB;;AAiEzB;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;AAQAsL,SAAO,EAAE,UAAUzH,IAAV,EAAgBtB,OAAhB,EAAyB1D,OAAzB,EAAkC;AACzC,QAAIjI,IAAI,GAAG,IAAX;;AAEA,QAAI,CAAEf,CAAC,CAAC0V,QAAF,CAAW1H,IAAX,CAAN,EAAwB;AACtBhF,aAAO,GAAGA,OAAO,IAAI,EAArB;;AAEA,UAAIgF,IAAI,IAAIA,IAAI,IAAIjN,IAAI,CAACoN,gBAAzB,EAA2C;AACzC/E,cAAM,CAAC6D,MAAP,CAAc,uCAAuCe,IAAvC,GAA8C,GAA5D;;AACA;AACD;;AAED,UAAItC,OAAO,CAACiK,WAAR,IAAuB,CAAC3M,OAAO,CAAC4M,OAApC,EAA6C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAI,CAAC7U,IAAI,CAAC8U,wBAAV,EAAoC;AAClC9U,cAAI,CAAC8U,wBAAL,GAAgC,IAAhC;;AACAzM,gBAAM,CAAC6D,MAAP,CACN,0EACA,yEADA,GAEA,uEAFA,GAGA,yCAHA,GAIA,MAJA,GAKA,gEALA,GAMA,MANA,GAOA,oCAPA,GAQA,MARA,GASA,8EATA,GAUA,wDAXM;AAYD;AACF;;AAED,UAAIe,IAAJ,EACEjN,IAAI,CAACoN,gBAAL,CAAsBH,IAAtB,IAA8BtB,OAA9B,CADF,KAEK;AACH3L,YAAI,CAAC0L,0BAAL,CAAgChM,IAAhC,CAAqCiM,OAArC,EADG,CAEH;AACA;AACA;;AACA3L,YAAI,CAAC8T,QAAL,CAAcvP,OAAd,CAAsB,UAAUyF,OAAV,EAAmB;AACvC,cAAI,CAACA,OAAO,CAAClB,0BAAb,EAAyC;AACvChF,iBAAK,CAAC,YAAW;AACfkG,qBAAO,CAAC4B,kBAAR,CAA2BD,OAA3B;AACD,aAFI,CAAL,CAEGzB,GAFH;AAGD;AACF,SAND;AAOD;AACF,KAhDD,MAiDI;AACFjL,OAAC,CAACuD,IAAF,CAAOyK,IAAP,EAAa,UAASvI,KAAT,EAAgBD,GAAhB,EAAqB;AAChCzE,YAAI,CAAC0U,OAAL,CAAajQ,GAAb,EAAkBC,KAAlB,EAAyB,EAAzB;AACD,OAFD;AAGD;AACF,GAzJwB;AA2JzBsH,gBAAc,EAAE,UAAUhC,OAAV,EAAmB;AACjC,QAAIhK,IAAI,GAAG,IAAX;AACAA,QAAI,CAAC8T,QAAL,CAAczO,MAAd,CAAqB2E,OAAO,CAACjD,EAA7B;AACD,GA9JwB;;AAgKzB;;;;;;;AAOAyH,SAAO,EAAE,UAAUA,OAAV,EAAmB;AAC1B,QAAIxO,IAAI,GAAG,IAAX;;AACAf,KAAC,CAACuD,IAAF,CAAOgM,OAAP,EAAgB,UAAUuG,IAAV,EAAgB9H,IAAhB,EAAsB;AACpC,UAAI,OAAO8H,IAAP,KAAgB,UAApB,EACE,MAAM,IAAIlN,KAAJ,CAAU,aAAaoF,IAAb,GAAoB,sBAA9B,CAAN;AACF,UAAIjN,IAAI,CAACyO,eAAL,CAAqBxB,IAArB,CAAJ,EACE,MAAM,IAAIpF,KAAJ,CAAU,qBAAqBoF,IAArB,GAA4B,sBAAtC,CAAN;AACFjN,UAAI,CAACyO,eAAL,CAAqBxB,IAArB,IAA6B8H,IAA7B;AACD,KAND;AAOD,GAhLwB;AAkLzBhI,MAAI,EAAE,UAAUE,IAAV,EAAyB;AAAA,sCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAC7B,QAAIA,IAAI,CAAC4B,MAAL,IAAe,OAAO5B,IAAI,CAACA,IAAI,CAAC4B,MAAL,GAAc,CAAf,CAAX,KAAiC,UAApD,EAAgE;AAC9D;AACA;AACA,UAAIzC,QAAQ,GAAGa,IAAI,CAAC0R,GAAL,EAAf;AACD;;AAED,WAAO,KAAKpR,KAAL,CAAWqJ,IAAX,EAAiB3J,IAAjB,EAAuBb,QAAvB,CAAP;AACD,GA1LwB;AA4LzB;AACAwS,WAAS,EAAE,UAAUhI,IAAV,EAAyB;AAAA,uCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAClC,WAAO,KAAK4R,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,CAAP;AACD,GA/LwB;AAiMzBM,OAAK,EAAE,UAAUqJ,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+BxF,QAA/B,EAAyC;AAC9C;AACA;AACA,QAAI,CAAEA,QAAF,IAAc,OAAOwF,OAAP,KAAmB,UAArC,EAAiD;AAC/CxF,cAAQ,GAAGwF,OAAX;AACAA,aAAO,GAAG,EAAV;AACD,KAHD,MAGO;AACLA,aAAO,GAAGA,OAAO,IAAI,EAArB;AACD;;AAED,UAAM+G,OAAO,GAAG,KAAKkG,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,EAA4B2E,OAA5B,CAAhB,CAV8C,CAY9C;AACA;AACA;AACA;AACA;;AACA,QAAIxF,QAAJ,EAAc;AACZuM,aAAO,CAACW,IAAR,CACEC,MAAM,IAAInN,QAAQ,CAACuC,SAAD,EAAY4K,MAAZ,CADpB,EAEEC,SAAS,IAAIpN,QAAQ,CAACoN,SAAD,CAFvB;AAID,KALD,MAKO;AACL,aAAOb,OAAO,CAACmG,KAAR,EAAP;AACD;AACF,GA1NwB;AA4NzB;AACAD,YAAU,EAAE,UAAUjI,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+B;AACzC;AACA,QAAI0D,OAAO,GAAG,KAAK8C,eAAL,CAAqBxB,IAArB,CAAd;;AACA,QAAI,CAAEtB,OAAN,EAAe;AACb,aAAOsD,OAAO,CAACE,MAAR,CACL,IAAI9G,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCoF,IAAjC,iBADK,CAAP;AAGD,KAPwC,CASzC;AACA;AACA;;;AACA,QAAItE,MAAM,GAAG,IAAb;;AACA,QAAIgG,SAAS,GAAG,YAAW;AACzB,YAAM,IAAI9G,KAAJ,CAAU,wDAAV,CAAN;AACD,KAFD;;AAGA,QAAI7F,UAAU,GAAG,IAAjB;;AACA,QAAIoT,uBAAuB,GAAG9F,GAAG,CAACC,wBAAJ,CAA6BzK,GAA7B,EAA9B;;AACA,QAAIuQ,4BAA4B,GAAG/F,GAAG,CAACiD,6BAAJ,CAAkCzN,GAAlC,EAAnC;;AACA,QAAIqJ,UAAU,GAAG,IAAjB;;AACA,QAAIiH,uBAAJ,EAA6B;AAC3BzM,YAAM,GAAGyM,uBAAuB,CAACzM,MAAjC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3ByM,+BAAuB,CAACzG,SAAxB,CAAkChG,MAAlC;AACD,OAFD;;AAGA3G,gBAAU,GAAGoT,uBAAuB,CAACpT,UAArC;AACAmM,gBAAU,GAAG9D,SAAS,CAACiL,WAAV,CAAsBF,uBAAtB,EAA+CnI,IAA/C,CAAb;AACD,KAPD,MAOO,IAAIoI,4BAAJ,EAAkC;AACvC1M,YAAM,GAAG0M,4BAA4B,CAAC1M,MAAtC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3B0M,oCAA4B,CAACvT,QAA7B,CAAsC8M,UAAtC,CAAiDjG,MAAjD;AACD,OAFD;;AAGA3G,gBAAU,GAAGqT,4BAA4B,CAACrT,UAA1C;AACD;;AAED,QAAI6M,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,kBAAY,EAAE,KADgC;AAE9CpG,YAF8C;AAG9CgG,eAH8C;AAI9C3M,gBAJ8C;AAK9CmM;AAL8C,KAA/B,CAAjB;AAQA,WAAO,IAAIc,OAAJ,CAAYC,OAAO,IAAIA,OAAO,CACnCI,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACER,UADF,EAEE,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACPvJ,KAAK,CAACI,KAAN,CAAYpC,IAAZ,CADO,EAE5B,uBAAuB2J,IAAvB,GAA8B,GAFF,CAFhC,CADmC,CAA9B,EAQJ0C,IARI,CAQCrK,KAAK,CAACI,KARP,CAAP;AASD,GAjRwB;AAmRzB6P,gBAAc,EAAE,UAAUC,SAAV,EAAqB;AACnC,QAAIxV,IAAI,GAAG,IAAX;AACA,QAAIgK,OAAO,GAAGhK,IAAI,CAAC8T,QAAL,CAAchP,GAAd,CAAkB0Q,SAAlB,CAAd;AACA,QAAIxL,OAAJ,EACE,OAAOA,OAAO,CAACf,UAAf,CADF,KAGE,OAAO,IAAP;AACH;AA1RwB,CAA3B;;AA6RA,IAAIwL,gBAAgB,GAAG,UAAUgB,uBAAV,EACUC,uBADV,EACmC;AACxD,MAAIC,cAAc,GAAG1W,CAAC,CAAC6G,IAAF,CAAO2P,uBAAP,EAAgC,UAAUzN,OAAV,EAAmB;AACtE,WAAO/I,CAAC,CAACsV,QAAF,CAAWmB,uBAAX,EAAoC1N,OAApC,CAAP;AACD,GAFoB,CAArB;;AAGA,MAAI,CAAC2N,cAAL,EAAqB;AACnBA,kBAAc,GAAGD,uBAAuB,CAAC,CAAD,CAAxC;AACD;;AACD,SAAOC,cAAP;AACD,CATD;;AAWA9R,SAAS,CAAC+R,iBAAV,GAA8BnB,gBAA9B,C,CAGA;AACA;;AACA,IAAI3E,qBAAqB,GAAG,UAAUD,SAAV,EAAqBgG,OAArB,EAA8B;AACxD,MAAI,CAAChG,SAAL,EAAgB,OAAOA,SAAP,CADwC,CAGxD;AACA;AACA;;AACA,MAAIA,SAAS,CAACiG,YAAd,EAA4B;AAC1B,QAAI,EAAEjG,SAAS,YAAYxH,MAAM,CAACR,KAA9B,CAAJ,EAA0C;AACxC,YAAMkO,eAAe,GAAGlG,SAAS,CAACmG,OAAlC;AACAnG,eAAS,GAAG,IAAIxH,MAAM,CAACR,KAAX,CAAiBgI,SAAS,CAACxC,KAA3B,EAAkCwC,SAAS,CAACxD,MAA5C,EAAoDwD,SAAS,CAACoG,OAA9D,CAAZ;AACApG,eAAS,CAACmG,OAAV,GAAoBD,eAApB;AACD;;AACD,WAAOlG,SAAP;AACD,GAbuD,CAexD;AACA;;;AACA,MAAI,CAACA,SAAS,CAACqG,eAAf,EAAgC;AAC9B7N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAA7B,EAAsChG,SAAS,CAACsG,KAAhD;;AACA,QAAItG,SAAS,CAACuG,cAAd,EAA8B;AAC5B/N,YAAM,CAAC6D,MAAP,CAAc,0CAAd,EAA0D2D,SAAS,CAACuG,cAApE;;AACA/N,YAAM,CAAC6D,MAAP;AACD;AACF,GAvBuD,CAyBxD;AACA;AACA;AACA;;;AACA,MAAI2D,SAAS,CAACuG,cAAd,EAA8B;AAC5B,QAAIvG,SAAS,CAACuG,cAAV,CAAyBN,YAA7B,EACE,OAAOjG,SAAS,CAACuG,cAAjB;;AACF/N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAAf,GAAyB,kCAAzB,GACA,mDADd;AAED;;AAED,SAAO,IAAIxN,MAAM,CAACR,KAAX,CAAiB,GAAjB,EAAsB,uBAAtB,CAAP;AACD,CArCD,C,CAwCA;AACA;;;AACA,IAAI2H,wBAAwB,GAAG,UAAUQ,CAAV,EAAa6F,OAAb,EAAsBvS,IAAtB,EAA4B+S,WAA5B,EAAyC;AACtE/S,MAAI,GAAGA,IAAI,IAAI,EAAf;;AACA,MAAIqH,OAAO,CAAC,uBAAD,CAAX,EAAsC;AACpC,WAAO2L,KAAK,CAACC,gCAAN,CACLvG,CADK,EACF6F,OADE,EACOvS,IADP,EACa+S,WADb,CAAP;AAED;;AACD,SAAOrG,CAAC,CAACpM,KAAF,CAAQiS,OAAR,EAAiBvS,IAAjB,CAAP;AACD,CAPD,C;;;;;;;;;;;ACpuDA,IAAIkT,MAAM,GAAG1X,GAAG,CAACC,OAAJ,CAAY,eAAZ,CAAb,C,CAEA;AACA;AACA;AACA;;;AACA8E,SAAS,CAACwK,WAAV,GAAwB,YAAY;AAClC,MAAIrO,IAAI,GAAG,IAAX;AAEAA,MAAI,CAACyW,KAAL,GAAa,KAAb;AACAzW,MAAI,CAAC0W,KAAL,GAAa,KAAb;AACA1W,MAAI,CAAC2W,OAAL,GAAe,KAAf;AACA3W,MAAI,CAAC4W,kBAAL,GAA0B,CAA1B;AACA5W,MAAI,CAAC6W,qBAAL,GAA6B,EAA7B;AACA7W,MAAI,CAAC8W,oBAAL,GAA4B,EAA5B;AACD,CATD,C,CAWA;AACA;AACA;AACA;;;AACAjT,SAAS,CAACuL,kBAAV,GAA+B,IAAI/G,MAAM,CAAC0O,mBAAX,EAA/B;;AAEA9X,CAAC,CAACyD,MAAF,CAASmB,SAAS,CAACwK,WAAV,CAAsB1L,SAA/B,EAA0C;AACxC;AACA;AACA;AACA;AACA;AACAqU,YAAU,EAAE,YAAY;AACtB,QAAIhX,IAAI,GAAG,IAAX;AAEA,QAAIA,IAAI,CAAC2W,OAAT,EACE,OAAO;AAAEM,eAAS,EAAE,YAAY,CAAE;AAA3B,KAAP;AAEF,QAAIjX,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,uDAAV,CAAN;AAEF7H,QAAI,CAAC4W,kBAAL;AACA,QAAIK,SAAS,GAAG,KAAhB;AACA,WAAO;AACLA,eAAS,EAAE,YAAY;AACrB,YAAIA,SAAJ,EACE,MAAM,IAAIpP,KAAJ,CAAU,0CAAV,CAAN;AACFoP,iBAAS,GAAG,IAAZ;AACAjX,YAAI,CAAC4W,kBAAL;;AACA5W,YAAI,CAACkX,UAAL;AACD;AAPI,KAAP;AASD,GA1BuC;AA4BxC;AACA;AACAxI,KAAG,EAAE,YAAY;AACf,QAAI1O,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,KAAK6D,SAAS,CAACuL,kBAAV,CAA6BtK,GAA7B,EAAb,EACE,MAAM+C,KAAK,CAAC,6BAAD,CAAX;AACF7H,QAAI,CAACyW,KAAL,GAAa,IAAb;;AACAzW,QAAI,CAACkX,UAAL;AACD,GApCuC;AAsCxC;AACA;AACA;AACAC,cAAY,EAAE,UAAUpC,IAAV,EAAgB;AAC5B,QAAI/U,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF7H,QAAI,CAAC6W,qBAAL,CAA2BnX,IAA3B,CAAgCqV,IAAhC;AACD,GA/CuC;AAiDxC;AACAzG,gBAAc,EAAE,UAAUyG,IAAV,EAAgB;AAC9B,QAAI/U,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF7H,QAAI,CAAC8W,oBAAL,CAA0BpX,IAA1B,CAA+BqV,IAA/B;AACD,GAxDuC;AA0DxC;AACAqC,YAAU,EAAE,YAAY;AACtB,QAAIpX,IAAI,GAAG,IAAX;AACA,QAAIqX,MAAM,GAAG,IAAIb,MAAJ,EAAb;AACAxW,QAAI,CAACsO,cAAL,CAAoB,YAAY;AAC9B+I,YAAM,CAAC,QAAD,CAAN;AACD,KAFD;AAGArX,QAAI,CAAC0O,GAAL;AACA2I,UAAM,CAACC,IAAP;AACD,GAnEuC;AAqExCJ,YAAU,EAAE,YAAY;AACtB,QAAIlX,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC0W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gCAAV,CAAN;;AACF,QAAI7H,IAAI,CAACyW,KAAL,IAAc,CAACzW,IAAI,CAAC4W,kBAAxB,EAA4C;AAC1C,eAASW,cAAT,CAAyBxC,IAAzB,EAA+B;AAC7B,YAAI;AACFA,cAAI,CAAC/U,IAAD,CAAJ;AACD,SAFD,CAEE,OAAO8H,GAAP,EAAY;AACZO,gBAAM,CAAC6D,MAAP,CAAc,mCAAd,EAAmDpE,GAAnD;AACD;AACF;;AAED9H,UAAI,CAAC4W,kBAAL;;AACA,aAAO5W,IAAI,CAAC6W,qBAAL,CAA2B3R,MAA3B,GAAoC,CAA3C,EAA8C;AAC5C,YAAIiB,SAAS,GAAGnG,IAAI,CAAC6W,qBAArB;AACA7W,YAAI,CAAC6W,qBAAL,GAA6B,EAA7B;;AACA5X,SAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkBoR,cAAlB;AACD;;AACDvX,UAAI,CAAC4W,kBAAL;;AAEA,UAAI,CAAC5W,IAAI,CAAC4W,kBAAV,EAA8B;AAC5B5W,YAAI,CAAC0W,KAAL,GAAa,IAAb;AACA,YAAIvQ,SAAS,GAAGnG,IAAI,CAAC8W,oBAArB;AACA9W,YAAI,CAAC8W,oBAAL,GAA4B,EAA5B;;AACA7X,SAAC,CAACuD,IAAF,CAAO2D,SAAP,EAAkBoR,cAAlB;AACD;AACF;AACF,GAjGuC;AAmGxC;AACA;AACAhJ,QAAM,EAAE,YAAY;AAClB,QAAIvO,IAAI,GAAG,IAAX;AACA,QAAI,CAAEA,IAAI,CAAC0W,KAAX,EACE,MAAM,IAAI7O,KAAJ,CAAU,yCAAV,CAAN;AACF7H,QAAI,CAAC2W,OAAL,GAAe,IAAf;AACD;AA1GuC,CAA1C,E;;;;;;;;;;;ACvBA;AACA;AACA;AAEA9S,SAAS,CAAC2T,SAAV,GAAsB,UAAUvP,OAAV,EAAmB;AACvC,MAAIjI,IAAI,GAAG,IAAX;AACAiI,SAAO,GAAGA,OAAO,IAAI,EAArB;AAEAjI,MAAI,CAACyX,MAAL,GAAc,CAAd,CAJuC,CAKvC;AACA;AACA;;AACAzX,MAAI,CAAC0X,qBAAL,GAA6B,EAA7B;AACA1X,MAAI,CAAC2X,0BAAL,GAAkC,EAAlC;AACA3X,MAAI,CAAC4X,WAAL,GAAmB3P,OAAO,CAAC2P,WAAR,IAAuB,UAA1C;AACA5X,MAAI,CAAC6X,QAAL,GAAgB5P,OAAO,CAAC4P,QAAR,IAAoB,IAApC;AACD,CAZD;;AAcA5Y,CAAC,CAACyD,MAAF,CAASmB,SAAS,CAAC2T,SAAV,CAAoB7U,SAA7B,EAAwC;AACtC;AACAmV,uBAAqB,EAAE,UAAU/N,GAAV,EAAe;AACpC,QAAI/J,IAAI,GAAG,IAAX;;AACA,QAAI,CAAEf,CAAC,CAAC0G,GAAF,CAAMoE,GAAN,EAAW,YAAX,CAAN,EAAgC;AAC9B,aAAO,EAAP;AACD,KAFD,MAEO,IAAI,OAAOA,GAAG,CAACoB,UAAX,KAA2B,QAA/B,EAAyC;AAC9C,UAAIpB,GAAG,CAACoB,UAAJ,KAAmB,EAAvB,EACE,MAAMtD,KAAK,CAAC,+BAAD,CAAX;AACF,aAAOkC,GAAG,CAACoB,UAAX;AACD,KAJM,MAIA;AACL,YAAMtD,KAAK,CAAC,oCAAD,CAAX;AACD;AACF,GAbqC;AAetC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAkQ,QAAM,EAAE,UAAUC,OAAV,EAAmBvV,QAAnB,EAA6B;AACnC,QAAIzC,IAAI,GAAG,IAAX;AACA,QAAI+G,EAAE,GAAG/G,IAAI,CAACyX,MAAL,EAAT;;AAEA,QAAItM,UAAU,GAAGnL,IAAI,CAAC8X,qBAAL,CAA2BE,OAA3B,CAAjB;;AACA,QAAIC,MAAM,GAAG;AAACD,aAAO,EAAE1S,KAAK,CAACI,KAAN,CAAYsS,OAAZ,CAAV;AAAgCvV,cAAQ,EAAEA;AAA1C,KAAb;;AACA,QAAI,CAAExD,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC0X,qBAAX,EAAkCvM,UAAlC,CAAN,EAAqD;AACnDnL,UAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,IAAyC,EAAzC;AACAnL,UAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC,IAA8C,CAA9C;AACD;;AACDnL,QAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,EAAuCpE,EAAvC,IAA6CkR,MAA7C;AACAjY,QAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC;;AAEA,QAAInL,IAAI,CAAC6X,QAAL,IAAiBlN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,aAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE7K,IAAI,CAAC4X,WADP,EACoB5X,IAAI,CAAC6X,QADzB,EACmC,CADnC;AAED;;AAED,WAAO;AACLhM,UAAI,EAAE,YAAY;AAChB,YAAI7L,IAAI,CAAC6X,QAAL,IAAiBlN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,iBAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE7K,IAAI,CAAC4X,WADP,EACoB5X,IAAI,CAAC6X,QADzB,EACmC,CAAC,CADpC;AAED;;AACD,eAAO7X,IAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,EAAuCpE,EAAvC,CAAP;AACA/G,YAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC;;AACA,YAAInL,IAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC,MAAgD,CAApD,EAAuD;AACrD,iBAAOnL,IAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,CAAP;AACA,iBAAOnL,IAAI,CAAC2X,0BAAL,CAAgCxM,UAAhC,CAAP;AACD;AACF;AAZI,KAAP;AAcD,GAzDqC;AA2DtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA+M,MAAI,EAAE,UAAUC,YAAV,EAAwB;AAC5B,QAAInY,IAAI,GAAG,IAAX;;AAEA,QAAImL,UAAU,GAAGnL,IAAI,CAAC8X,qBAAL,CAA2BK,YAA3B,CAAjB;;AAEA,QAAI,CAAElZ,CAAC,CAAC0G,GAAF,CAAM3F,IAAI,CAAC0X,qBAAX,EAAkCvM,UAAlC,CAAN,EAAqD;AACnD;AACD;;AAED,QAAIiN,sBAAsB,GAAGpY,IAAI,CAAC0X,qBAAL,CAA2BvM,UAA3B,CAA7B;AACA,QAAIkN,WAAW,GAAG,EAAlB;;AACApZ,KAAC,CAACuD,IAAF,CAAO4V,sBAAP,EAA+B,UAAUE,CAAV,EAAavR,EAAb,EAAiB;AAC9C,UAAI/G,IAAI,CAACuY,QAAL,CAAcJ,YAAd,EAA4BG,CAAC,CAACN,OAA9B,CAAJ,EAA4C;AAC1CK,mBAAW,CAAC3Y,IAAZ,CAAiBqH,EAAjB;AACD;AACF,KAJD,EAX4B,CAiB5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA9H,KAAC,CAACuD,IAAF,CAAO6V,WAAP,EAAoB,UAAUtR,EAAV,EAAc;AAChC,UAAI9H,CAAC,CAAC0G,GAAF,CAAMyS,sBAAN,EAA8BrR,EAA9B,CAAJ,EAAuC;AACrCqR,8BAAsB,CAACrR,EAAD,CAAtB,CAA2BtE,QAA3B,CAAoC0V,YAApC;AACD;AACF,KAJD;AAKD,GAlGqC;AAoGtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAI,UAAQ,EAAE,UAAUJ,YAAV,EAAwBH,OAAxB,EAAiC;AACzC;AACA;AACA;AACA;AACA;AACA,QAAI,OAAOG,YAAY,CAACpR,EAApB,KAA4B,QAA5B,IACA,OAAOiR,OAAO,CAACjR,EAAf,KAAuB,QADvB,IAEAoR,YAAY,CAACpR,EAAb,KAAoBiR,OAAO,CAACjR,EAFhC,EAEoC;AAClC,aAAO,KAAP;AACD;;AACD,QAAIoR,YAAY,CAACpR,EAAb,YAA2BqL,OAAO,CAACoG,QAAnC,IACAR,OAAO,CAACjR,EAAR,YAAsBqL,OAAO,CAACoG,QAD9B,IAEA,CAAEL,YAAY,CAACpR,EAAb,CAAgBxB,MAAhB,CAAuByS,OAAO,CAACjR,EAA/B,CAFN,EAE0C;AACxC,aAAO,KAAP;AACD;;AAED,WAAO9H,CAAC,CAAC+T,GAAF,CAAMgF,OAAN,EAAe,UAAUS,YAAV,EAAwBhU,GAAxB,EAA6B;AACjD,aAAO,CAACxF,CAAC,CAAC0G,GAAF,CAAMwS,YAAN,EAAoB1T,GAApB,CAAD,IACLa,KAAK,CAACC,MAAN,CAAakT,YAAb,EAA2BN,YAAY,CAAC1T,GAAD,CAAvC,CADF;AAED,KAHM,CAAP;AAID;AA1IqC,CAAxC,E,CA6IA;AACA;AACA;AACA;AACA;;;AACAZ,SAAS,CAAC6U,qBAAV,GAAkC,IAAI7U,SAAS,CAAC2T,SAAd,CAAwB;AACxDK,UAAQ,EAAE;AAD8C,CAAxB,CAAlC,C;;;;;;;;;;;ACpKA,IAAIxY,OAAO,CAACC,GAAR,CAAYqZ,0BAAhB,EAA4C;AAC1C9Y,2BAAyB,CAAC8Y,0BAA1B,GACEtZ,OAAO,CAACC,GAAR,CAAYqZ,0BADd;AAED;;AAEDtQ,MAAM,CAACrH,MAAP,GAAgB,IAAIyS,MAAJ,EAAhB;;AAEApL,MAAM,CAACuQ,OAAP,GAAiB,UAAUT,YAAV,EAAwB;AACvCtU,WAAS,CAAC6U,qBAAV,CAAgCR,IAAhC,CAAqCC,YAArC;AACD,CAFD,C,CAIA;AACA;;;AACAlZ,CAAC,CAACuD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,EAAuB,MAAvB,EAA+B,OAA/B,EAAwC,cAAxC,EAAwD,WAAxD,CAAP,EACO,UAAUyK,IAAV,EAAgB;AACd5E,QAAM,CAAC4E,IAAD,CAAN,GAAehO,CAAC,CAAC2H,IAAF,CAAOyB,MAAM,CAACrH,MAAP,CAAciM,IAAd,CAAP,EAA4B5E,MAAM,CAACrH,MAAnC,CAAf;AACD,CAHR,E,CAKA;AACA;AACA;;;AACAqH,MAAM,CAACwQ,cAAP,GAAwBxQ,MAAM,CAACrH,MAA/B,C","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n var extensions = [];\n\n var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n if (websocketCompressionConfig) {\n extensions.push(Npm.require('permessage-deflate').configure(\n websocketCompressionConfig\n ));\n }\n\n return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n var self = this;\n self.registration_callbacks = [];\n self.open_sockets = [];\n\n // Because we are installing directly onto WebApp.httpServer instead of using\n // WebApp.app, we have to process the path prefix ourselves.\n self.prefix = pathPrefix + '/sockjs';\n RoutePolicy.declare(self.prefix + '/', 'network');\n\n // set up sockjs\n var sockjs = Npm.require('sockjs');\n var serverOptions = {\n prefix: self.prefix,\n log: function() {},\n // this is the default, but we code it explicitly because we depend\n // on it in stream_client:HEARTBEAT_TIMEOUT\n heartbeat_delay: 45000,\n // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n // bound for that much time, SockJS might not notice that the user has\n // reconnected because the timer (of disconnect_delay ms) can fire before\n // SockJS processes the new connection. Eventually we'll fix this by not\n // combining CPU-heavy processing with SockJS termination (eg a proxy which\n // converts to Unix sockets) but for now, raise the delay.\n disconnect_delay: 60 * 1000,\n // Set the USE_JSESSIONID environment variable to enable setting the\n // JSESSIONID cookie. This is useful for setting up proxies with\n // session affinity.\n jsessionid: !!process.env.USE_JSESSIONID\n };\n\n // If you know your server environment (eg, proxies) will prevent websockets\n // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n // browsers) will not waste time attempting to use them.\n // (Your server will still have a /websocket endpoint.)\n if (process.env.DISABLE_WEBSOCKETS) {\n serverOptions.websocket = false;\n } else {\n serverOptions.faye_server_options = {\n extensions: websocketExtensions()\n };\n }\n\n self.server = sockjs.createServer(serverOptions);\n\n // Install the sockjs handlers, but we want to keep around our own particular\n // request handler that adjusts idle timeouts while we have an outstanding\n // request. This compensates for the fact that sockjs removes all listeners\n // for \"request\" to add its own.\n WebApp.httpServer.removeListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n self.server.installHandlers(WebApp.httpServer);\n WebApp.httpServer.addListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n\n // Support the /websocket endpoint\n self._redirectWebsocketEndpoint();\n\n self.server.on('connection', function (socket) {\n // We want to make sure that if a client connects to us and does the initial\n // Websocket handshake but never gets to the DDP handshake, that we\n // eventually kill the socket. Once the DDP handshake happens, DDP\n // heartbeating will work. And before the Websocket handshake, the timeouts\n // we set at the server level in webapp_server.js will work. But\n // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n // is an \"in between\" state where this doesn't happen. We work around this\n // by explicitly setting the socket timeout to a relatively large time here,\n // and setting it back to zero when we set up the heartbeat in\n // livedata_server.js.\n socket.setWebsocketTimeout = function (timeout) {\n if ((socket.protocol === 'websocket' ||\n socket.protocol === 'websocket-raw')\n && socket._session.recv) {\n socket._session.recv.connection.setTimeout(timeout);\n }\n };\n socket.setWebsocketTimeout(45 * 1000);\n\n socket.send = function (data) {\n socket.write(data);\n };\n socket.on('close', function () {\n self.open_sockets = _.without(self.open_sockets, socket);\n });\n self.open_sockets.push(socket);\n\n // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n // will force old clients to reload. Remove this once we're not\n // concerned about people upgrading from a pre-0.7.0 release. Also,\n // remove the clause in the client that ignores the welcome message\n // (livedata_connection.js)\n socket.send(JSON.stringify({server_id: \"0\"}));\n\n // call all our callbacks when we get a new socket. they will do the\n // work of setting up handlers and such for specific messages.\n _.each(self.registration_callbacks, function (callback) {\n callback(socket);\n });\n });\n\n};\n\n_.extend(StreamServer.prototype, {\n // call my callback when a new socket connects.\n // also call it for all current connections.\n register: function (callback) {\n var self = this;\n self.registration_callbacks.push(callback);\n _.each(self.all_sockets(), function (socket) {\n callback(socket);\n });\n },\n\n // get a list of all sockets\n all_sockets: function () {\n var self = this;\n return _.values(self.open_sockets);\n },\n\n // Redirect /websocket to /sockjs/websocket in order to not expose\n // sockjs to clients that want to use raw websockets\n _redirectWebsocketEndpoint: function() {\n var self = this;\n // Unfortunately we can't use a connect middleware here since\n // sockjs installs itself prior to all existing listeners\n // (meaning prior to any connect middlewares) so we need to take\n // an approach similar to overshadowListeners in\n // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n _.each(['request', 'upgrade'], function(event) {\n var httpServer = WebApp.httpServer;\n var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n httpServer.removeAllListeners(event);\n\n // request and upgrade have different arguments passed but\n // we only care about the first one which is always request\n var newListener = function(request /*, moreArguments */) {\n // Store arguments for use within the closure below\n var args = arguments;\n\n // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n // preserving query string.\n var parsedUrl = url.parse(request.url);\n if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n parsedUrl.pathname === pathPrefix + '/websocket/') {\n parsedUrl.pathname = self.prefix + '/websocket';\n request.url = url.format(parsedUrl);\n }\n _.each(oldHttpServerListeners, function(oldListener) {\n oldListener.apply(httpServer, args);\n });\n };\n httpServer.addListener(event, newListener);\n });\n }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n var self = this;\n self.existsIn = new Set(); // set of subscriptionHandle\n self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n getFields: function () {\n var self = this;\n var ret = {};\n self.dataByKey.forEach(function (precedenceList, key) {\n ret[key] = precedenceList[0].value;\n });\n return ret;\n },\n\n clearField: function (subscriptionHandle, key, changeCollector) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n var precedenceList = self.dataByKey.get(key);\n\n // It's okay to clear fields that didn't exist. No need to throw\n // an error.\n if (!precedenceList)\n return;\n\n var removedValue = undefined;\n for (var i = 0; i < precedenceList.length; i++) {\n var precedence = precedenceList[i];\n if (precedence.subscriptionHandle === subscriptionHandle) {\n // The view's value can only change if this subscription is the one that\n // used to have precedence.\n if (i === 0)\n removedValue = precedence.value;\n precedenceList.splice(i, 1);\n break;\n }\n }\n if (precedenceList.length === 0) {\n self.dataByKey.delete(key);\n changeCollector[key] = undefined;\n } else if (removedValue !== undefined &&\n !EJSON.equals(removedValue, precedenceList[0].value)) {\n changeCollector[key] = precedenceList[0].value;\n }\n },\n\n changeField: function (subscriptionHandle, key, value,\n changeCollector, isAdd) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n\n // Don't share state with the data passed in by the user.\n value = EJSON.clone(value);\n\n if (!self.dataByKey.has(key)) {\n self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n value: value}]);\n changeCollector[key] = value;\n return;\n }\n var precedenceList = self.dataByKey.get(key);\n var elt;\n if (!isAdd) {\n elt = precedenceList.find(function (precedence) {\n return precedence.subscriptionHandle === subscriptionHandle;\n });\n }\n\n if (elt) {\n if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n // this subscription is changing the value of this field.\n changeCollector[key] = value;\n }\n elt.value = value;\n } else {\n // this subscription is newly caring about this field\n precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n }\n\n }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n var self = this;\n self.collectionName = collectionName;\n self.documents = new Map();\n self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n isEmpty: function () {\n var self = this;\n return self.documents.size === 0;\n },\n\n diff: function (previous) {\n var self = this;\n DiffSequence.diffMaps(previous.documents, self.documents, {\n both: _.bind(self.diffDocument, self),\n\n rightOnly: function (id, nowDV) {\n self.callbacks.added(self.collectionName, id, nowDV.getFields());\n },\n\n leftOnly: function (id, prevDV) {\n self.callbacks.removed(self.collectionName, id);\n }\n });\n },\n\n diffDocument: function (id, prevDV, nowDV) {\n var self = this;\n var fields = {};\n DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n both: function (key, prev, now) {\n if (!EJSON.equals(prev, now))\n fields[key] = now;\n },\n rightOnly: function (key, now) {\n fields[key] = now;\n },\n leftOnly: function(key, prev) {\n fields[key] = undefined;\n }\n });\n self.callbacks.changed(self.collectionName, id, fields);\n },\n\n added: function (subscriptionHandle, id, fields) {\n var self = this;\n var docView = self.documents.get(id);\n var added = false;\n if (!docView) {\n added = true;\n docView = new SessionDocumentView();\n self.documents.set(id, docView);\n }\n docView.existsIn.add(subscriptionHandle);\n var changeCollector = {};\n _.each(fields, function (value, key) {\n docView.changeField(\n subscriptionHandle, key, value, changeCollector, true);\n });\n if (added)\n self.callbacks.added(self.collectionName, id, changeCollector);\n else\n self.callbacks.changed(self.collectionName, id, changeCollector);\n },\n\n changed: function (subscriptionHandle, id, changed) {\n var self = this;\n var changedResult = {};\n var docView = self.documents.get(id);\n if (!docView)\n throw new Error(\"Could not find element with id \" + id + \" to change\");\n _.each(changed, function (value, key) {\n if (value === undefined)\n docView.clearField(subscriptionHandle, key, changedResult);\n else\n docView.changeField(subscriptionHandle, key, value, changedResult);\n });\n self.callbacks.changed(self.collectionName, id, changedResult);\n },\n\n removed: function (subscriptionHandle, id) {\n var self = this;\n var docView = self.documents.get(id);\n if (!docView) {\n var err = new Error(\"Removed nonexistent document \" + id);\n throw err;\n }\n docView.existsIn.delete(subscriptionHandle);\n if (docView.existsIn.size === 0) {\n // it is gone from everyone\n self.callbacks.removed(self.collectionName, id);\n self.documents.delete(id);\n } else {\n var changed = {};\n // remove this subscription from every precedence list\n // and record the changes\n docView.dataByKey.forEach(function (precedenceList, key) {\n docView.clearField(subscriptionHandle, key, changed);\n });\n\n self.callbacks.changed(self.collectionName, id, changed);\n }\n }\n});\n\n/******************************************************************************/\n/* Session */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n var self = this;\n self.id = Random.id();\n\n self.server = server;\n self.version = version;\n\n self.initialized = false;\n self.socket = socket;\n\n // set to null when the session is destroyed. multiple places below\n // use this to determine if the session is alive or not.\n self.inQueue = new Meteor._DoubleEndedQueue();\n\n self.blocked = false;\n self.workerRunning = false;\n\n // Sub objects for active subscriptions\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n self.userId = null;\n\n self.collectionViews = new Map();\n\n // Set this to false to not send messages when collectionViews are\n // modified. This is done when rerunning subs in _setUserId and those messages\n // are calculated via a diff instead.\n self._isSending = true;\n\n // If this is true, don't start a newly-created universal publisher on this\n // session. The session will take care of starting it when appropriate.\n self._dontStartNewUniversalSubs = false;\n\n // when we are rerunning subscriptions, any ready messages\n // we want to buffer up for when we are done rerunning subscriptions\n self._pendingReady = [];\n\n // List of callbacks to call when this connection is closed.\n self._closeCallbacks = [];\n\n\n // XXX HACK: If a sockjs connection, save off the URL. This is\n // temporary and will go away in the near future.\n self._socketUrl = socket.url;\n\n // Allow tests to disable responding to pings.\n self._respondToPings = options.respondToPings;\n\n // This object is the public interface to the session. In the public\n // API, it is called the `connection` object. Internally we call it\n // a `connectionHandle` to avoid ambiguity.\n self.connectionHandle = {\n id: self.id,\n close: function () {\n self.close();\n },\n onClose: function (fn) {\n var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n if (self.inQueue) {\n self._closeCallbacks.push(cb);\n } else {\n // if we're already closed, call the callback.\n Meteor.defer(cb);\n }\n },\n clientAddress: self._clientAddress(),\n httpHeaders: self.socket.headers\n };\n\n self.send({ msg: 'connected', session: self.id });\n\n // On initial connect, spin up all the universal publishers.\n Fiber(function () {\n self.startUniversalSubs();\n }).run();\n\n if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n // We no longer need the low level timeout because we have heartbeating.\n socket.setWebsocketTimeout(0);\n\n self.heartbeat = new DDPCommon.Heartbeat({\n heartbeatInterval: options.heartbeatInterval,\n heartbeatTimeout: options.heartbeatTimeout,\n onTimeout: function () {\n self.close();\n },\n sendPing: function () {\n self.send({msg: 'ping'});\n }\n });\n self.heartbeat.start();\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n sendReady: function (subscriptionIds) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"ready\", subs: subscriptionIds});\n else {\n _.each(subscriptionIds, function (subscriptionId) {\n self._pendingReady.push(subscriptionId);\n });\n }\n },\n\n sendAdded: function (collectionName, id, fields) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n },\n\n sendChanged: function (collectionName, id, fields) {\n var self = this;\n if (_.isEmpty(fields))\n return;\n\n if (self._isSending) {\n self.send({\n msg: \"changed\",\n collection: collectionName,\n id: id,\n fields: fields\n });\n }\n },\n\n sendRemoved: function (collectionName, id) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"removed\", collection: collectionName, id: id});\n },\n\n getSendCallbacks: function () {\n var self = this;\n return {\n added: _.bind(self.sendAdded, self),\n changed: _.bind(self.sendChanged, self),\n removed: _.bind(self.sendRemoved, self)\n };\n },\n\n getCollectionView: function (collectionName) {\n var self = this;\n var ret = self.collectionViews.get(collectionName);\n if (!ret) {\n ret = new SessionCollectionView(collectionName,\n self.getSendCallbacks());\n self.collectionViews.set(collectionName, ret);\n }\n return ret;\n },\n\n added: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.added(subscriptionHandle, id, fields);\n },\n\n removed: function (subscriptionHandle, collectionName, id) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.removed(subscriptionHandle, id);\n if (view.isEmpty()) {\n self.collectionViews.delete(collectionName);\n }\n },\n\n changed: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.changed(subscriptionHandle, id, fields);\n },\n\n startUniversalSubs: function () {\n var self = this;\n // Make a shallow copy of the set of universal handlers and start them. If\n // additional universal publishers start while we're running them (due to\n // yielding), they will run separately as part of Server.publish.\n var handlers = _.clone(self.server.universal_publish_handlers);\n _.each(handlers, function (handler) {\n self._startSubscription(handler);\n });\n },\n\n // Destroy this session and unregister it at the server.\n close: function () {\n var self = this;\n\n // Destroy this session, even if it's not registered at the\n // server. Stop all processing and tear everything down. If a socket\n // was attached, close it.\n\n // Already destroyed.\n if (! self.inQueue)\n return;\n\n // Drop the merge box data immediately.\n self.inQueue = null;\n self.collectionViews = new Map();\n\n if (self.heartbeat) {\n self.heartbeat.stop();\n self.heartbeat = null;\n }\n\n if (self.socket) {\n self.socket.close();\n self.socket._meteorSession = null;\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", -1);\n\n Meteor.defer(function () {\n // stop callbacks can yield, so we defer this on close.\n // sub._isDeactivated() detects that we set inQueue to null and\n // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n self._deactivateAllSubscriptions();\n\n // Defer calling the close callbacks, so that the caller closing\n // the session isn't waiting for all the callbacks to complete.\n _.each(self._closeCallbacks, function (callback) {\n callback();\n });\n });\n\n // Unregister the session.\n self.server._removeSession(self);\n },\n\n // Send a message (doing nothing if no socket is connected right now.)\n // It should be a JSON object (it will be stringified.)\n send: function (msg) {\n var self = this;\n if (self.socket) {\n if (Meteor._printSentDDP)\n Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n self.socket.send(DDPCommon.stringifyDDP(msg));\n }\n },\n\n // Send a connection error.\n sendError: function (reason, offendingMessage) {\n var self = this;\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n self.send(msg);\n },\n\n // Process 'msg' as an incoming message. (But as a guard against\n // race conditions during reconnection, ignore the message if\n // 'socket' is not the currently connected socket.)\n //\n // We run the messages from the client one at a time, in the order\n // given by the client. The message handler is passed an idempotent\n // function 'unblock' which it may call to allow other messages to\n // begin running in parallel in another fiber (for example, a method\n // that wants to yield.) Otherwise, it is automatically unblocked\n // when it returns.\n //\n // Actually, we don't have to 'totally order' the messages in this\n // way, but it's the easiest thing that's correct. (unsub needs to\n // be ordered against sub, methods need to be ordered against each\n // other.)\n processMessage: function (msg_in) {\n var self = this;\n if (!self.inQueue) // we have been destroyed.\n return;\n\n // Respond to ping and pong messages immediately without queuing.\n // If the negotiated DDP version is \"pre1\" which didn't support\n // pings, preserve the \"pre1\" behavior of responding with a \"bad\n // request\" for the unknown messages.\n //\n // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n // needs a Fiber. We could actually use regular setTimeout and avoid\n // these new fibers, but it is easier to just make everything use\n // Meteor.setTimeout and not think too hard.\n //\n // Any message counts as receiving a pong, as it demonstrates that\n // the client is still alive.\n if (self.heartbeat) {\n Fiber(function () {\n self.heartbeat.messageReceived();\n }).run();\n }\n\n if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n if (self._respondToPings)\n self.send({msg: \"pong\", id: msg_in.id});\n return;\n }\n if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n // Since everything is a pong, nothing to do\n return;\n }\n\n self.inQueue.push(msg_in);\n if (self.workerRunning)\n return;\n self.workerRunning = true;\n\n var processNext = function () {\n var msg = self.inQueue && self.inQueue.shift();\n if (!msg) {\n self.workerRunning = false;\n return;\n }\n\n Fiber(function () {\n var blocked = true;\n\n var unblock = function () {\n if (!blocked)\n return; // idempotent\n blocked = false;\n processNext();\n };\n\n self.server.onMessageHook.each(function (callback) {\n callback(msg, self);\n return true;\n });\n\n if (_.has(self.protocol_handlers, msg.msg))\n self.protocol_handlers[msg.msg].call(self, msg, unblock);\n else\n self.sendError('Bad request', msg);\n unblock(); // in case the handler didn't already do it\n }).run();\n };\n\n processNext();\n },\n\n protocol_handlers: {\n sub: function (msg) {\n var self = this;\n\n // reject malformed messages\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.name) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array))) {\n self.sendError(\"Malformed subscription\", msg);\n return;\n }\n\n if (!self.server.publish_handlers[msg.name]) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n return;\n }\n\n if (self._namedSubs.has(msg.id))\n // subs are idempotent, or rather, they are ignored if a sub\n // with that id already exists. this is important during\n // reconnect.\n return;\n\n // XXX It'd be much better if we had generic hooks where any package can\n // hook into subscription handling, but in the mean while we special case\n // ddp-rate-limiter package. This is also done for weak requirements to\n // add the ddp-rate-limiter package in case we don't have Accounts. A\n // user trying to use the ddp-rate-limiter must explicitly require it.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"subscription\",\n name: msg.name,\n connectionId: self.id\n };\n\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n if (!rateLimitResult.allowed) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(\n 'too-many-requests',\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset})\n });\n return;\n }\n }\n\n var handler = self.server.publish_handlers[msg.name];\n\n self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n },\n\n unsub: function (msg) {\n var self = this;\n\n self._stopSubscription(msg.id);\n },\n\n method: function (msg, unblock) {\n var self = this;\n\n // reject malformed messages\n // For now, we silently ignore unknown attributes,\n // for forwards compatibility.\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.method) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array)) ||\n (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n self.sendError(\"Malformed method invocation\", msg);\n return;\n }\n\n var randomSeed = msg.randomSeed || null;\n\n // set up to mark the method as satisfied once all observers\n // (and subscriptions) have reacted to any writes that were\n // done.\n var fence = new DDPServer._WriteFence;\n fence.onAllCommitted(function () {\n // Retire the fence so that future writes are allowed.\n // This means that callbacks like timers are free to use\n // the fence, and if they fire before it's armed (for\n // example, because the method waits for them) their\n // writes will be included in the fence.\n fence.retire();\n self.send({\n msg: 'updated', methods: [msg.id]});\n });\n\n // find the handler\n var handler = self.server.method_handlers[msg.method];\n if (!handler) {\n self.send({\n msg: 'result', id: msg.id,\n error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n fence.arm();\n return;\n }\n\n var setUserId = function(userId) {\n self._setUserId(userId);\n };\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId: self.userId,\n setUserId: setUserId,\n unblock: unblock,\n connection: self.connectionHandle,\n randomSeed: randomSeed\n });\n\n const promise = new Promise((resolve, reject) => {\n // XXX It'd be better if we could hook into method handlers better but\n // for now, we need to check if the ddp-rate-limiter exists since we\n // have a weak requirement for the ddp-rate-limiter package to be added\n // to our application.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"method\",\n name: msg.method,\n connectionId: self.id\n };\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n if (!rateLimitResult.allowed) {\n reject(new Meteor.Error(\n \"too-many-requests\",\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset}\n ));\n return;\n }\n }\n\n resolve(DDPServer._CurrentWriteFence.withValue(\n fence,\n () => DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, msg.params,\n \"call to '\" + msg.method + \"'\"\n )\n )\n ));\n });\n\n function finish() {\n fence.arm();\n unblock();\n }\n\n const payload = {\n msg: \"result\",\n id: msg.id\n };\n\n promise.then((result) => {\n finish();\n if (result !== undefined) {\n payload.result = result;\n }\n self.send(payload);\n }, (exception) => {\n finish();\n payload.error = wrapInternalException(\n exception,\n `while invoking method '${msg.method}'`\n );\n self.send(payload);\n });\n }\n },\n\n _eachSub: function (f) {\n var self = this;\n self._namedSubs.forEach(f);\n self._universalSubs.forEach(f);\n },\n\n _diffCollectionViews: function (beforeCVs) {\n var self = this;\n DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n both: function (collectionName, leftValue, rightValue) {\n rightValue.diff(leftValue);\n },\n rightOnly: function (collectionName, rightValue) {\n rightValue.documents.forEach(function (docView, id) {\n self.sendAdded(collectionName, id, docView.getFields());\n });\n },\n leftOnly: function (collectionName, leftValue) {\n leftValue.documents.forEach(function (doc, id) {\n self.sendRemoved(collectionName, id);\n });\n }\n });\n },\n\n // Sets the current user id in all appropriate contexts and reruns\n // all subscriptions\n _setUserId: function(userId) {\n var self = this;\n\n if (userId !== null && typeof userId !== \"string\")\n throw new Error(\"setUserId must be called on string or null, not \" +\n typeof userId);\n\n // Prevent newly-created universal subscriptions from being added to our\n // session; they will be found below when we call startUniversalSubs.\n //\n // (We don't have to worry about named subscriptions, because we only add\n // them when we process a 'sub' message. We are currently processing a\n // 'method' message, and the method did not unblock, because it is illegal\n // to call setUserId after unblock. Thus we cannot be concurrently adding a\n // new named subscription.)\n self._dontStartNewUniversalSubs = true;\n\n // Prevent current subs from updating our collectionViews and call their\n // stop callbacks. This may yield.\n self._eachSub(function (sub) {\n sub._deactivate();\n });\n\n // All subs should now be deactivated. Stop sending messages to the client,\n // save the state of the published collections, reset to an empty view, and\n // update the userId.\n self._isSending = false;\n var beforeCVs = self.collectionViews;\n self.collectionViews = new Map();\n self.userId = userId;\n\n // _setUserId is normally called from a Meteor method with\n // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n // expected to be set inside a publish function, so we temporary unset it.\n // Inside a publish function DDP._CurrentPublicationInvocation is set.\n DDP._CurrentMethodInvocation.withValue(undefined, function () {\n // Save the old named subs, and reset to having no subscriptions.\n var oldNamedSubs = self._namedSubs;\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n oldNamedSubs.forEach(function (sub, subscriptionId) {\n var newSub = sub._recreate();\n self._namedSubs.set(subscriptionId, newSub);\n // nb: if the handler throws or calls this.error(), it will in fact\n // immediately send its 'nosub'. This is OK, though.\n newSub._runHandler();\n });\n\n // Allow newly-created universal subs to be started on our connection in\n // parallel with the ones we're spinning up here, and spin up universal\n // subs.\n self._dontStartNewUniversalSubs = false;\n self.startUniversalSubs();\n });\n\n // Start sending messages again, beginning with the diff from the previous\n // state of the world to the current state. No yields are allowed during\n // this diff, so that other changes cannot interleave.\n Meteor._noYieldsAllowed(function () {\n self._isSending = true;\n self._diffCollectionViews(beforeCVs);\n if (!_.isEmpty(self._pendingReady)) {\n self.sendReady(self._pendingReady);\n self._pendingReady = [];\n }\n });\n },\n\n _startSubscription: function (handler, subId, params, name) {\n var self = this;\n\n var sub = new Subscription(\n self, handler, subId, params, name);\n if (subId)\n self._namedSubs.set(subId, sub);\n else\n self._universalSubs.push(sub);\n\n sub._runHandler();\n },\n\n // tear down specified subscription\n _stopSubscription: function (subId, error) {\n var self = this;\n\n var subName = null;\n if (subId) {\n var maybeSub = self._namedSubs.get(subId);\n if (maybeSub) {\n subName = maybeSub._name;\n maybeSub._removeAllDocuments();\n maybeSub._deactivate();\n self._namedSubs.delete(subId);\n }\n }\n\n var response = {msg: 'nosub', id: subId};\n\n if (error) {\n response.error = wrapInternalException(\n error,\n subName ? (\"from sub \" + subName + \" id \" + subId)\n : (\"from sub id \" + subId));\n }\n\n self.send(response);\n },\n\n // tear down all subscriptions. Note that this does NOT send removed or nosub\n // messages, since we assume the client is gone.\n _deactivateAllSubscriptions: function () {\n var self = this;\n\n self._namedSubs.forEach(function (sub, id) {\n sub._deactivate();\n });\n self._namedSubs = new Map();\n\n self._universalSubs.forEach(function (sub) {\n sub._deactivate();\n });\n self._universalSubs = [];\n },\n\n // Determine the remote client's IP address, based on the\n // HTTP_FORWARDED_COUNT environment variable representing how many\n // proxies the server is behind.\n _clientAddress: function () {\n var self = this;\n\n // For the reported client address for a connection to be correct,\n // the developer must set the HTTP_FORWARDED_COUNT environment\n // variable to an integer representing the number of hops they\n // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n // server is behind one proxy.\n //\n // This could be computed once at startup instead of every time.\n var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n if (httpForwardedCount === 0)\n return self.socket.remoteAddress;\n\n var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n if (! _.isString(forwardedFor))\n return null;\n forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n // Typically the first value in the `x-forwarded-for` header is\n // the original IP address of the client connecting to the first\n // proxy. However, the end user can easily spoof the header, in\n // which case the first value(s) will be the fake IP address from\n // the user pretending to be a proxy reporting the original IP\n // address value. By counting HTTP_FORWARDED_COUNT back from the\n // end of the list, we ensure that we get the IP address being\n // reported by *our* first proxy.\n\n if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n return null;\n\n return forwardedFor[forwardedFor.length - httpForwardedCount];\n }\n});\n\n/******************************************************************************/\n/* Subscription */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n session, handler, subscriptionId, params, name) {\n var self = this;\n self._session = session; // type is Session\n\n /**\n * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n * @locus Server\n * @name connection\n * @memberOf Subscription\n * @instance\n */\n self.connection = session.connectionHandle; // public API object\n\n self._handler = handler;\n\n // my subscription ID (generated by client, undefined for universal subs).\n self._subscriptionId = subscriptionId;\n // undefined for universal subs\n self._name = name;\n\n self._params = params || [];\n\n // Only named subscriptions have IDs, but we need some sort of string\n // internally to keep track of all subscriptions inside\n // SessionDocumentViews. We use this subscriptionHandle for that.\n if (self._subscriptionId) {\n self._subscriptionHandle = 'N' + self._subscriptionId;\n } else {\n self._subscriptionHandle = 'U' + Random.id();\n }\n\n // has _deactivate been called?\n self._deactivated = false;\n\n // stop callbacks to g/c this sub. called w/ zero arguments.\n self._stopCallbacks = [];\n\n // the set of (collection, documentid) that this subscription has\n // an opinion about\n self._documents = new Map();\n\n // remember if we are ready.\n self._ready = false;\n\n // Part of the public API: the user of this sub.\n\n /**\n * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n * @locus Server\n * @memberOf Subscription\n * @name userId\n * @instance\n */\n self.userId = session.userId;\n\n // For now, the id filter is going to default to\n // the to/from DDP methods on MongoID, to\n // specifically deal with mongo/minimongo ObjectIds.\n\n // Later, you will be able to make this be \"raw\"\n // if you want to publish a collection that you know\n // just has strings for keys and no funny business, to\n // a ddp consumer that isn't minimongo\n\n self._idFilter = {\n idStringify: MongoID.idStringify,\n idParse: MongoID.idParse\n };\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n _runHandler: function () {\n // XXX should we unblock() here? Either before running the publish\n // function, or before running _publishCursor.\n //\n // Right now, each publish function blocks all future publishes and\n // methods waiting on data from Mongo (or whatever else the function\n // blocks on). This probably slows page load in common cases.\n\n var self = this;\n try {\n var res = DDP._CurrentPublicationInvocation.withValue(\n self,\n () => maybeAuditArgumentChecks(\n self._handler, self, EJSON.clone(self._params),\n // It's OK that this would look weird for universal subscriptions,\n // because they have no arguments so there can never be an\n // audit-argument-checks failure.\n \"publisher '\" + self._name + \"'\"\n )\n );\n } catch (e) {\n self.error(e);\n return;\n }\n\n // Did the handler call this.error or this.stop?\n if (self._isDeactivated())\n return;\n\n self._publishHandlerResult(res);\n },\n\n _publishHandlerResult: function (res) {\n // SPECIAL CASE: Instead of writing their own callbacks that invoke\n // this.added/changed/ready/etc, the user can just return a collection\n // cursor or array of cursors from the publish function; we call their\n // _publishCursor method which starts observing the cursor and publishes the\n // results. Note that _publishCursor does NOT call ready().\n //\n // XXX This uses an undocumented interface which only the Mongo cursor\n // interface publishes. Should we make this interface public and encourage\n // users to implement it themselves? Arguably, it's unnecessary; users can\n // already write their own functions like\n // var publishMyReactiveThingy = function (name, handler) {\n // Meteor.publish(name, function () {\n // var reactiveThingy = handler();\n // reactiveThingy.publishMe();\n // });\n // };\n\n var self = this;\n var isCursor = function (c) {\n return c && c._publishCursor;\n };\n if (isCursor(res)) {\n try {\n res._publishCursor(self);\n } catch (e) {\n self.error(e);\n return;\n }\n // _publishCursor only returns after the initial added callbacks have run.\n // mark subscription as ready.\n self.ready();\n } else if (_.isArray(res)) {\n // check all the elements are cursors\n if (! _.all(res, isCursor)) {\n self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n return;\n }\n // find duplicate collection names\n // XXX we should support overlapping cursors, but that would require the\n // merge box to allow overlap within a subscription\n var collectionNames = {};\n for (var i = 0; i < res.length; ++i) {\n var collectionName = res[i]._getCollectionName();\n if (_.has(collectionNames, collectionName)) {\n self.error(new Error(\n \"Publish function returned multiple cursors for collection \" +\n collectionName));\n return;\n }\n collectionNames[collectionName] = true;\n };\n\n try {\n _.each(res, function (cur) {\n cur._publishCursor(self);\n });\n } catch (e) {\n self.error(e);\n return;\n }\n self.ready();\n } else if (res) {\n // truthy values other than cursors or arrays are probably a\n // user mistake (possible returning a Mongo document via, say,\n // `coll.findOne()`).\n self.error(new Error(\"Publish function can only return a Cursor or \"\n + \"an array of Cursors\"));\n }\n },\n\n // This calls all stop callbacks and prevents the handler from updating any\n // SessionCollectionViews further. It's used when the user unsubscribes or\n // disconnects, as well as during setUserId re-runs. It does *NOT* send\n // removed messages for the published objects; if that is necessary, call\n // _removeAllDocuments first.\n _deactivate: function() {\n var self = this;\n if (self._deactivated)\n return;\n self._deactivated = true;\n self._callStopCallbacks();\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", -1);\n },\n\n _callStopCallbacks: function () {\n var self = this;\n // tell listeners, so they can clean up\n var callbacks = self._stopCallbacks;\n self._stopCallbacks = [];\n _.each(callbacks, function (callback) {\n callback();\n });\n },\n\n // Send remove messages for every document.\n _removeAllDocuments: function () {\n var self = this;\n Meteor._noYieldsAllowed(function () {\n self._documents.forEach(function (collectionDocs, collectionName) {\n collectionDocs.forEach(function (strId) {\n self.removed(collectionName, self._idFilter.idParse(strId));\n });\n });\n });\n },\n\n // Returns a new Subscription for the same session with the same\n // initial creation parameters. This isn't a clone: it doesn't have\n // the same _documents cache, stopped state or callbacks; may have a\n // different _subscriptionHandle, and gets its userId from the\n // session, not from this object.\n _recreate: function () {\n var self = this;\n return new Subscription(\n self._session, self._handler, self._subscriptionId, self._params,\n self._name);\n },\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n * @locus Server\n * @param {Error} error The error to pass to the client.\n * @instance\n * @memberOf Subscription\n */\n error: function (error) {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId, error);\n },\n\n // Note that while our DDP client will notice that you've called stop() on the\n // server (and clean up its _subscriptions table) we don't actually provide a\n // mechanism for an app to notice this (the subscribe onError callback only\n // triggers if there is an error).\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error.\n * @locus Server\n * @instance\n * @memberOf Subscription\n */\n stop: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId);\n },\n\n /**\n * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {Function} func The callback function\n */\n onStop: function (callback) {\n var self = this;\n callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n if (self._isDeactivated())\n callback();\n else\n self._stopCallbacks.push(callback);\n },\n\n // This returns true if the sub has been deactivated, *OR* if the session was\n // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n // happened yet.\n _isDeactivated: function () {\n var self = this;\n return self._deactivated || self._session.inQueue === null;\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the new document.\n * @param {String} id The new document's ID.\n * @param {Object} fields The fields in the new document. If `_id` is present it is ignored.\n */\n added: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n let ids = self._documents.get(collectionName);\n if (ids == null) {\n ids = new Set();\n self._documents.set(collectionName, ids);\n }\n ids.add(id);\n self._session.added(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the changed document.\n * @param {String} id The changed document's ID.\n * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored.\n */\n changed: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that the document has been removed from.\n * @param {String} id The ID of the document that has been removed.\n */\n removed: function (collectionName, id) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n // We don't bother to delete sets of things in a collection if the\n // collection is empty. It could break _removeAllDocuments.\n self._documents.get(collectionName).delete(id);\n self._session.removed(self._subscriptionHandle, collectionName, id);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any.\n * @locus Server\n * @memberOf Subscription\n * @instance\n */\n ready: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n if (!self._subscriptionId)\n return; // unnecessary but ignored for universal sub\n if (!self._ready) {\n self._session.sendReady([self._subscriptionId]);\n self._ready = true;\n }\n }\n});\n\n/******************************************************************************/\n/* Server */\n/******************************************************************************/\n\nServer = function (options) {\n var self = this;\n\n // The default heartbeat interval is 30 seconds on the server and 35\n // seconds on the client. Since the client doesn't need to send a\n // ping as long as it is receiving pings, this means that pings\n // normally go from the server to the client.\n //\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n self.options = _.defaults(options || {}, {\n heartbeatInterval: 15000,\n heartbeatTimeout: 15000,\n // For testing, allow responding to pings to be disabled.\n respondToPings: true\n });\n\n // Map of callbacks to call when a new connection comes in to the\n // server and completes DDP version negotiation. Use an object instead\n // of an array so we can safely remove one from the list while\n // iterating over it.\n self.onConnectionHook = new Hook({\n debugPrintExceptions: \"onConnection callback\"\n });\n\n // Map of callbacks to call when a new message comes in.\n self.onMessageHook = new Hook({\n debugPrintExceptions: \"onMessage callback\"\n });\n\n self.publish_handlers = {};\n self.universal_publish_handlers = [];\n\n self.method_handlers = {};\n\n self.sessions = new Map(); // map from id to session\n\n self.stream_server = new StreamServer;\n\n self.stream_server.register(function (socket) {\n // socket implements the SockJSConnection interface\n socket._meteorSession = null;\n\n var sendError = function (reason, offendingMessage) {\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n socket.send(DDPCommon.stringifyDDP(msg));\n };\n\n socket.on('data', function (raw_msg) {\n if (Meteor._printReceivedDDP) {\n Meteor._debug(\"Received DDP\", raw_msg);\n }\n try {\n try {\n var msg = DDPCommon.parseDDP(raw_msg);\n } catch (err) {\n sendError('Parse error');\n return;\n }\n if (msg === null || !msg.msg) {\n sendError('Bad request', msg);\n return;\n }\n\n if (msg.msg === 'connect') {\n if (socket._meteorSession) {\n sendError(\"Already connected\", msg);\n return;\n }\n Fiber(function () {\n self._handleConnect(socket, msg);\n }).run();\n return;\n }\n\n if (!socket._meteorSession) {\n sendError('Must connect first', msg);\n return;\n }\n socket._meteorSession.processMessage(msg);\n } catch (e) {\n // XXX print stack nicely\n Meteor._debug(\"Internal exception while processing message\", msg, e);\n }\n });\n\n socket.on('close', function () {\n if (socket._meteorSession) {\n Fiber(function () {\n socket._meteorSession.close();\n }).run();\n }\n });\n });\n};\n\n_.extend(Server.prototype, {\n\n /**\n * @summary Register a callback to be called when a new DDP connection is made to the server.\n * @locus Server\n * @param {function} callback The function to call when a new DDP connection is established.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onConnection: function (fn) {\n var self = this;\n return self.onConnectionHook.register(fn);\n },\n\n /**\n * @summary Register a callback to be called when a new DDP message is received.\n * @locus Server\n * @param {function} callback The function to call when a new DDP message is received.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onMessage: function (fn) {\n var self = this;\n return self.onMessageHook.register(fn);\n },\n\n _handleConnect: function (socket, msg) {\n var self = this;\n\n // The connect message must specify a version and an array of supported\n // versions, and it must claim to support what it is proposing.\n if (!(typeof (msg.version) === 'string' &&\n _.isArray(msg.support) &&\n _.all(msg.support, _.isString) &&\n _.contains(msg.support, msg.version))) {\n socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n socket.close();\n return;\n }\n\n // In the future, handle session resumption: something like:\n // socket._meteorSession = self.sessions[msg.session]\n var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n if (msg.version !== version) {\n // The best version to use (according to the client's stated preferences)\n // is not the one the client is trying to use. Inform them about the best\n // version to use.\n socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n socket.close();\n return;\n }\n\n // Yay, version matches! Create a new session.\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n socket._meteorSession = new Session(self, version, socket, self.options);\n self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n self.onConnectionHook.each(function (callback) {\n if (socket._meteorSession)\n callback(socket._meteorSession.connectionHandle);\n return true;\n });\n },\n /**\n * Register a publish handler function.\n *\n * @param name {String} identifier for query\n * @param handler {Function} publish handler\n * @param options {Object}\n *\n * Server will call handler function on each new subscription,\n * either when receiving DDP sub message for a named subscription, or on\n * DDP connect for a universal subscription.\n *\n * If name is null, this will be a subscription that is\n * automatically established and permanently on for all connected\n * client, instead of a subscription that can be turned on and off\n * with subscribe().\n *\n * options to contain:\n * - (mostly internal) is_auto: true if generated automatically\n * from an autopublish hook. this is for cosmetic purposes only\n * (it lets us determine whether to print a warning suggesting\n * that you turn off autopublish.)\n */\n\n /**\n * @summary Publish a record set.\n * @memberOf Meteor\n * @importFromPackage meteor\n * @locus Server\n * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments.\n */\n publish: function (name, handler, options) {\n var self = this;\n\n if (! _.isObject(name)) {\n options = options || {};\n\n if (name && name in self.publish_handlers) {\n Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n return;\n }\n\n if (Package.autopublish && !options.is_auto) {\n // They have autopublish on, yet they're trying to manually\n // picking stuff to publish. They probably should turn off\n // autopublish. (This check isn't perfect -- if you create a\n // publish before you turn on autopublish, it won't catch\n // it. But this will definitely handle the simple case where\n // you've added the autopublish package to your app, and are\n // calling publish from your app code.)\n if (!self.warned_about_autopublish) {\n self.warned_about_autopublish = true;\n Meteor._debug(\n \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n \"** will still be sent to all clients.\\n\" +\n \"**\\n\" +\n \"** Turn off autopublish by removing the autopublish package:\\n\" +\n \"**\\n\" +\n \"** $ meteor remove autopublish\\n\" +\n \"**\\n\" +\n \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n \"** for each collection that you want clients to see.\\n\");\n }\n }\n\n if (name)\n self.publish_handlers[name] = handler;\n else {\n self.universal_publish_handlers.push(handler);\n // Spin up the new publisher on any existing session too. Run each\n // session's subscription in a new Fiber, so that there's no change for\n // self.sessions to change while we're running this loop.\n self.sessions.forEach(function (session) {\n if (!session._dontStartNewUniversalSubs) {\n Fiber(function() {\n session._startSubscription(handler);\n }).run();\n }\n });\n }\n }\n else{\n _.each(name, function(value, key) {\n self.publish(key, value, {});\n });\n }\n },\n\n _removeSession: function (session) {\n var self = this;\n self.sessions.delete(session.id);\n },\n\n /**\n * @summary Defines functions that can be invoked over the network by clients.\n * @locus Anywhere\n * @param {Object} methods Dictionary whose keys are method names and values are functions.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n methods: function (methods) {\n var self = this;\n _.each(methods, function (func, name) {\n if (typeof func !== 'function')\n throw new Error(\"Method '\" + name + \"' must be a function\");\n if (self.method_handlers[name])\n throw new Error(\"A method named '\" + name + \"' is already defined\");\n self.method_handlers[name] = func;\n });\n },\n\n call: function (name, ...args) {\n if (args.length && typeof args[args.length - 1] === \"function\") {\n // If it's a function, the last argument is the result callback, not\n // a parameter to the remote method.\n var callback = args.pop();\n }\n\n return this.apply(name, args, callback);\n },\n\n // A version of the call method that always returns a Promise.\n callAsync: function (name, ...args) {\n return this.applyAsync(name, args);\n },\n\n apply: function (name, args, options, callback) {\n // We were passed 3 arguments. They may be either (name, args, options)\n // or (name, args, callback)\n if (! callback && typeof options === 'function') {\n callback = options;\n options = {};\n } else {\n options = options || {};\n }\n\n const promise = this.applyAsync(name, args, options);\n\n // Return the result in whichever way the caller asked for it. Note that we\n // do NOT block on the write fence in an analogous way to how the client\n // blocks on the relevant data being visible, so you are NOT guaranteed that\n // cursor observe callbacks have fired when your callback is invoked. (We\n // can change this if there's a real use case.)\n if (callback) {\n promise.then(\n result => callback(undefined, result),\n exception => callback(exception)\n );\n } else {\n return promise.await();\n }\n },\n\n // @param options {Optional Object}\n applyAsync: function (name, args, options) {\n // Run the handler\n var handler = this.method_handlers[name];\n if (! handler) {\n return Promise.reject(\n new Meteor.Error(404, `Method '${name}' not found`)\n );\n }\n\n // If this is a method call from within another method or publish function,\n // get the user state from the outer method or publish function, otherwise\n // don't allow setUserId to be called\n var userId = null;\n var setUserId = function() {\n throw new Error(\"Can't call setUserId on a server initiated method call\");\n };\n var connection = null;\n var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n var randomSeed = null;\n if (currentMethodInvocation) {\n userId = currentMethodInvocation.userId;\n setUserId = function(userId) {\n currentMethodInvocation.setUserId(userId);\n };\n connection = currentMethodInvocation.connection;\n randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n } else if (currentPublicationInvocation) {\n userId = currentPublicationInvocation.userId;\n setUserId = function(userId) {\n currentPublicationInvocation._session._setUserId(userId);\n };\n connection = currentPublicationInvocation.connection;\n }\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId,\n setUserId,\n connection,\n randomSeed\n });\n\n return new Promise(resolve => resolve(\n DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, EJSON.clone(args),\n \"internal call to '\" + name + \"'\"\n )\n )\n )).then(EJSON.clone);\n },\n\n _urlForSession: function (sessionId) {\n var self = this;\n var session = self.sessions.get(sessionId);\n if (session)\n return session._socketUrl;\n else\n return null;\n }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n serverSupportedVersions) {\n var correctVersion = _.find(clientSupportedVersions, function (version) {\n return _.contains(serverSupportedVersions, version);\n });\n if (!correctVersion) {\n correctVersion = serverSupportedVersions[0];\n }\n return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n if (!exception) return exception;\n\n // To allow packages to throw errors intended for the client but not have to\n // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n // error before it is thrown.\n if (exception.isClientSafe) {\n if (!(exception instanceof Meteor.Error)) {\n const originalMessage = exception.message;\n exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n exception.message = originalMessage;\n }\n return exception;\n }\n\n // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n // the server log.\n if (!exception._expectedByTest) {\n Meteor._debug(\"Exception \" + context, exception.stack);\n if (exception.sanitizedError) {\n Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n Meteor._debug();\n }\n }\n\n // Did the error contain more details that could have been useful if caught in\n // server code (or if thrown from non-client-originated code), but also\n // provided a \"sanitized\" version with more context than 500 Internal server\n // error? Use that.\n if (exception.sanitizedError) {\n if (exception.sanitizedError.isClientSafe)\n return exception.sanitizedError;\n Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n \"does not have isClientSafe property set; ignoring\");\n }\n\n return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n args = args || [];\n if (Package['audit-argument-checks']) {\n return Match._failIfArgumentsAreNotAllChecked(\n f, context, args, description);\n }\n return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n var self = this;\n\n self.armed = false;\n self.fired = false;\n self.retired = false;\n self.outstanding_writes = 0;\n self.before_fire_callbacks = [];\n self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n // Start tracking a write, and return an object to represent it. The\n // object has a single method, committed(). This method should be\n // called when the write is fully committed and propagated. You can\n // continue to add writes to the WriteFence up until it is triggered\n // (calls its callbacks because all writes have committed.)\n beginWrite: function () {\n var self = this;\n\n if (self.retired)\n return { committed: function () {} };\n\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to add writes\");\n\n self.outstanding_writes++;\n var committed = false;\n return {\n committed: function () {\n if (committed)\n throw new Error(\"committed called twice on the same write\");\n committed = true;\n self.outstanding_writes--;\n self._maybeFire();\n }\n };\n },\n\n // Arm the fence. Once the fence is armed, and there are no more\n // uncommitted writes, it will activate.\n arm: function () {\n var self = this;\n if (self === DDPServer._CurrentWriteFence.get())\n throw Error(\"Can't arm the current fence\");\n self.armed = true;\n self._maybeFire();\n },\n\n // Register a function to be called once before firing the fence.\n // Callback function can add new writes to the fence, in which case\n // it won't fire until those writes are done as well.\n onBeforeFire: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.before_fire_callbacks.push(func);\n },\n\n // Register a function to be called when the fence fires.\n onAllCommitted: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.completion_callbacks.push(func);\n },\n\n // Convenience function. Arms the fence, then blocks until it fires.\n armAndWait: function () {\n var self = this;\n var future = new Future;\n self.onAllCommitted(function () {\n future['return']();\n });\n self.arm();\n future.wait();\n },\n\n _maybeFire: function () {\n var self = this;\n if (self.fired)\n throw new Error(\"write fence already activated?\");\n if (self.armed && !self.outstanding_writes) {\n function invokeCallback (func) {\n try {\n func(self);\n } catch (err) {\n Meteor._debug(\"exception in write fence callback\", err);\n }\n }\n\n self.outstanding_writes++;\n while (self.before_fire_callbacks.length > 0) {\n var callbacks = self.before_fire_callbacks;\n self.before_fire_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n self.outstanding_writes--;\n\n if (!self.outstanding_writes) {\n self.fired = true;\n var callbacks = self.completion_callbacks;\n self.completion_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n }\n },\n\n // Deactivate this fence so that adding more writes has no effect.\n // The fence must have already fired.\n retire: function () {\n var self = this;\n if (! self.fired)\n throw new Error(\"Can't retire a fence that hasn't fired.\");\n self.retired = true;\n }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n var self = this;\n options = options || {};\n\n self.nextId = 1;\n // map from collection name (string) -> listener id -> object. each object has\n // keys 'trigger', 'callback'. As a hack, the empty string means \"no\n // collection\".\n self.listenersByCollection = {};\n self.listenersByCollectionCount = {};\n self.factPackage = options.factPackage || \"livedata\";\n self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n // msg is a trigger or a notification\n _collectionForMessage: function (msg) {\n var self = this;\n if (! _.has(msg, 'collection')) {\n return '';\n } else if (typeof(msg.collection) === 'string') {\n if (msg.collection === '')\n throw Error(\"Message has empty collection!\");\n return msg.collection;\n } else {\n throw Error(\"Message has non-string collection!\");\n }\n },\n\n // Listen for notification that match 'trigger'. A notification\n // matches if it has the key-value pairs in trigger as a\n // subset. When a notification matches, call 'callback', passing\n // the actual notification.\n //\n // Returns a listen handle, which is an object with a method\n // stop(). Call stop() to stop listening.\n //\n // XXX It should be legal to call fire() from inside a listen()\n // callback?\n listen: function (trigger, callback) {\n var self = this;\n var id = self.nextId++;\n\n var collection = self._collectionForMessage(trigger);\n var record = {trigger: EJSON.clone(trigger), callback: callback};\n if (! _.has(self.listenersByCollection, collection)) {\n self.listenersByCollection[collection] = {};\n self.listenersByCollectionCount[collection] = 0;\n }\n self.listenersByCollection[collection][id] = record;\n self.listenersByCollectionCount[collection]++;\n\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, 1);\n }\n\n return {\n stop: function () {\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, -1);\n }\n delete self.listenersByCollection[collection][id];\n self.listenersByCollectionCount[collection]--;\n if (self.listenersByCollectionCount[collection] === 0) {\n delete self.listenersByCollection[collection];\n delete self.listenersByCollectionCount[collection];\n }\n }\n };\n },\n\n // Fire the provided 'notification' (an object whose attribute\n // values are all JSON-compatibile) -- inform all matching listeners\n // (registered with listen()).\n //\n // If fire() is called inside a write fence, then each of the\n // listener callbacks will be called inside the write fence as well.\n //\n // The listeners may be invoked in parallel, rather than serially.\n fire: function (notification) {\n var self = this;\n\n var collection = self._collectionForMessage(notification);\n\n if (! _.has(self.listenersByCollection, collection)) {\n return;\n }\n\n var listenersForCollection = self.listenersByCollection[collection];\n var callbackIds = [];\n _.each(listenersForCollection, function (l, id) {\n if (self._matches(notification, l.trigger)) {\n callbackIds.push(id);\n }\n });\n\n // Listener callbacks can yield, so we need to first find all the ones that\n // match in a single iteration over self.listenersByCollection (which can't\n // be mutated during this iteration), and then invoke the matching\n // callbacks, checking before each call to ensure they haven't stopped.\n // Note that we don't have to check that\n // self.listenersByCollection[collection] still === listenersForCollection,\n // because the only way that stops being true is if listenersForCollection\n // first gets reduced down to the empty object (and then never gets\n // increased again).\n _.each(callbackIds, function (id) {\n if (_.has(listenersForCollection, id)) {\n listenersForCollection[id].callback(notification);\n }\n });\n },\n\n // A notification matches a trigger if all keys that exist in both are equal.\n //\n // Examples:\n // N:{collection: \"C\"} matches T:{collection: \"C\"}\n // (a non-targeted write to a collection matches a\n // non-targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n // (a targeted write to a collection matches a non-targeted query)\n // N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n // (a non-targeted write to a collection matches a\n // targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n // (a targeted write to a collection matches a targeted query targeted\n // at the same document)\n // N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n // (a targeted write to a collection does not match a targeted query\n // targeted at a different document)\n _matches: function (notification, trigger) {\n // Most notifications that use the crossbar have a string `collection` and\n // maybe an `id` that is a string or ObjectID. We're already dividing up\n // triggers by collection, but let's fast-track \"nope, different ID\" (and\n // avoid the overly generic EJSON.equals). This makes a noticeable\n // performance difference; see https://github.com/meteor/meteor/pull/3697\n if (typeof(notification.id) === 'string' &&\n typeof(trigger.id) === 'string' &&\n notification.id !== trigger.id) {\n return false;\n }\n if (notification.id instanceof MongoID.ObjectID &&\n trigger.id instanceof MongoID.ObjectID &&\n ! notification.id.equals(trigger.id)) {\n return false;\n }\n\n return _.all(trigger, function (triggerValue, key) {\n return !_.has(notification, key) ||\n EJSON.equals(triggerValue, notification[key]);\n });\n }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n function (name) {\n Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} \ No newline at end of file +{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","disable_cors","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n var extensions = [];\n\n var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n if (websocketCompressionConfig) {\n extensions.push(Npm.require('permessage-deflate').configure(\n websocketCompressionConfig\n ));\n }\n\n return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n var self = this;\n self.registration_callbacks = [];\n self.open_sockets = [];\n\n // Because we are installing directly onto WebApp.httpServer instead of using\n // WebApp.app, we have to process the path prefix ourselves.\n self.prefix = pathPrefix + '/sockjs';\n RoutePolicy.declare(self.prefix + '/', 'network');\n\n // set up sockjs\n var sockjs = Npm.require('sockjs');\n var serverOptions = {\n prefix: self.prefix,\n log: function () { },\n // this is the default, but we code it explicitly because we depend\n // on it in stream_client:HEARTBEAT_TIMEOUT\n heartbeat_delay: 45000,\n // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n // bound for that much time, SockJS might not notice that the user has\n // reconnected because the timer (of disconnect_delay ms) can fire before\n // SockJS processes the new connection. Eventually we'll fix this by not\n // combining CPU-heavy processing with SockJS termination (eg a proxy which\n // converts to Unix sockets) but for now, raise the delay.\n disconnect_delay: 60 * 1000,\n // Set the USE_JSESSIONID environment variable to enable setting the\n // JSESSIONID cookie. This is useful for setting up proxies with\n // session affinity.\n jsessionid: !!process.env.USE_JSESSIONID,\n // 禁用cors，防止请求response返回Access-Control-Allow-Origin:*\n disable_cors: true\n };\n\n // If you know your server environment (eg, proxies) will prevent websockets\n // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n // browsers) will not waste time attempting to use them.\n // (Your server will still have a /websocket endpoint.)\n if (process.env.DISABLE_WEBSOCKETS) {\n serverOptions.websocket = false;\n } else {\n serverOptions.faye_server_options = {\n extensions: websocketExtensions()\n };\n }\n\n self.server = sockjs.createServer(serverOptions);\n\n // Install the sockjs handlers, but we want to keep around our own particular\n // request handler that adjusts idle timeouts while we have an outstanding\n // request. This compensates for the fact that sockjs removes all listeners\n // for \"request\" to add its own.\n WebApp.httpServer.removeListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n self.server.installHandlers(WebApp.httpServer);\n WebApp.httpServer.addListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n\n // Support the /websocket endpoint\n self._redirectWebsocketEndpoint();\n\n self.server.on('connection', function (socket) {\n // We want to make sure that if a client connects to us and does the initial\n // Websocket handshake but never gets to the DDP handshake, that we\n // eventually kill the socket. Once the DDP handshake happens, DDP\n // heartbeating will work. And before the Websocket handshake, the timeouts\n // we set at the server level in webapp_server.js will work. But\n // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n // is an \"in between\" state where this doesn't happen. We work around this\n // by explicitly setting the socket timeout to a relatively large time here,\n // and setting it back to zero when we set up the heartbeat in\n // livedata_server.js.\n socket.setWebsocketTimeout = function (timeout) {\n if ((socket.protocol === 'websocket' ||\n socket.protocol === 'websocket-raw')\n && socket._session.recv) {\n socket._session.recv.connection.setTimeout(timeout);\n }\n };\n socket.setWebsocketTimeout(45 * 1000);\n\n socket.send = function (data) {\n socket.write(data);\n };\n socket.on('close', function () {\n self.open_sockets = _.without(self.open_sockets, socket);\n });\n self.open_sockets.push(socket);\n\n // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n // will force old clients to reload. Remove this once we're not\n // concerned about people upgrading from a pre-0.7.0 release. Also,\n // remove the clause in the client that ignores the welcome message\n // (livedata_connection.js)\n socket.send(JSON.stringify({ server_id: \"0\" }));\n\n // call all our callbacks when we get a new socket. they will do the\n // work of setting up handlers and such for specific messages.\n _.each(self.registration_callbacks, function (callback) {\n callback(socket);\n });\n });\n\n};\n\n_.extend(StreamServer.prototype, {\n // call my callback when a new socket connects.\n // also call it for all current connections.\n register: function (callback) {\n var self = this;\n self.registration_callbacks.push(callback);\n _.each(self.all_sockets(), function (socket) {\n callback(socket);\n });\n },\n\n // get a list of all sockets\n all_sockets: function () {\n var self = this;\n return _.values(self.open_sockets);\n },\n\n // Redirect /websocket to /sockjs/websocket in order to not expose\n // sockjs to clients that want to use raw websockets\n _redirectWebsocketEndpoint: function () {\n var self = this;\n // Unfortunately we can't use a connect middleware here since\n // sockjs installs itself prior to all existing listeners\n // (meaning prior to any connect middlewares) so we need to take\n // an approach similar to overshadowListeners in\n // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n _.each(['request', 'upgrade'], function (event) {\n var httpServer = WebApp.httpServer;\n var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n httpServer.removeAllListeners(event);\n\n // request and upgrade have different arguments passed but\n // we only care about the first one which is always request\n var newListener = function (request /*, moreArguments */) {\n // Store arguments for use within the closure below\n var args = arguments;\n\n // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n // preserving query string.\n var parsedUrl = url.parse(request.url);\n if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n parsedUrl.pathname === pathPrefix + '/websocket/') {\n parsedUrl.pathname = self.prefix + '/websocket';\n request.url = url.format(parsedUrl);\n }\n _.each(oldHttpServerListeners, function (oldListener) {\n oldListener.apply(httpServer, args);\n });\n };\n httpServer.addListener(event, newListener);\n });\n }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n var self = this;\n self.existsIn = new Set(); // set of subscriptionHandle\n self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n getFields: function () {\n var self = this;\n var ret = {};\n self.dataByKey.forEach(function (precedenceList, key) {\n ret[key] = precedenceList[0].value;\n });\n return ret;\n },\n\n clearField: function (subscriptionHandle, key, changeCollector) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n var precedenceList = self.dataByKey.get(key);\n\n // It's okay to clear fields that didn't exist. No need to throw\n // an error.\n if (!precedenceList)\n return;\n\n var removedValue = undefined;\n for (var i = 0; i < precedenceList.length; i++) {\n var precedence = precedenceList[i];\n if (precedence.subscriptionHandle === subscriptionHandle) {\n // The view's value can only change if this subscription is the one that\n // used to have precedence.\n if (i === 0)\n removedValue = precedence.value;\n precedenceList.splice(i, 1);\n break;\n }\n }\n if (precedenceList.length === 0) {\n self.dataByKey.delete(key);\n changeCollector[key] = undefined;\n } else if (removedValue !== undefined &&\n !EJSON.equals(removedValue, precedenceList[0].value)) {\n changeCollector[key] = precedenceList[0].value;\n }\n },\n\n changeField: function (subscriptionHandle, key, value,\n changeCollector, isAdd) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n\n // Don't share state with the data passed in by the user.\n value = EJSON.clone(value);\n\n if (!self.dataByKey.has(key)) {\n self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n value: value}]);\n changeCollector[key] = value;\n return;\n }\n var precedenceList = self.dataByKey.get(key);\n var elt;\n if (!isAdd) {\n elt = precedenceList.find(function (precedence) {\n return precedence.subscriptionHandle === subscriptionHandle;\n });\n }\n\n if (elt) {\n if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n // this subscription is changing the value of this field.\n changeCollector[key] = value;\n }\n elt.value = value;\n } else {\n // this subscription is newly caring about this field\n precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n }\n\n }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n var self = this;\n self.collectionName = collectionName;\n self.documents = new Map();\n self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n isEmpty: function () {\n var self = this;\n return self.documents.size === 0;\n },\n\n diff: function (previous) {\n var self = this;\n DiffSequence.diffMaps(previous.documents, self.documents, {\n both: _.bind(self.diffDocument, self),\n\n rightOnly: function (id, nowDV) {\n self.callbacks.added(self.collectionName, id, nowDV.getFields());\n },\n\n leftOnly: function (id, prevDV) {\n self.callbacks.removed(self.collectionName, id);\n }\n });\n },\n\n diffDocument: function (id, prevDV, nowDV) {\n var self = this;\n var fields = {};\n DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n both: function (key, prev, now) {\n if (!EJSON.equals(prev, now))\n fields[key] = now;\n },\n rightOnly: function (key, now) {\n fields[key] = now;\n },\n leftOnly: function(key, prev) {\n fields[key] = undefined;\n }\n });\n self.callbacks.changed(self.collectionName, id, fields);\n },\n\n added: function (subscriptionHandle, id, fields) {\n var self = this;\n var docView = self.documents.get(id);\n var added = false;\n if (!docView) {\n added = true;\n docView = new SessionDocumentView();\n self.documents.set(id, docView);\n }\n docView.existsIn.add(subscriptionHandle);\n var changeCollector = {};\n _.each(fields, function (value, key) {\n docView.changeField(\n subscriptionHandle, key, value, changeCollector, true);\n });\n if (added)\n self.callbacks.added(self.collectionName, id, changeCollector);\n else\n self.callbacks.changed(self.collectionName, id, changeCollector);\n },\n\n changed: function (subscriptionHandle, id, changed) {\n var self = this;\n var changedResult = {};\n var docView = self.documents.get(id);\n if (!docView)\n throw new Error(\"Could not find element with id \" + id + \" to change\");\n _.each(changed, function (value, key) {\n if (value === undefined)\n docView.clearField(subscriptionHandle, key, changedResult);\n else\n docView.changeField(subscriptionHandle, key, value, changedResult);\n });\n self.callbacks.changed(self.collectionName, id, changedResult);\n },\n\n removed: function (subscriptionHandle, id) {\n var self = this;\n var docView = self.documents.get(id);\n if (!docView) {\n var err = new Error(\"Removed nonexistent document \" + id);\n throw err;\n }\n docView.existsIn.delete(subscriptionHandle);\n if (docView.existsIn.size === 0) {\n // it is gone from everyone\n self.callbacks.removed(self.collectionName, id);\n self.documents.delete(id);\n } else {\n var changed = {};\n // remove this subscription from every precedence list\n // and record the changes\n docView.dataByKey.forEach(function (precedenceList, key) {\n docView.clearField(subscriptionHandle, key, changed);\n });\n\n self.callbacks.changed(self.collectionName, id, changed);\n }\n }\n});\n\n/******************************************************************************/\n/* Session */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n var self = this;\n self.id = Random.id();\n\n self.server = server;\n self.version = version;\n\n self.initialized = false;\n self.socket = socket;\n\n // set to null when the session is destroyed. multiple places below\n // use this to determine if the session is alive or not.\n self.inQueue = new Meteor._DoubleEndedQueue();\n\n self.blocked = false;\n self.workerRunning = false;\n\n // Sub objects for active subscriptions\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n self.userId = null;\n\n self.collectionViews = new Map();\n\n // Set this to false to not send messages when collectionViews are\n // modified. This is done when rerunning subs in _setUserId and those messages\n // are calculated via a diff instead.\n self._isSending = true;\n\n // If this is true, don't start a newly-created universal publisher on this\n // session. The session will take care of starting it when appropriate.\n self._dontStartNewUniversalSubs = false;\n\n // when we are rerunning subscriptions, any ready messages\n // we want to buffer up for when we are done rerunning subscriptions\n self._pendingReady = [];\n\n // List of callbacks to call when this connection is closed.\n self._closeCallbacks = [];\n\n\n // XXX HACK: If a sockjs connection, save off the URL. This is\n // temporary and will go away in the near future.\n self._socketUrl = socket.url;\n\n // Allow tests to disable responding to pings.\n self._respondToPings = options.respondToPings;\n\n // This object is the public interface to the session. In the public\n // API, it is called the `connection` object. Internally we call it\n // a `connectionHandle` to avoid ambiguity.\n self.connectionHandle = {\n id: self.id,\n close: function () {\n self.close();\n },\n onClose: function (fn) {\n var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n if (self.inQueue) {\n self._closeCallbacks.push(cb);\n } else {\n // if we're already closed, call the callback.\n Meteor.defer(cb);\n }\n },\n clientAddress: self._clientAddress(),\n httpHeaders: self.socket.headers\n };\n\n self.send({ msg: 'connected', session: self.id });\n\n // On initial connect, spin up all the universal publishers.\n Fiber(function () {\n self.startUniversalSubs();\n }).run();\n\n if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n // We no longer need the low level timeout because we have heartbeating.\n socket.setWebsocketTimeout(0);\n\n self.heartbeat = new DDPCommon.Heartbeat({\n heartbeatInterval: options.heartbeatInterval,\n heartbeatTimeout: options.heartbeatTimeout,\n onTimeout: function () {\n self.close();\n },\n sendPing: function () {\n self.send({msg: 'ping'});\n }\n });\n self.heartbeat.start();\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n sendReady: function (subscriptionIds) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"ready\", subs: subscriptionIds});\n else {\n _.each(subscriptionIds, function (subscriptionId) {\n self._pendingReady.push(subscriptionId);\n });\n }\n },\n\n sendAdded: function (collectionName, id, fields) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n },\n\n sendChanged: function (collectionName, id, fields) {\n var self = this;\n if (_.isEmpty(fields))\n return;\n\n if (self._isSending) {\n self.send({\n msg: \"changed\",\n collection: collectionName,\n id: id,\n fields: fields\n });\n }\n },\n\n sendRemoved: function (collectionName, id) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"removed\", collection: collectionName, id: id});\n },\n\n getSendCallbacks: function () {\n var self = this;\n return {\n added: _.bind(self.sendAdded, self),\n changed: _.bind(self.sendChanged, self),\n removed: _.bind(self.sendRemoved, self)\n };\n },\n\n getCollectionView: function (collectionName) {\n var self = this;\n var ret = self.collectionViews.get(collectionName);\n if (!ret) {\n ret = new SessionCollectionView(collectionName,\n self.getSendCallbacks());\n self.collectionViews.set(collectionName, ret);\n }\n return ret;\n },\n\n added: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.added(subscriptionHandle, id, fields);\n },\n\n removed: function (subscriptionHandle, collectionName, id) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.removed(subscriptionHandle, id);\n if (view.isEmpty()) {\n self.collectionViews.delete(collectionName);\n }\n },\n\n changed: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.changed(subscriptionHandle, id, fields);\n },\n\n startUniversalSubs: function () {\n var self = this;\n // Make a shallow copy of the set of universal handlers and start them. If\n // additional universal publishers start while we're running them (due to\n // yielding), they will run separately as part of Server.publish.\n var handlers = _.clone(self.server.universal_publish_handlers);\n _.each(handlers, function (handler) {\n self._startSubscription(handler);\n });\n },\n\n // Destroy this session and unregister it at the server.\n close: function () {\n var self = this;\n\n // Destroy this session, even if it's not registered at the\n // server. Stop all processing and tear everything down. If a socket\n // was attached, close it.\n\n // Already destroyed.\n if (! self.inQueue)\n return;\n\n // Drop the merge box data immediately.\n self.inQueue = null;\n self.collectionViews = new Map();\n\n if (self.heartbeat) {\n self.heartbeat.stop();\n self.heartbeat = null;\n }\n\n if (self.socket) {\n self.socket.close();\n self.socket._meteorSession = null;\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", -1);\n\n Meteor.defer(function () {\n // stop callbacks can yield, so we defer this on close.\n // sub._isDeactivated() detects that we set inQueue to null and\n // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n self._deactivateAllSubscriptions();\n\n // Defer calling the close callbacks, so that the caller closing\n // the session isn't waiting for all the callbacks to complete.\n _.each(self._closeCallbacks, function (callback) {\n callback();\n });\n });\n\n // Unregister the session.\n self.server._removeSession(self);\n },\n\n // Send a message (doing nothing if no socket is connected right now.)\n // It should be a JSON object (it will be stringified.)\n send: function (msg) {\n var self = this;\n if (self.socket) {\n if (Meteor._printSentDDP)\n Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n self.socket.send(DDPCommon.stringifyDDP(msg));\n }\n },\n\n // Send a connection error.\n sendError: function (reason, offendingMessage) {\n var self = this;\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n self.send(msg);\n },\n\n // Process 'msg' as an incoming message. (But as a guard against\n // race conditions during reconnection, ignore the message if\n // 'socket' is not the currently connected socket.)\n //\n // We run the messages from the client one at a time, in the order\n // given by the client. The message handler is passed an idempotent\n // function 'unblock' which it may call to allow other messages to\n // begin running in parallel in another fiber (for example, a method\n // that wants to yield.) Otherwise, it is automatically unblocked\n // when it returns.\n //\n // Actually, we don't have to 'totally order' the messages in this\n // way, but it's the easiest thing that's correct. (unsub needs to\n // be ordered against sub, methods need to be ordered against each\n // other.)\n processMessage: function (msg_in) {\n var self = this;\n if (!self.inQueue) // we have been destroyed.\n return;\n\n // Respond to ping and pong messages immediately without queuing.\n // If the negotiated DDP version is \"pre1\" which didn't support\n // pings, preserve the \"pre1\" behavior of responding with a \"bad\n // request\" for the unknown messages.\n //\n // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n // needs a Fiber. We could actually use regular setTimeout and avoid\n // these new fibers, but it is easier to just make everything use\n // Meteor.setTimeout and not think too hard.\n //\n // Any message counts as receiving a pong, as it demonstrates that\n // the client is still alive.\n if (self.heartbeat) {\n Fiber(function () {\n self.heartbeat.messageReceived();\n }).run();\n }\n\n if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n if (self._respondToPings)\n self.send({msg: \"pong\", id: msg_in.id});\n return;\n }\n if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n // Since everything is a pong, nothing to do\n return;\n }\n\n self.inQueue.push(msg_in);\n if (self.workerRunning)\n return;\n self.workerRunning = true;\n\n var processNext = function () {\n var msg = self.inQueue && self.inQueue.shift();\n if (!msg) {\n self.workerRunning = false;\n return;\n }\n\n Fiber(function () {\n var blocked = true;\n\n var unblock = function () {\n if (!blocked)\n return; // idempotent\n blocked = false;\n processNext();\n };\n\n self.server.onMessageHook.each(function (callback) {\n callback(msg, self);\n return true;\n });\n\n if (_.has(self.protocol_handlers, msg.msg))\n self.protocol_handlers[msg.msg].call(self, msg, unblock);\n else\n self.sendError('Bad request', msg);\n unblock(); // in case the handler didn't already do it\n }).run();\n };\n\n processNext();\n },\n\n protocol_handlers: {\n sub: function (msg) {\n var self = this;\n\n // reject malformed messages\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.name) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array))) {\n self.sendError(\"Malformed subscription\", msg);\n return;\n }\n\n if (!self.server.publish_handlers[msg.name]) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n return;\n }\n\n if (self._namedSubs.has(msg.id))\n // subs are idempotent, or rather, they are ignored if a sub\n // with that id already exists. this is important during\n // reconnect.\n return;\n\n // XXX It'd be much better if we had generic hooks where any package can\n // hook into subscription handling, but in the mean while we special case\n // ddp-rate-limiter package. This is also done for weak requirements to\n // add the ddp-rate-limiter package in case we don't have Accounts. A\n // user trying to use the ddp-rate-limiter must explicitly require it.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"subscription\",\n name: msg.name,\n connectionId: self.id\n };\n\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n if (!rateLimitResult.allowed) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(\n 'too-many-requests',\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset})\n });\n return;\n }\n }\n\n var handler = self.server.publish_handlers[msg.name];\n\n self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n },\n\n unsub: function (msg) {\n var self = this;\n\n self._stopSubscription(msg.id);\n },\n\n method: function (msg, unblock) {\n var self = this;\n\n // reject malformed messages\n // For now, we silently ignore unknown attributes,\n // for forwards compatibility.\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.method) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array)) ||\n (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n self.sendError(\"Malformed method invocation\", msg);\n return;\n }\n\n var randomSeed = msg.randomSeed || null;\n\n // set up to mark the method as satisfied once all observers\n // (and subscriptions) have reacted to any writes that were\n // done.\n var fence = new DDPServer._WriteFence;\n fence.onAllCommitted(function () {\n // Retire the fence so that future writes are allowed.\n // This means that callbacks like timers are free to use\n // the fence, and if they fire before it's armed (for\n // example, because the method waits for them) their\n // writes will be included in the fence.\n fence.retire();\n self.send({\n msg: 'updated', methods: [msg.id]});\n });\n\n // find the handler\n var handler = self.server.method_handlers[msg.method];\n if (!handler) {\n self.send({\n msg: 'result', id: msg.id,\n error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n fence.arm();\n return;\n }\n\n var setUserId = function(userId) {\n self._setUserId(userId);\n };\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId: self.userId,\n setUserId: setUserId,\n unblock: unblock,\n connection: self.connectionHandle,\n randomSeed: randomSeed\n });\n\n const promise = new Promise((resolve, reject) => {\n // XXX It'd be better if we could hook into method handlers better but\n // for now, we need to check if the ddp-rate-limiter exists since we\n // have a weak requirement for the ddp-rate-limiter package to be added\n // to our application.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"method\",\n name: msg.method,\n connectionId: self.id\n };\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n if (!rateLimitResult.allowed) {\n reject(new Meteor.Error(\n \"too-many-requests\",\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset}\n ));\n return;\n }\n }\n\n resolve(DDPServer._CurrentWriteFence.withValue(\n fence,\n () => DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, msg.params,\n \"call to '\" + msg.method + \"'\"\n )\n )\n ));\n });\n\n function finish() {\n fence.arm();\n unblock();\n }\n\n const payload = {\n msg: \"result\",\n id: msg.id\n };\n\n promise.then((result) => {\n finish();\n if (result !== undefined) {\n payload.result = result;\n }\n self.send(payload);\n }, (exception) => {\n finish();\n payload.error = wrapInternalException(\n exception,\n `while invoking method '${msg.method}'`\n );\n self.send(payload);\n });\n }\n },\n\n _eachSub: function (f) {\n var self = this;\n self._namedSubs.forEach(f);\n self._universalSubs.forEach(f);\n },\n\n _diffCollectionViews: function (beforeCVs) {\n var self = this;\n DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n both: function (collectionName, leftValue, rightValue) {\n rightValue.diff(leftValue);\n },\n rightOnly: function (collectionName, rightValue) {\n rightValue.documents.forEach(function (docView, id) {\n self.sendAdded(collectionName, id, docView.getFields());\n });\n },\n leftOnly: function (collectionName, leftValue) {\n leftValue.documents.forEach(function (doc, id) {\n self.sendRemoved(collectionName, id);\n });\n }\n });\n },\n\n // Sets the current user id in all appropriate contexts and reruns\n // all subscriptions\n _setUserId: function(userId) {\n var self = this;\n\n if (userId !== null && typeof userId !== \"string\")\n throw new Error(\"setUserId must be called on string or null, not \" +\n typeof userId);\n\n // Prevent newly-created universal subscriptions from being added to our\n // session; they will be found below when we call startUniversalSubs.\n //\n // (We don't have to worry about named subscriptions, because we only add\n // them when we process a 'sub' message. We are currently processing a\n // 'method' message, and the method did not unblock, because it is illegal\n // to call setUserId after unblock. Thus we cannot be concurrently adding a\n // new named subscription.)\n self._dontStartNewUniversalSubs = true;\n\n // Prevent current subs from updating our collectionViews and call their\n // stop callbacks. This may yield.\n self._eachSub(function (sub) {\n sub._deactivate();\n });\n\n // All subs should now be deactivated. Stop sending messages to the client,\n // save the state of the published collections, reset to an empty view, and\n // update the userId.\n self._isSending = false;\n var beforeCVs = self.collectionViews;\n self.collectionViews = new Map();\n self.userId = userId;\n\n // _setUserId is normally called from a Meteor method with\n // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n // expected to be set inside a publish function, so we temporary unset it.\n // Inside a publish function DDP._CurrentPublicationInvocation is set.\n DDP._CurrentMethodInvocation.withValue(undefined, function () {\n // Save the old named subs, and reset to having no subscriptions.\n var oldNamedSubs = self._namedSubs;\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n oldNamedSubs.forEach(function (sub, subscriptionId) {\n var newSub = sub._recreate();\n self._namedSubs.set(subscriptionId, newSub);\n // nb: if the handler throws or calls this.error(), it will in fact\n // immediately send its 'nosub'. This is OK, though.\n newSub._runHandler();\n });\n\n // Allow newly-created universal subs to be started on our connection in\n // parallel with the ones we're spinning up here, and spin up universal\n // subs.\n self._dontStartNewUniversalSubs = false;\n self.startUniversalSubs();\n });\n\n // Start sending messages again, beginning with the diff from the previous\n // state of the world to the current state. No yields are allowed during\n // this diff, so that other changes cannot interleave.\n Meteor._noYieldsAllowed(function () {\n self._isSending = true;\n self._diffCollectionViews(beforeCVs);\n if (!_.isEmpty(self._pendingReady)) {\n self.sendReady(self._pendingReady);\n self._pendingReady = [];\n }\n });\n },\n\n _startSubscription: function (handler, subId, params, name) {\n var self = this;\n\n var sub = new Subscription(\n self, handler, subId, params, name);\n if (subId)\n self._namedSubs.set(subId, sub);\n else\n self._universalSubs.push(sub);\n\n sub._runHandler();\n },\n\n // tear down specified subscription\n _stopSubscription: function (subId, error) {\n var self = this;\n\n var subName = null;\n if (subId) {\n var maybeSub = self._namedSubs.get(subId);\n if (maybeSub) {\n subName = maybeSub._name;\n maybeSub._removeAllDocuments();\n maybeSub._deactivate();\n self._namedSubs.delete(subId);\n }\n }\n\n var response = {msg: 'nosub', id: subId};\n\n if (error) {\n response.error = wrapInternalException(\n error,\n subName ? (\"from sub \" + subName + \" id \" + subId)\n : (\"from sub id \" + subId));\n }\n\n self.send(response);\n },\n\n // tear down all subscriptions. Note that this does NOT send removed or nosub\n // messages, since we assume the client is gone.\n _deactivateAllSubscriptions: function () {\n var self = this;\n\n self._namedSubs.forEach(function (sub, id) {\n sub._deactivate();\n });\n self._namedSubs = new Map();\n\n self._universalSubs.forEach(function (sub) {\n sub._deactivate();\n });\n self._universalSubs = [];\n },\n\n // Determine the remote client's IP address, based on the\n // HTTP_FORWARDED_COUNT environment variable representing how many\n // proxies the server is behind.\n _clientAddress: function () {\n var self = this;\n\n // For the reported client address for a connection to be correct,\n // the developer must set the HTTP_FORWARDED_COUNT environment\n // variable to an integer representing the number of hops they\n // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n // server is behind one proxy.\n //\n // This could be computed once at startup instead of every time.\n var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n if (httpForwardedCount === 0)\n return self.socket.remoteAddress;\n\n var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n if (! _.isString(forwardedFor))\n return null;\n forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n // Typically the first value in the `x-forwarded-for` header is\n // the original IP address of the client connecting to the first\n // proxy. However, the end user can easily spoof the header, in\n // which case the first value(s) will be the fake IP address from\n // the user pretending to be a proxy reporting the original IP\n // address value. By counting HTTP_FORWARDED_COUNT back from the\n // end of the list, we ensure that we get the IP address being\n // reported by *our* first proxy.\n\n if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n return null;\n\n return forwardedFor[forwardedFor.length - httpForwardedCount];\n }\n});\n\n/******************************************************************************/\n/* Subscription */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n session, handler, subscriptionId, params, name) {\n var self = this;\n self._session = session; // type is Session\n\n /**\n * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n * @locus Server\n * @name connection\n * @memberOf Subscription\n * @instance\n */\n self.connection = session.connectionHandle; // public API object\n\n self._handler = handler;\n\n // my subscription ID (generated by client, undefined for universal subs).\n self._subscriptionId = subscriptionId;\n // undefined for universal subs\n self._name = name;\n\n self._params = params || [];\n\n // Only named subscriptions have IDs, but we need some sort of string\n // internally to keep track of all subscriptions inside\n // SessionDocumentViews. We use this subscriptionHandle for that.\n if (self._subscriptionId) {\n self._subscriptionHandle = 'N' + self._subscriptionId;\n } else {\n self._subscriptionHandle = 'U' + Random.id();\n }\n\n // has _deactivate been called?\n self._deactivated = false;\n\n // stop callbacks to g/c this sub. called w/ zero arguments.\n self._stopCallbacks = [];\n\n // the set of (collection, documentid) that this subscription has\n // an opinion about\n self._documents = new Map();\n\n // remember if we are ready.\n self._ready = false;\n\n // Part of the public API: the user of this sub.\n\n /**\n * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n * @locus Server\n * @memberOf Subscription\n * @name userId\n * @instance\n */\n self.userId = session.userId;\n\n // For now, the id filter is going to default to\n // the to/from DDP methods on MongoID, to\n // specifically deal with mongo/minimongo ObjectIds.\n\n // Later, you will be able to make this be \"raw\"\n // if you want to publish a collection that you know\n // just has strings for keys and no funny business, to\n // a ddp consumer that isn't minimongo\n\n self._idFilter = {\n idStringify: MongoID.idStringify,\n idParse: MongoID.idParse\n };\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n _runHandler: function () {\n // XXX should we unblock() here? Either before running the publish\n // function, or before running _publishCursor.\n //\n // Right now, each publish function blocks all future publishes and\n // methods waiting on data from Mongo (or whatever else the function\n // blocks on). This probably slows page load in common cases.\n\n var self = this;\n try {\n var res = DDP._CurrentPublicationInvocation.withValue(\n self,\n () => maybeAuditArgumentChecks(\n self._handler, self, EJSON.clone(self._params),\n // It's OK that this would look weird for universal subscriptions,\n // because they have no arguments so there can never be an\n // audit-argument-checks failure.\n \"publisher '\" + self._name + \"'\"\n )\n );\n } catch (e) {\n self.error(e);\n return;\n }\n\n // Did the handler call this.error or this.stop?\n if (self._isDeactivated())\n return;\n\n self._publishHandlerResult(res);\n },\n\n _publishHandlerResult: function (res) {\n // SPECIAL CASE: Instead of writing their own callbacks that invoke\n // this.added/changed/ready/etc, the user can just return a collection\n // cursor or array of cursors from the publish function; we call their\n // _publishCursor method which starts observing the cursor and publishes the\n // results. Note that _publishCursor does NOT call ready().\n //\n // XXX This uses an undocumented interface which only the Mongo cursor\n // interface publishes. Should we make this interface public and encourage\n // users to implement it themselves? Arguably, it's unnecessary; users can\n // already write their own functions like\n // var publishMyReactiveThingy = function (name, handler) {\n // Meteor.publish(name, function () {\n // var reactiveThingy = handler();\n // reactiveThingy.publishMe();\n // });\n // };\n\n var self = this;\n var isCursor = function (c) {\n return c && c._publishCursor;\n };\n if (isCursor(res)) {\n try {\n res._publishCursor(self);\n } catch (e) {\n self.error(e);\n return;\n }\n // _publishCursor only returns after the initial added callbacks have run.\n // mark subscription as ready.\n self.ready();\n } else if (_.isArray(res)) {\n // check all the elements are cursors\n if (! _.all(res, isCursor)) {\n self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n return;\n }\n // find duplicate collection names\n // XXX we should support overlapping cursors, but that would require the\n // merge box to allow overlap within a subscription\n var collectionNames = {};\n for (var i = 0; i < res.length; ++i) {\n var collectionName = res[i]._getCollectionName();\n if (_.has(collectionNames, collectionName)) {\n self.error(new Error(\n \"Publish function returned multiple cursors for collection \" +\n collectionName));\n return;\n }\n collectionNames[collectionName] = true;\n };\n\n try {\n _.each(res, function (cur) {\n cur._publishCursor(self);\n });\n } catch (e) {\n self.error(e);\n return;\n }\n self.ready();\n } else if (res) {\n // truthy values other than cursors or arrays are probably a\n // user mistake (possible returning a Mongo document via, say,\n // `coll.findOne()`).\n self.error(new Error(\"Publish function can only return a Cursor or \"\n + \"an array of Cursors\"));\n }\n },\n\n // This calls all stop callbacks and prevents the handler from updating any\n // SessionCollectionViews further. It's used when the user unsubscribes or\n // disconnects, as well as during setUserId re-runs. It does *NOT* send\n // removed messages for the published objects; if that is necessary, call\n // _removeAllDocuments first.\n _deactivate: function() {\n var self = this;\n if (self._deactivated)\n return;\n self._deactivated = true;\n self._callStopCallbacks();\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", -1);\n },\n\n _callStopCallbacks: function () {\n var self = this;\n // tell listeners, so they can clean up\n var callbacks = self._stopCallbacks;\n self._stopCallbacks = [];\n _.each(callbacks, function (callback) {\n callback();\n });\n },\n\n // Send remove messages for every document.\n _removeAllDocuments: function () {\n var self = this;\n Meteor._noYieldsAllowed(function () {\n self._documents.forEach(function (collectionDocs, collectionName) {\n collectionDocs.forEach(function (strId) {\n self.removed(collectionName, self._idFilter.idParse(strId));\n });\n });\n });\n },\n\n // Returns a new Subscription for the same session with the same\n // initial creation parameters. This isn't a clone: it doesn't have\n // the same _documents cache, stopped state or callbacks; may have a\n // different _subscriptionHandle, and gets its userId from the\n // session, not from this object.\n _recreate: function () {\n var self = this;\n return new Subscription(\n self._session, self._handler, self._subscriptionId, self._params,\n self._name);\n },\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n * @locus Server\n * @param {Error} error The error to pass to the client.\n * @instance\n * @memberOf Subscription\n */\n error: function (error) {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId, error);\n },\n\n // Note that while our DDP client will notice that you've called stop() on the\n // server (and clean up its _subscriptions table) we don't actually provide a\n // mechanism for an app to notice this (the subscribe onError callback only\n // triggers if there is an error).\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error.\n * @locus Server\n * @instance\n * @memberOf Subscription\n */\n stop: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId);\n },\n\n /**\n * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {Function} func The callback function\n */\n onStop: function (callback) {\n var self = this;\n callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n if (self._isDeactivated())\n callback();\n else\n self._stopCallbacks.push(callback);\n },\n\n // This returns true if the sub has been deactivated, *OR* if the session was\n // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n // happened yet.\n _isDeactivated: function () {\n var self = this;\n return self._deactivated || self._session.inQueue === null;\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the new document.\n * @param {String} id The new document's ID.\n * @param {Object} fields The fields in the new document. If `_id` is present it is ignored.\n */\n added: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n let ids = self._documents.get(collectionName);\n if (ids == null) {\n ids = new Set();\n self._documents.set(collectionName, ids);\n }\n ids.add(id);\n self._session.added(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the changed document.\n * @param {String} id The changed document's ID.\n * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored.\n */\n changed: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that the document has been removed from.\n * @param {String} id The ID of the document that has been removed.\n */\n removed: function (collectionName, id) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n // We don't bother to delete sets of things in a collection if the\n // collection is empty. It could break _removeAllDocuments.\n self._documents.get(collectionName).delete(id);\n self._session.removed(self._subscriptionHandle, collectionName, id);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any.\n * @locus Server\n * @memberOf Subscription\n * @instance\n */\n ready: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n if (!self._subscriptionId)\n return; // unnecessary but ignored for universal sub\n if (!self._ready) {\n self._session.sendReady([self._subscriptionId]);\n self._ready = true;\n }\n }\n});\n\n/******************************************************************************/\n/* Server */\n/******************************************************************************/\n\nServer = function (options) {\n var self = this;\n\n // The default heartbeat interval is 30 seconds on the server and 35\n // seconds on the client. Since the client doesn't need to send a\n // ping as long as it is receiving pings, this means that pings\n // normally go from the server to the client.\n //\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n self.options = _.defaults(options || {}, {\n heartbeatInterval: 15000,\n heartbeatTimeout: 15000,\n // For testing, allow responding to pings to be disabled.\n respondToPings: true\n });\n\n // Map of callbacks to call when a new connection comes in to the\n // server and completes DDP version negotiation. Use an object instead\n // of an array so we can safely remove one from the list while\n // iterating over it.\n self.onConnectionHook = new Hook({\n debugPrintExceptions: \"onConnection callback\"\n });\n\n // Map of callbacks to call when a new message comes in.\n self.onMessageHook = new Hook({\n debugPrintExceptions: \"onMessage callback\"\n });\n\n self.publish_handlers = {};\n self.universal_publish_handlers = [];\n\n self.method_handlers = {};\n\n self.sessions = new Map(); // map from id to session\n\n self.stream_server = new StreamServer;\n\n self.stream_server.register(function (socket) {\n // socket implements the SockJSConnection interface\n socket._meteorSession = null;\n\n var sendError = function (reason, offendingMessage) {\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n socket.send(DDPCommon.stringifyDDP(msg));\n };\n\n socket.on('data', function (raw_msg) {\n if (Meteor._printReceivedDDP) {\n Meteor._debug(\"Received DDP\", raw_msg);\n }\n try {\n try {\n var msg = DDPCommon.parseDDP(raw_msg);\n } catch (err) {\n sendError('Parse error');\n return;\n }\n if (msg === null || !msg.msg) {\n sendError('Bad request', msg);\n return;\n }\n\n if (msg.msg === 'connect') {\n if (socket._meteorSession) {\n sendError(\"Already connected\", msg);\n return;\n }\n Fiber(function () {\n self._handleConnect(socket, msg);\n }).run();\n return;\n }\n\n if (!socket._meteorSession) {\n sendError('Must connect first', msg);\n return;\n }\n socket._meteorSession.processMessage(msg);\n } catch (e) {\n // XXX print stack nicely\n Meteor._debug(\"Internal exception while processing message\", msg, e);\n }\n });\n\n socket.on('close', function () {\n if (socket._meteorSession) {\n Fiber(function () {\n socket._meteorSession.close();\n }).run();\n }\n });\n });\n};\n\n_.extend(Server.prototype, {\n\n /**\n * @summary Register a callback to be called when a new DDP connection is made to the server.\n * @locus Server\n * @param {function} callback The function to call when a new DDP connection is established.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onConnection: function (fn) {\n var self = this;\n return self.onConnectionHook.register(fn);\n },\n\n /**\n * @summary Register a callback to be called when a new DDP message is received.\n * @locus Server\n * @param {function} callback The function to call when a new DDP message is received.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onMessage: function (fn) {\n var self = this;\n return self.onMessageHook.register(fn);\n },\n\n _handleConnect: function (socket, msg) {\n var self = this;\n\n // The connect message must specify a version and an array of supported\n // versions, and it must claim to support what it is proposing.\n if (!(typeof (msg.version) === 'string' &&\n _.isArray(msg.support) &&\n _.all(msg.support, _.isString) &&\n _.contains(msg.support, msg.version))) {\n socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n socket.close();\n return;\n }\n\n // In the future, handle session resumption: something like:\n // socket._meteorSession = self.sessions[msg.session]\n var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n if (msg.version !== version) {\n // The best version to use (according to the client's stated preferences)\n // is not the one the client is trying to use. Inform them about the best\n // version to use.\n socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n socket.close();\n return;\n }\n\n // Yay, version matches! Create a new session.\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n socket._meteorSession = new Session(self, version, socket, self.options);\n self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n self.onConnectionHook.each(function (callback) {\n if (socket._meteorSession)\n callback(socket._meteorSession.connectionHandle);\n return true;\n });\n },\n /**\n * Register a publish handler function.\n *\n * @param name {String} identifier for query\n * @param handler {Function} publish handler\n * @param options {Object}\n *\n * Server will call handler function on each new subscription,\n * either when receiving DDP sub message for a named subscription, or on\n * DDP connect for a universal subscription.\n *\n * If name is null, this will be a subscription that is\n * automatically established and permanently on for all connected\n * client, instead of a subscription that can be turned on and off\n * with subscribe().\n *\n * options to contain:\n * - (mostly internal) is_auto: true if generated automatically\n * from an autopublish hook. this is for cosmetic purposes only\n * (it lets us determine whether to print a warning suggesting\n * that you turn off autopublish.)\n */\n\n /**\n * @summary Publish a record set.\n * @memberOf Meteor\n * @importFromPackage meteor\n * @locus Server\n * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments.\n */\n publish: function (name, handler, options) {\n var self = this;\n\n if (! _.isObject(name)) {\n options = options || {};\n\n if (name && name in self.publish_handlers) {\n Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n return;\n }\n\n if (Package.autopublish && !options.is_auto) {\n // They have autopublish on, yet they're trying to manually\n // picking stuff to publish. They probably should turn off\n // autopublish. (This check isn't perfect -- if you create a\n // publish before you turn on autopublish, it won't catch\n // it. But this will definitely handle the simple case where\n // you've added the autopublish package to your app, and are\n // calling publish from your app code.)\n if (!self.warned_about_autopublish) {\n self.warned_about_autopublish = true;\n Meteor._debug(\n \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n \"** will still be sent to all clients.\\n\" +\n \"**\\n\" +\n \"** Turn off autopublish by removing the autopublish package:\\n\" +\n \"**\\n\" +\n \"** $ meteor remove autopublish\\n\" +\n \"**\\n\" +\n \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n \"** for each collection that you want clients to see.\\n\");\n }\n }\n\n if (name)\n self.publish_handlers[name] = handler;\n else {\n self.universal_publish_handlers.push(handler);\n // Spin up the new publisher on any existing session too. Run each\n // session's subscription in a new Fiber, so that there's no change for\n // self.sessions to change while we're running this loop.\n self.sessions.forEach(function (session) {\n if (!session._dontStartNewUniversalSubs) {\n Fiber(function() {\n session._startSubscription(handler);\n }).run();\n }\n });\n }\n }\n else{\n _.each(name, function(value, key) {\n self.publish(key, value, {});\n });\n }\n },\n\n _removeSession: function (session) {\n var self = this;\n self.sessions.delete(session.id);\n },\n\n /**\n * @summary Defines functions that can be invoked over the network by clients.\n * @locus Anywhere\n * @param {Object} methods Dictionary whose keys are method names and values are functions.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n methods: function (methods) {\n var self = this;\n _.each(methods, function (func, name) {\n if (typeof func !== 'function')\n throw new Error(\"Method '\" + name + \"' must be a function\");\n if (self.method_handlers[name])\n throw new Error(\"A method named '\" + name + \"' is already defined\");\n self.method_handlers[name] = func;\n });\n },\n\n call: function (name, ...args) {\n if (args.length && typeof args[args.length - 1] === \"function\") {\n // If it's a function, the last argument is the result callback, not\n // a parameter to the remote method.\n var callback = args.pop();\n }\n\n return this.apply(name, args, callback);\n },\n\n // A version of the call method that always returns a Promise.\n callAsync: function (name, ...args) {\n return this.applyAsync(name, args);\n },\n\n apply: function (name, args, options, callback) {\n // We were passed 3 arguments. They may be either (name, args, options)\n // or (name, args, callback)\n if (! callback && typeof options === 'function') {\n callback = options;\n options = {};\n } else {\n options = options || {};\n }\n\n const promise = this.applyAsync(name, args, options);\n\n // Return the result in whichever way the caller asked for it. Note that we\n // do NOT block on the write fence in an analogous way to how the client\n // blocks on the relevant data being visible, so you are NOT guaranteed that\n // cursor observe callbacks have fired when your callback is invoked. (We\n // can change this if there's a real use case.)\n if (callback) {\n promise.then(\n result => callback(undefined, result),\n exception => callback(exception)\n );\n } else {\n return promise.await();\n }\n },\n\n // @param options {Optional Object}\n applyAsync: function (name, args, options) {\n // Run the handler\n var handler = this.method_handlers[name];\n if (! handler) {\n return Promise.reject(\n new Meteor.Error(404, `Method '${name}' not found`)\n );\n }\n\n // If this is a method call from within another method or publish function,\n // get the user state from the outer method or publish function, otherwise\n // don't allow setUserId to be called\n var userId = null;\n var setUserId = function() {\n throw new Error(\"Can't call setUserId on a server initiated method call\");\n };\n var connection = null;\n var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n var randomSeed = null;\n if (currentMethodInvocation) {\n userId = currentMethodInvocation.userId;\n setUserId = function(userId) {\n currentMethodInvocation.setUserId(userId);\n };\n connection = currentMethodInvocation.connection;\n randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n } else if (currentPublicationInvocation) {\n userId = currentPublicationInvocation.userId;\n setUserId = function(userId) {\n currentPublicationInvocation._session._setUserId(userId);\n };\n connection = currentPublicationInvocation.connection;\n }\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId,\n setUserId,\n connection,\n randomSeed\n });\n\n return new Promise(resolve => resolve(\n DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, EJSON.clone(args),\n \"internal call to '\" + name + \"'\"\n )\n )\n )).then(EJSON.clone);\n },\n\n _urlForSession: function (sessionId) {\n var self = this;\n var session = self.sessions.get(sessionId);\n if (session)\n return session._socketUrl;\n else\n return null;\n }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n serverSupportedVersions) {\n var correctVersion = _.find(clientSupportedVersions, function (version) {\n return _.contains(serverSupportedVersions, version);\n });\n if (!correctVersion) {\n correctVersion = serverSupportedVersions[0];\n }\n return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n if (!exception) return exception;\n\n // To allow packages to throw errors intended for the client but not have to\n // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n // error before it is thrown.\n if (exception.isClientSafe) {\n if (!(exception instanceof Meteor.Error)) {\n const originalMessage = exception.message;\n exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n exception.message = originalMessage;\n }\n return exception;\n }\n\n // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n // the server log.\n if (!exception._expectedByTest) {\n Meteor._debug(\"Exception \" + context, exception.stack);\n if (exception.sanitizedError) {\n Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n Meteor._debug();\n }\n }\n\n // Did the error contain more details that could have been useful if caught in\n // server code (or if thrown from non-client-originated code), but also\n // provided a \"sanitized\" version with more context than 500 Internal server\n // error? Use that.\n if (exception.sanitizedError) {\n if (exception.sanitizedError.isClientSafe)\n return exception.sanitizedError;\n Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n \"does not have isClientSafe property set; ignoring\");\n }\n\n return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n args = args || [];\n if (Package['audit-argument-checks']) {\n return Match._failIfArgumentsAreNotAllChecked(\n f, context, args, description);\n }\n return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n var self = this;\n\n self.armed = false;\n self.fired = false;\n self.retired = false;\n self.outstanding_writes = 0;\n self.before_fire_callbacks = [];\n self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n // Start tracking a write, and return an object to represent it. The\n // object has a single method, committed(). This method should be\n // called when the write is fully committed and propagated. You can\n // continue to add writes to the WriteFence up until it is triggered\n // (calls its callbacks because all writes have committed.)\n beginWrite: function () {\n var self = this;\n\n if (self.retired)\n return { committed: function () {} };\n\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to add writes\");\n\n self.outstanding_writes++;\n var committed = false;\n return {\n committed: function () {\n if (committed)\n throw new Error(\"committed called twice on the same write\");\n committed = true;\n self.outstanding_writes--;\n self._maybeFire();\n }\n };\n },\n\n // Arm the fence. Once the fence is armed, and there are no more\n // uncommitted writes, it will activate.\n arm: function () {\n var self = this;\n if (self === DDPServer._CurrentWriteFence.get())\n throw Error(\"Can't arm the current fence\");\n self.armed = true;\n self._maybeFire();\n },\n\n // Register a function to be called once before firing the fence.\n // Callback function can add new writes to the fence, in which case\n // it won't fire until those writes are done as well.\n onBeforeFire: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.before_fire_callbacks.push(func);\n },\n\n // Register a function to be called when the fence fires.\n onAllCommitted: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.completion_callbacks.push(func);\n },\n\n // Convenience function. Arms the fence, then blocks until it fires.\n armAndWait: function () {\n var self = this;\n var future = new Future;\n self.onAllCommitted(function () {\n future['return']();\n });\n self.arm();\n future.wait();\n },\n\n _maybeFire: function () {\n var self = this;\n if (self.fired)\n throw new Error(\"write fence already activated?\");\n if (self.armed && !self.outstanding_writes) {\n function invokeCallback (func) {\n try {\n func(self);\n } catch (err) {\n Meteor._debug(\"exception in write fence callback\", err);\n }\n }\n\n self.outstanding_writes++;\n while (self.before_fire_callbacks.length > 0) {\n var callbacks = self.before_fire_callbacks;\n self.before_fire_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n self.outstanding_writes--;\n\n if (!self.outstanding_writes) {\n self.fired = true;\n var callbacks = self.completion_callbacks;\n self.completion_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n }\n },\n\n // Deactivate this fence so that adding more writes has no effect.\n // The fence must have already fired.\n retire: function () {\n var self = this;\n if (! self.fired)\n throw new Error(\"Can't retire a fence that hasn't fired.\");\n self.retired = true;\n }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n var self = this;\n options = options || {};\n\n self.nextId = 1;\n // map from collection name (string) -> listener id -> object. each object has\n // keys 'trigger', 'callback'. As a hack, the empty string means \"no\n // collection\".\n self.listenersByCollection = {};\n self.listenersByCollectionCount = {};\n self.factPackage = options.factPackage || \"livedata\";\n self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n // msg is a trigger or a notification\n _collectionForMessage: function (msg) {\n var self = this;\n if (! _.has(msg, 'collection')) {\n return '';\n } else if (typeof(msg.collection) === 'string') {\n if (msg.collection === '')\n throw Error(\"Message has empty collection!\");\n return msg.collection;\n } else {\n throw Error(\"Message has non-string collection!\");\n }\n },\n\n // Listen for notification that match 'trigger'. A notification\n // matches if it has the key-value pairs in trigger as a\n // subset. When a notification matches, call 'callback', passing\n // the actual notification.\n //\n // Returns a listen handle, which is an object with a method\n // stop(). Call stop() to stop listening.\n //\n // XXX It should be legal to call fire() from inside a listen()\n // callback?\n listen: function (trigger, callback) {\n var self = this;\n var id = self.nextId++;\n\n var collection = self._collectionForMessage(trigger);\n var record = {trigger: EJSON.clone(trigger), callback: callback};\n if (! _.has(self.listenersByCollection, collection)) {\n self.listenersByCollection[collection] = {};\n self.listenersByCollectionCount[collection] = 0;\n }\n self.listenersByCollection[collection][id] = record;\n self.listenersByCollectionCount[collection]++;\n\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, 1);\n }\n\n return {\n stop: function () {\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, -1);\n }\n delete self.listenersByCollection[collection][id];\n self.listenersByCollectionCount[collection]--;\n if (self.listenersByCollectionCount[collection] === 0) {\n delete self.listenersByCollection[collection];\n delete self.listenersByCollectionCount[collection];\n }\n }\n };\n },\n\n // Fire the provided 'notification' (an object whose attribute\n // values are all JSON-compatibile) -- inform all matching listeners\n // (registered with listen()).\n //\n // If fire() is called inside a write fence, then each of the\n // listener callbacks will be called inside the write fence as well.\n //\n // The listeners may be invoked in parallel, rather than serially.\n fire: function (notification) {\n var self = this;\n\n var collection = self._collectionForMessage(notification);\n\n if (! _.has(self.listenersByCollection, collection)) {\n return;\n }\n\n var listenersForCollection = self.listenersByCollection[collection];\n var callbackIds = [];\n _.each(listenersForCollection, function (l, id) {\n if (self._matches(notification, l.trigger)) {\n callbackIds.push(id);\n }\n });\n\n // Listener callbacks can yield, so we need to first find all the ones that\n // match in a single iteration over self.listenersByCollection (which can't\n // be mutated during this iteration), and then invoke the matching\n // callbacks, checking before each call to ensure they haven't stopped.\n // Note that we don't have to check that\n // self.listenersByCollection[collection] still === listenersForCollection,\n // because the only way that stops being true is if listenersForCollection\n // first gets reduced down to the empty object (and then never gets\n // increased again).\n _.each(callbackIds, function (id) {\n if (_.has(listenersForCollection, id)) {\n listenersForCollection[id].callback(notification);\n }\n });\n },\n\n // A notification matches a trigger if all keys that exist in both are equal.\n //\n // Examples:\n // N:{collection: \"C\"} matches T:{collection: \"C\"}\n // (a non-targeted write to a collection matches a\n // non-targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n // (a targeted write to a collection matches a non-targeted query)\n // N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n // (a non-targeted write to a collection matches a\n // targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n // (a targeted write to a collection matches a targeted query targeted\n // at the same document)\n // N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n // (a targeted write to a collection does not match a targeted query\n // targeted at a different document)\n _matches: function (notification, trigger) {\n // Most notifications that use the crossbar have a string `collection` and\n // maybe an `id` that is a string or ObjectID. We're already dividing up\n // triggers by collection, but let's fast-track \"nope, different ID\" (and\n // avoid the overly generic EJSON.equals). This makes a noticeable\n // performance difference; see https://github.com/meteor/meteor/pull/3697\n if (typeof(notification.id) === 'string' &&\n typeof(trigger.id) === 'string' &&\n notification.id !== trigger.id) {\n return false;\n }\n if (notification.id instanceof MongoID.ObjectID &&\n trigger.id instanceof MongoID.ObjectID &&\n ! notification.id.equals(trigger.id)) {\n return false;\n }\n\n return _.all(trigger, function (triggerValue, key) {\n return !_.has(notification, key) ||\n EJSON.equals(triggerValue, notification[key]);\n });\n }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n function (name) {\n Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} \ No newline at end of file diff --git a/server/bundle/star.json b/server/bundle/star.json index 665464447a..c70d086232 100644 --- a/server/bundle/star.json +++ b/server/bundle/star.json @@ -36,5 +36,5 @@ "meteorRelease": "METEOR@1.9.3", "nodeVersion": "12.16.1", "npmVersion": "6.13.4", - "gitCommitHash": "dfc5b93993de2cdc4f25fc17cd29ba7f8947c069" + "gitCommitHash": "ff3716b5435f36644aa77f696f878d48faf1f906" } \ No newline at end of file From 19d66b8f9e38ad011e1f7161e2b02e74ff161f5c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=AD=99=E6=B5=A9=E6=9E=97?= Date: Fri, 19 Jul 2024 13:19:40 +0800 Subject: [PATCH 3/6] =?UTF-8?q?=E4=BD=BF=E7=94=A8DISABLE=5FSOCKJS=5FCORS?= =?UTF-8?q?=E6=8E=A7=E5=88=B6=E6=98=AF=E5=90=A6=E7=A6=81=E6=AD=A2cors=20?= =?UTF-8?q?=EF=BC=88#6964=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- creator/packages/ddp-server/stream_server.js | 7 ++++--- server/bundle/programs/server/packages/ddp-server.js | 9 +++++---- server/bundle/programs/server/packages/ddp-server.js.map | 2 +- server/bundle/star.json | 2 +- 4 files changed, 11 insertions(+), 9 deletions(-) diff --git a/creator/packages/ddp-server/stream_server.js b/creator/packages/ddp-server/stream_server.js index 85a9997e56..16d62b3265 100644 --- a/creator/packages/ddp-server/stream_server.js +++ b/creator/packages/ddp-server/stream_server.js @@ -52,12 +52,13 @@ StreamServer = function () { // combining CPU-heavy processing with SockJS termination (eg a proxy which // converts to Unix sockets) but for now, raise the delay. disconnect_delay: 60 * 1000, + // Allow disabling of CORS requests to address + // https://github.com/meteor/meteor/issues/8317. + disable_cors: !!process.env.DISABLE_SOCKJS_CORS, // Set the USE_JSESSIONID environment variable to enable setting the // JSESSIONID cookie. This is useful for setting up proxies with // session affinity. - jsessionid: !!process.env.USE_JSESSIONID, - // 禁用cors，防止请求response返回Access-Control-Allow-Origin:* - disable_cors: true + jsessionid: !!process.env.USE_JSESSIONID }; // If you know your server environment (eg, proxies) will prevent websockets diff --git a/server/bundle/programs/server/packages/ddp-server.js b/server/bundle/programs/server/packages/ddp-server.js index 440878eebe..a01f98f0cd 100644 --- a/server/bundle/programs/server/packages/ddp-server.js +++ b/server/bundle/programs/server/packages/ddp-server.js @@ -84,12 +84,13 @@ StreamServer = function () { // combining CPU-heavy processing with SockJS termination (eg a proxy which // converts to Unix sockets) but for now, raise the delay. disconnect_delay: 60 * 1000, + // Allow disabling of CORS requests to address + // https://github.com/meteor/meteor/issues/8317. + disable_cors: !!process.env.DISABLE_SOCKJS_CORS, // Set the USE_JSESSIONID environment variable to enable setting the // JSESSIONID cookie. This is useful for setting up proxies with // session affinity. - jsessionid: !!process.env.USE_JSESSIONID, - // 禁用cors，防止请求response返回Access-Control-Allow-Origin:* - disable_cors: true + jsessionid: !!process.env.USE_JSESSIONID }; // If you know your server environment (eg, proxies) will prevent websockets // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie, // browsers) will not waste time attempting to use them. @@ -2247,4 +2248,4 @@ Package._define("ddp-server", { })(); //# sourceURL=meteor://💻app/packages/ddp-server.js -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","disable_cors","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n  var extensions = [];\n\n  var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n    ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n  if (websocketCompressionConfig) {\n    extensions.push(Npm.require('permessage-deflate').configure(\n      websocketCompressionConfig\n    ));\n  }\n\n  return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n  var self = this;\n  self.registration_callbacks = [];\n  self.open_sockets = [];\n\n  // Because we are installing directly onto WebApp.httpServer instead of using\n  // WebApp.app, we have to process the path prefix ourselves.\n  self.prefix = pathPrefix + '/sockjs';\n  RoutePolicy.declare(self.prefix + '/', 'network');\n\n  // set up sockjs\n  var sockjs = Npm.require('sockjs');\n  var serverOptions = {\n    prefix: self.prefix,\n    log: function () { },\n    // this is the default, but we code it explicitly because we depend\n    // on it in stream_client:HEARTBEAT_TIMEOUT\n    heartbeat_delay: 45000,\n    // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n    // bound for that much time, SockJS might not notice that the user has\n    // reconnected because the timer (of disconnect_delay ms) can fire before\n    // SockJS processes the new connection. Eventually we'll fix this by not\n    // combining CPU-heavy processing with SockJS termination (eg a proxy which\n    // converts to Unix sockets) but for now, raise the delay.\n    disconnect_delay: 60 * 1000,\n    // Set the USE_JSESSIONID environment variable to enable setting the\n    // JSESSIONID cookie. This is useful for setting up proxies with\n    // session affinity.\n    jsessionid: !!process.env.USE_JSESSIONID,\n    // 禁用cors，防止请求response返回Access-Control-Allow-Origin:*\n    disable_cors: true\n  };\n\n  // If you know your server environment (eg, proxies) will prevent websockets\n  // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n  // browsers) will not waste time attempting to use them.\n  // (Your server will still have a /websocket endpoint.)\n  if (process.env.DISABLE_WEBSOCKETS) {\n    serverOptions.websocket = false;\n  } else {\n    serverOptions.faye_server_options = {\n      extensions: websocketExtensions()\n    };\n  }\n\n  self.server = sockjs.createServer(serverOptions);\n\n  // Install the sockjs handlers, but we want to keep around our own particular\n  // request handler that adjusts idle timeouts while we have an outstanding\n  // request.  This compensates for the fact that sockjs removes all listeners\n  // for \"request\" to add its own.\n  WebApp.httpServer.removeListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n  self.server.installHandlers(WebApp.httpServer);\n  WebApp.httpServer.addListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n\n  // Support the /websocket endpoint\n  self._redirectWebsocketEndpoint();\n\n  self.server.on('connection', function (socket) {\n    // We want to make sure that if a client connects to us and does the initial\n    // Websocket handshake but never gets to the DDP handshake, that we\n    // eventually kill the socket.  Once the DDP handshake happens, DDP\n    // heartbeating will work. And before the Websocket handshake, the timeouts\n    // we set at the server level in webapp_server.js will work. But\n    // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n    // is an \"in between\" state where this doesn't happen.  We work around this\n    // by explicitly setting the socket timeout to a relatively large time here,\n    // and setting it back to zero when we set up the heartbeat in\n    // livedata_server.js.\n    socket.setWebsocketTimeout = function (timeout) {\n      if ((socket.protocol === 'websocket' ||\n        socket.protocol === 'websocket-raw')\n        && socket._session.recv) {\n        socket._session.recv.connection.setTimeout(timeout);\n      }\n    };\n    socket.setWebsocketTimeout(45 * 1000);\n\n    socket.send = function (data) {\n      socket.write(data);\n    };\n    socket.on('close', function () {\n      self.open_sockets = _.without(self.open_sockets, socket);\n    });\n    self.open_sockets.push(socket);\n\n    // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n    // will force old clients to reload. Remove this once we're not\n    // concerned about people upgrading from a pre-0.7.0 release. Also,\n    // remove the clause in the client that ignores the welcome message\n    // (livedata_connection.js)\n    socket.send(JSON.stringify({ server_id: \"0\" }));\n\n    // call all our callbacks when we get a new socket. they will do the\n    // work of setting up handlers and such for specific messages.\n    _.each(self.registration_callbacks, function (callback) {\n      callback(socket);\n    });\n  });\n\n};\n\n_.extend(StreamServer.prototype, {\n  // call my callback when a new socket connects.\n  // also call it for all current connections.\n  register: function (callback) {\n    var self = this;\n    self.registration_callbacks.push(callback);\n    _.each(self.all_sockets(), function (socket) {\n      callback(socket);\n    });\n  },\n\n  // get a list of all sockets\n  all_sockets: function () {\n    var self = this;\n    return _.values(self.open_sockets);\n  },\n\n  // Redirect /websocket to /sockjs/websocket in order to not expose\n  // sockjs to clients that want to use raw websockets\n  _redirectWebsocketEndpoint: function () {\n    var self = this;\n    // Unfortunately we can't use a connect middleware here since\n    // sockjs installs itself prior to all existing listeners\n    // (meaning prior to any connect middlewares) so we need to take\n    // an approach similar to overshadowListeners in\n    // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n    _.each(['request', 'upgrade'], function (event) {\n      var httpServer = WebApp.httpServer;\n      var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n      httpServer.removeAllListeners(event);\n\n      // request and upgrade have different arguments passed but\n      // we only care about the first one which is always request\n      var newListener = function (request /*, moreArguments */) {\n        // Store arguments for use within the closure below\n        var args = arguments;\n\n        // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n        // preserving query string.\n        var parsedUrl = url.parse(request.url);\n        if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n          parsedUrl.pathname === pathPrefix + '/websocket/') {\n          parsedUrl.pathname = self.prefix + '/websocket';\n          request.url = url.format(parsedUrl);\n        }\n        _.each(oldHttpServerListeners, function (oldListener) {\n          oldListener.apply(httpServer, args);\n        });\n      };\n      httpServer.addListener(event, newListener);\n    });\n  }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n  var self = this;\n  self.existsIn = new Set(); // set of subscriptionHandle\n  self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n  getFields: function () {\n    var self = this;\n    var ret = {};\n    self.dataByKey.forEach(function (precedenceList, key) {\n      ret[key] = precedenceList[0].value;\n    });\n    return ret;\n  },\n\n  clearField: function (subscriptionHandle, key, changeCollector) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n    var precedenceList = self.dataByKey.get(key);\n\n    // It's okay to clear fields that didn't exist. No need to throw\n    // an error.\n    if (!precedenceList)\n      return;\n\n    var removedValue = undefined;\n    for (var i = 0; i < precedenceList.length; i++) {\n      var precedence = precedenceList[i];\n      if (precedence.subscriptionHandle === subscriptionHandle) {\n        // The view's value can only change if this subscription is the one that\n        // used to have precedence.\n        if (i === 0)\n          removedValue = precedence.value;\n        precedenceList.splice(i, 1);\n        break;\n      }\n    }\n    if (precedenceList.length === 0) {\n      self.dataByKey.delete(key);\n      changeCollector[key] = undefined;\n    } else if (removedValue !== undefined &&\n               !EJSON.equals(removedValue, precedenceList[0].value)) {\n      changeCollector[key] = precedenceList[0].value;\n    }\n  },\n\n  changeField: function (subscriptionHandle, key, value,\n                         changeCollector, isAdd) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n\n    // Don't share state with the data passed in by the user.\n    value = EJSON.clone(value);\n\n    if (!self.dataByKey.has(key)) {\n      self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n                                value: value}]);\n      changeCollector[key] = value;\n      return;\n    }\n    var precedenceList = self.dataByKey.get(key);\n    var elt;\n    if (!isAdd) {\n      elt = precedenceList.find(function (precedence) {\n          return precedence.subscriptionHandle === subscriptionHandle;\n      });\n    }\n\n    if (elt) {\n      if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n        // this subscription is changing the value of this field.\n        changeCollector[key] = value;\n      }\n      elt.value = value;\n    } else {\n      // this subscription is newly caring about this field\n      precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n    }\n\n  }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n  var self = this;\n  self.collectionName = collectionName;\n  self.documents = new Map();\n  self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n  isEmpty: function () {\n    var self = this;\n    return self.documents.size === 0;\n  },\n\n  diff: function (previous) {\n    var self = this;\n    DiffSequence.diffMaps(previous.documents, self.documents, {\n      both: _.bind(self.diffDocument, self),\n\n      rightOnly: function (id, nowDV) {\n        self.callbacks.added(self.collectionName, id, nowDV.getFields());\n      },\n\n      leftOnly: function (id, prevDV) {\n        self.callbacks.removed(self.collectionName, id);\n      }\n    });\n  },\n\n  diffDocument: function (id, prevDV, nowDV) {\n    var self = this;\n    var fields = {};\n    DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n      both: function (key, prev, now) {\n        if (!EJSON.equals(prev, now))\n          fields[key] = now;\n      },\n      rightOnly: function (key, now) {\n        fields[key] = now;\n      },\n      leftOnly: function(key, prev) {\n        fields[key] = undefined;\n      }\n    });\n    self.callbacks.changed(self.collectionName, id, fields);\n  },\n\n  added: function (subscriptionHandle, id, fields) {\n    var self = this;\n    var docView = self.documents.get(id);\n    var added = false;\n    if (!docView) {\n      added = true;\n      docView = new SessionDocumentView();\n      self.documents.set(id, docView);\n    }\n    docView.existsIn.add(subscriptionHandle);\n    var changeCollector = {};\n    _.each(fields, function (value, key) {\n      docView.changeField(\n        subscriptionHandle, key, value, changeCollector, true);\n    });\n    if (added)\n      self.callbacks.added(self.collectionName, id, changeCollector);\n    else\n      self.callbacks.changed(self.collectionName, id, changeCollector);\n  },\n\n  changed: function (subscriptionHandle, id, changed) {\n    var self = this;\n    var changedResult = {};\n    var docView = self.documents.get(id);\n    if (!docView)\n      throw new Error(\"Could not find element with id \" + id + \" to change\");\n    _.each(changed, function (value, key) {\n      if (value === undefined)\n        docView.clearField(subscriptionHandle, key, changedResult);\n      else\n        docView.changeField(subscriptionHandle, key, value, changedResult);\n    });\n    self.callbacks.changed(self.collectionName, id, changedResult);\n  },\n\n  removed: function (subscriptionHandle, id) {\n    var self = this;\n    var docView = self.documents.get(id);\n    if (!docView) {\n      var err = new Error(\"Removed nonexistent document \" + id);\n      throw err;\n    }\n    docView.existsIn.delete(subscriptionHandle);\n    if (docView.existsIn.size === 0) {\n      // it is gone from everyone\n      self.callbacks.removed(self.collectionName, id);\n      self.documents.delete(id);\n    } else {\n      var changed = {};\n      // remove this subscription from every precedence list\n      // and record the changes\n      docView.dataByKey.forEach(function (precedenceList, key) {\n        docView.clearField(subscriptionHandle, key, changed);\n      });\n\n      self.callbacks.changed(self.collectionName, id, changed);\n    }\n  }\n});\n\n/******************************************************************************/\n/* Session                                                                    */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n  var self = this;\n  self.id = Random.id();\n\n  self.server = server;\n  self.version = version;\n\n  self.initialized = false;\n  self.socket = socket;\n\n  // set to null when the session is destroyed. multiple places below\n  // use this to determine if the session is alive or not.\n  self.inQueue = new Meteor._DoubleEndedQueue();\n\n  self.blocked = false;\n  self.workerRunning = false;\n\n  // Sub objects for active subscriptions\n  self._namedSubs = new Map();\n  self._universalSubs = [];\n\n  self.userId = null;\n\n  self.collectionViews = new Map();\n\n  // Set this to false to not send messages when collectionViews are\n  // modified. This is done when rerunning subs in _setUserId and those messages\n  // are calculated via a diff instead.\n  self._isSending = true;\n\n  // If this is true, don't start a newly-created universal publisher on this\n  // session. The session will take care of starting it when appropriate.\n  self._dontStartNewUniversalSubs = false;\n\n  // when we are rerunning subscriptions, any ready messages\n  // we want to buffer up for when we are done rerunning subscriptions\n  self._pendingReady = [];\n\n  // List of callbacks to call when this connection is closed.\n  self._closeCallbacks = [];\n\n\n  // XXX HACK: If a sockjs connection, save off the URL. This is\n  // temporary and will go away in the near future.\n  self._socketUrl = socket.url;\n\n  // Allow tests to disable responding to pings.\n  self._respondToPings = options.respondToPings;\n\n  // This object is the public interface to the session. In the public\n  // API, it is called the `connection` object.  Internally we call it\n  // a `connectionHandle` to avoid ambiguity.\n  self.connectionHandle = {\n    id: self.id,\n    close: function () {\n      self.close();\n    },\n    onClose: function (fn) {\n      var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n      if (self.inQueue) {\n        self._closeCallbacks.push(cb);\n      } else {\n        // if we're already closed, call the callback.\n        Meteor.defer(cb);\n      }\n    },\n    clientAddress: self._clientAddress(),\n    httpHeaders: self.socket.headers\n  };\n\n  self.send({ msg: 'connected', session: self.id });\n\n  // On initial connect, spin up all the universal publishers.\n  Fiber(function () {\n    self.startUniversalSubs();\n  }).run();\n\n  if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n    // We no longer need the low level timeout because we have heartbeating.\n    socket.setWebsocketTimeout(0);\n\n    self.heartbeat = new DDPCommon.Heartbeat({\n      heartbeatInterval: options.heartbeatInterval,\n      heartbeatTimeout: options.heartbeatTimeout,\n      onTimeout: function () {\n        self.close();\n      },\n      sendPing: function () {\n        self.send({msg: 'ping'});\n      }\n    });\n    self.heartbeat.start();\n  }\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n  sendReady: function (subscriptionIds) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"ready\", subs: subscriptionIds});\n    else {\n      _.each(subscriptionIds, function (subscriptionId) {\n        self._pendingReady.push(subscriptionId);\n      });\n    }\n  },\n\n  sendAdded: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n  },\n\n  sendChanged: function (collectionName, id, fields) {\n    var self = this;\n    if (_.isEmpty(fields))\n      return;\n\n    if (self._isSending) {\n      self.send({\n        msg: \"changed\",\n        collection: collectionName,\n        id: id,\n        fields: fields\n      });\n    }\n  },\n\n  sendRemoved: function (collectionName, id) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"removed\", collection: collectionName, id: id});\n  },\n\n  getSendCallbacks: function () {\n    var self = this;\n    return {\n      added: _.bind(self.sendAdded, self),\n      changed: _.bind(self.sendChanged, self),\n      removed: _.bind(self.sendRemoved, self)\n    };\n  },\n\n  getCollectionView: function (collectionName) {\n    var self = this;\n    var ret = self.collectionViews.get(collectionName);\n    if (!ret) {\n      ret = new SessionCollectionView(collectionName,\n                                        self.getSendCallbacks());\n      self.collectionViews.set(collectionName, ret);\n    }\n    return ret;\n  },\n\n  added: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.added(subscriptionHandle, id, fields);\n  },\n\n  removed: function (subscriptionHandle, collectionName, id) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.removed(subscriptionHandle, id);\n    if (view.isEmpty()) {\n       self.collectionViews.delete(collectionName);\n    }\n  },\n\n  changed: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.changed(subscriptionHandle, id, fields);\n  },\n\n  startUniversalSubs: function () {\n    var self = this;\n    // Make a shallow copy of the set of universal handlers and start them. If\n    // additional universal publishers start while we're running them (due to\n    // yielding), they will run separately as part of Server.publish.\n    var handlers = _.clone(self.server.universal_publish_handlers);\n    _.each(handlers, function (handler) {\n      self._startSubscription(handler);\n    });\n  },\n\n  // Destroy this session and unregister it at the server.\n  close: function () {\n    var self = this;\n\n    // Destroy this session, even if it's not registered at the\n    // server. Stop all processing and tear everything down. If a socket\n    // was attached, close it.\n\n    // Already destroyed.\n    if (! self.inQueue)\n      return;\n\n    // Drop the merge box data immediately.\n    self.inQueue = null;\n    self.collectionViews = new Map();\n\n    if (self.heartbeat) {\n      self.heartbeat.stop();\n      self.heartbeat = null;\n    }\n\n    if (self.socket) {\n      self.socket.close();\n      self.socket._meteorSession = null;\n    }\n\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"sessions\", -1);\n\n    Meteor.defer(function () {\n      // stop callbacks can yield, so we defer this on close.\n      // sub._isDeactivated() detects that we set inQueue to null and\n      // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n      self._deactivateAllSubscriptions();\n\n      // Defer calling the close callbacks, so that the caller closing\n      // the session isn't waiting for all the callbacks to complete.\n      _.each(self._closeCallbacks, function (callback) {\n        callback();\n      });\n    });\n\n    // Unregister the session.\n    self.server._removeSession(self);\n  },\n\n  // Send a message (doing nothing if no socket is connected right now.)\n  // It should be a JSON object (it will be stringified.)\n  send: function (msg) {\n    var self = this;\n    if (self.socket) {\n      if (Meteor._printSentDDP)\n        Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n      self.socket.send(DDPCommon.stringifyDDP(msg));\n    }\n  },\n\n  // Send a connection error.\n  sendError: function (reason, offendingMessage) {\n    var self = this;\n    var msg = {msg: 'error', reason: reason};\n    if (offendingMessage)\n      msg.offendingMessage = offendingMessage;\n    self.send(msg);\n  },\n\n  // Process 'msg' as an incoming message. (But as a guard against\n  // race conditions during reconnection, ignore the message if\n  // 'socket' is not the currently connected socket.)\n  //\n  // We run the messages from the client one at a time, in the order\n  // given by the client. The message handler is passed an idempotent\n  // function 'unblock' which it may call to allow other messages to\n  // begin running in parallel in another fiber (for example, a method\n  // that wants to yield.) Otherwise, it is automatically unblocked\n  // when it returns.\n  //\n  // Actually, we don't have to 'totally order' the messages in this\n  // way, but it's the easiest thing that's correct. (unsub needs to\n  // be ordered against sub, methods need to be ordered against each\n  // other.)\n  processMessage: function (msg_in) {\n    var self = this;\n    if (!self.inQueue) // we have been destroyed.\n      return;\n\n    // Respond to ping and pong messages immediately without queuing.\n    // If the negotiated DDP version is \"pre1\" which didn't support\n    // pings, preserve the \"pre1\" behavior of responding with a \"bad\n    // request\" for the unknown messages.\n    //\n    // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n    // needs a Fiber. We could actually use regular setTimeout and avoid\n    // these new fibers, but it is easier to just make everything use\n    // Meteor.setTimeout and not think too hard.\n    //\n    // Any message counts as receiving a pong, as it demonstrates that\n    // the client is still alive.\n    if (self.heartbeat) {\n      Fiber(function () {\n        self.heartbeat.messageReceived();\n      }).run();\n    }\n\n    if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n      if (self._respondToPings)\n        self.send({msg: \"pong\", id: msg_in.id});\n      return;\n    }\n    if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n      // Since everything is a pong, nothing to do\n      return;\n    }\n\n    self.inQueue.push(msg_in);\n    if (self.workerRunning)\n      return;\n    self.workerRunning = true;\n\n    var processNext = function () {\n      var msg = self.inQueue && self.inQueue.shift();\n      if (!msg) {\n        self.workerRunning = false;\n        return;\n      }\n\n      Fiber(function () {\n        var blocked = true;\n\n        var unblock = function () {\n          if (!blocked)\n            return; // idempotent\n          blocked = false;\n          processNext();\n        };\n\n        self.server.onMessageHook.each(function (callback) {\n          callback(msg, self);\n          return true;\n        });\n\n        if (_.has(self.protocol_handlers, msg.msg))\n          self.protocol_handlers[msg.msg].call(self, msg, unblock);\n        else\n          self.sendError('Bad request', msg);\n        unblock(); // in case the handler didn't already do it\n      }).run();\n    };\n\n    processNext();\n  },\n\n  protocol_handlers: {\n    sub: function (msg) {\n      var self = this;\n\n      // reject malformed messages\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.name) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array))) {\n        self.sendError(\"Malformed subscription\", msg);\n        return;\n      }\n\n      if (!self.server.publish_handlers[msg.name]) {\n        self.send({\n          msg: 'nosub', id: msg.id,\n          error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n        return;\n      }\n\n      if (self._namedSubs.has(msg.id))\n        // subs are idempotent, or rather, they are ignored if a sub\n        // with that id already exists. this is important during\n        // reconnect.\n        return;\n\n      // XXX It'd be much better if we had generic hooks where any package can\n      // hook into subscription handling, but in the mean while we special case\n      // ddp-rate-limiter package. This is also done for weak requirements to\n      // add the ddp-rate-limiter package in case we don't have Accounts. A\n      // user trying to use the ddp-rate-limiter must explicitly require it.\n      if (Package['ddp-rate-limiter']) {\n        var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n        var rateLimiterInput = {\n          userId: self.userId,\n          clientAddress: self.connectionHandle.clientAddress,\n          type: \"subscription\",\n          name: msg.name,\n          connectionId: self.id\n        };\n\n        DDPRateLimiter._increment(rateLimiterInput);\n        var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n        if (!rateLimitResult.allowed) {\n          self.send({\n            msg: 'nosub', id: msg.id,\n            error: new Meteor.Error(\n              'too-many-requests',\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset})\n          });\n          return;\n        }\n      }\n\n      var handler = self.server.publish_handlers[msg.name];\n\n      self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n    },\n\n    unsub: function (msg) {\n      var self = this;\n\n      self._stopSubscription(msg.id);\n    },\n\n    method: function (msg, unblock) {\n      var self = this;\n\n      // reject malformed messages\n      // For now, we silently ignore unknown attributes,\n      // for forwards compatibility.\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.method) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array)) ||\n          (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n        self.sendError(\"Malformed method invocation\", msg);\n        return;\n      }\n\n      var randomSeed = msg.randomSeed || null;\n\n      // set up to mark the method as satisfied once all observers\n      // (and subscriptions) have reacted to any writes that were\n      // done.\n      var fence = new DDPServer._WriteFence;\n      fence.onAllCommitted(function () {\n        // Retire the fence so that future writes are allowed.\n        // This means that callbacks like timers are free to use\n        // the fence, and if they fire before it's armed (for\n        // example, because the method waits for them) their\n        // writes will be included in the fence.\n        fence.retire();\n        self.send({\n          msg: 'updated', methods: [msg.id]});\n      });\n\n      // find the handler\n      var handler = self.server.method_handlers[msg.method];\n      if (!handler) {\n        self.send({\n          msg: 'result', id: msg.id,\n          error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n        fence.arm();\n        return;\n      }\n\n      var setUserId = function(userId) {\n        self._setUserId(userId);\n      };\n\n      var invocation = new DDPCommon.MethodInvocation({\n        isSimulation: false,\n        userId: self.userId,\n        setUserId: setUserId,\n        unblock: unblock,\n        connection: self.connectionHandle,\n        randomSeed: randomSeed\n      });\n\n      const promise = new Promise((resolve, reject) => {\n        // XXX It'd be better if we could hook into method handlers better but\n        // for now, we need to check if the ddp-rate-limiter exists since we\n        // have a weak requirement for the ddp-rate-limiter package to be added\n        // to our application.\n        if (Package['ddp-rate-limiter']) {\n          var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n          var rateLimiterInput = {\n            userId: self.userId,\n            clientAddress: self.connectionHandle.clientAddress,\n            type: \"method\",\n            name: msg.method,\n            connectionId: self.id\n          };\n          DDPRateLimiter._increment(rateLimiterInput);\n          var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n          if (!rateLimitResult.allowed) {\n            reject(new Meteor.Error(\n              \"too-many-requests\",\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset}\n            ));\n            return;\n          }\n        }\n\n        resolve(DDPServer._CurrentWriteFence.withValue(\n          fence,\n          () => DDP._CurrentMethodInvocation.withValue(\n            invocation,\n            () => maybeAuditArgumentChecks(\n              handler, invocation, msg.params,\n              \"call to '\" + msg.method + \"'\"\n            )\n          )\n        ));\n      });\n\n      function finish() {\n        fence.arm();\n        unblock();\n      }\n\n      const payload = {\n        msg: \"result\",\n        id: msg.id\n      };\n\n      promise.then((result) => {\n        finish();\n        if (result !== undefined) {\n          payload.result = result;\n        }\n        self.send(payload);\n      }, (exception) => {\n        finish();\n        payload.error = wrapInternalException(\n          exception,\n          `while invoking method '${msg.method}'`\n        );\n        self.send(payload);\n      });\n    }\n  },\n\n  _eachSub: function (f) {\n    var self = this;\n    self._namedSubs.forEach(f);\n    self._universalSubs.forEach(f);\n  },\n\n  _diffCollectionViews: function (beforeCVs) {\n    var self = this;\n    DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n      both: function (collectionName, leftValue, rightValue) {\n        rightValue.diff(leftValue);\n      },\n      rightOnly: function (collectionName, rightValue) {\n        rightValue.documents.forEach(function (docView, id) {\n          self.sendAdded(collectionName, id, docView.getFields());\n        });\n      },\n      leftOnly: function (collectionName, leftValue) {\n        leftValue.documents.forEach(function (doc, id) {\n          self.sendRemoved(collectionName, id);\n        });\n      }\n    });\n  },\n\n  // Sets the current user id in all appropriate contexts and reruns\n  // all subscriptions\n  _setUserId: function(userId) {\n    var self = this;\n\n    if (userId !== null && typeof userId !== \"string\")\n      throw new Error(\"setUserId must be called on string or null, not \" +\n                      typeof userId);\n\n    // Prevent newly-created universal subscriptions from being added to our\n    // session; they will be found below when we call startUniversalSubs.\n    //\n    // (We don't have to worry about named subscriptions, because we only add\n    // them when we process a 'sub' message. We are currently processing a\n    // 'method' message, and the method did not unblock, because it is illegal\n    // to call setUserId after unblock. Thus we cannot be concurrently adding a\n    // new named subscription.)\n    self._dontStartNewUniversalSubs = true;\n\n    // Prevent current subs from updating our collectionViews and call their\n    // stop callbacks. This may yield.\n    self._eachSub(function (sub) {\n      sub._deactivate();\n    });\n\n    // All subs should now be deactivated. Stop sending messages to the client,\n    // save the state of the published collections, reset to an empty view, and\n    // update the userId.\n    self._isSending = false;\n    var beforeCVs = self.collectionViews;\n    self.collectionViews = new Map();\n    self.userId = userId;\n\n    // _setUserId is normally called from a Meteor method with\n    // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n    // expected to be set inside a publish function, so we temporary unset it.\n    // Inside a publish function DDP._CurrentPublicationInvocation is set.\n    DDP._CurrentMethodInvocation.withValue(undefined, function () {\n      // Save the old named subs, and reset to having no subscriptions.\n      var oldNamedSubs = self._namedSubs;\n      self._namedSubs = new Map();\n      self._universalSubs = [];\n\n      oldNamedSubs.forEach(function (sub, subscriptionId) {\n        var newSub = sub._recreate();\n        self._namedSubs.set(subscriptionId, newSub);\n        // nb: if the handler throws or calls this.error(), it will in fact\n        // immediately send its 'nosub'. This is OK, though.\n        newSub._runHandler();\n      });\n\n      // Allow newly-created universal subs to be started on our connection in\n      // parallel with the ones we're spinning up here, and spin up universal\n      // subs.\n      self._dontStartNewUniversalSubs = false;\n      self.startUniversalSubs();\n    });\n\n    // Start sending messages again, beginning with the diff from the previous\n    // state of the world to the current state. No yields are allowed during\n    // this diff, so that other changes cannot interleave.\n    Meteor._noYieldsAllowed(function () {\n      self._isSending = true;\n      self._diffCollectionViews(beforeCVs);\n      if (!_.isEmpty(self._pendingReady)) {\n        self.sendReady(self._pendingReady);\n        self._pendingReady = [];\n      }\n    });\n  },\n\n  _startSubscription: function (handler, subId, params, name) {\n    var self = this;\n\n    var sub = new Subscription(\n      self, handler, subId, params, name);\n    if (subId)\n      self._namedSubs.set(subId, sub);\n    else\n      self._universalSubs.push(sub);\n\n    sub._runHandler();\n  },\n\n  // tear down specified subscription\n  _stopSubscription: function (subId, error) {\n    var self = this;\n\n    var subName = null;\n    if (subId) {\n      var maybeSub = self._namedSubs.get(subId);\n      if (maybeSub) {\n        subName = maybeSub._name;\n        maybeSub._removeAllDocuments();\n        maybeSub._deactivate();\n        self._namedSubs.delete(subId);\n      }\n    }\n\n    var response = {msg: 'nosub', id: subId};\n\n    if (error) {\n      response.error = wrapInternalException(\n        error,\n        subName ? (\"from sub \" + subName + \" id \" + subId)\n          : (\"from sub id \" + subId));\n    }\n\n    self.send(response);\n  },\n\n  // tear down all subscriptions. Note that this does NOT send removed or nosub\n  // messages, since we assume the client is gone.\n  _deactivateAllSubscriptions: function () {\n    var self = this;\n\n    self._namedSubs.forEach(function (sub, id) {\n      sub._deactivate();\n    });\n    self._namedSubs = new Map();\n\n    self._universalSubs.forEach(function (sub) {\n      sub._deactivate();\n    });\n    self._universalSubs = [];\n  },\n\n  // Determine the remote client's IP address, based on the\n  // HTTP_FORWARDED_COUNT environment variable representing how many\n  // proxies the server is behind.\n  _clientAddress: function () {\n    var self = this;\n\n    // For the reported client address for a connection to be correct,\n    // the developer must set the HTTP_FORWARDED_COUNT environment\n    // variable to an integer representing the number of hops they\n    // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n    // server is behind one proxy.\n    //\n    // This could be computed once at startup instead of every time.\n    var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n    if (httpForwardedCount === 0)\n      return self.socket.remoteAddress;\n\n    var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n    if (! _.isString(forwardedFor))\n      return null;\n    forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n    // Typically the first value in the `x-forwarded-for` header is\n    // the original IP address of the client connecting to the first\n    // proxy.  However, the end user can easily spoof the header, in\n    // which case the first value(s) will be the fake IP address from\n    // the user pretending to be a proxy reporting the original IP\n    // address value.  By counting HTTP_FORWARDED_COUNT back from the\n    // end of the list, we ensure that we get the IP address being\n    // reported by *our* first proxy.\n\n    if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n      return null;\n\n    return forwardedFor[forwardedFor.length - httpForwardedCount];\n  }\n});\n\n/******************************************************************************/\n/* Subscription                                                               */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n    session, handler, subscriptionId, params, name) {\n  var self = this;\n  self._session = session; // type is Session\n\n  /**\n   * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n   * @locus Server\n   * @name  connection\n   * @memberOf Subscription\n   * @instance\n   */\n  self.connection = session.connectionHandle; // public API object\n\n  self._handler = handler;\n\n  // my subscription ID (generated by client, undefined for universal subs).\n  self._subscriptionId = subscriptionId;\n  // undefined for universal subs\n  self._name = name;\n\n  self._params = params || [];\n\n  // Only named subscriptions have IDs, but we need some sort of string\n  // internally to keep track of all subscriptions inside\n  // SessionDocumentViews. We use this subscriptionHandle for that.\n  if (self._subscriptionId) {\n    self._subscriptionHandle = 'N' + self._subscriptionId;\n  } else {\n    self._subscriptionHandle = 'U' + Random.id();\n  }\n\n  // has _deactivate been called?\n  self._deactivated = false;\n\n  // stop callbacks to g/c this sub.  called w/ zero arguments.\n  self._stopCallbacks = [];\n\n  // the set of (collection, documentid) that this subscription has\n  // an opinion about\n  self._documents = new Map();\n\n  // remember if we are ready.\n  self._ready = false;\n\n  // Part of the public API: the user of this sub.\n\n  /**\n   * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n   * @locus Server\n   * @memberOf Subscription\n   * @name  userId\n   * @instance\n   */\n  self.userId = session.userId;\n\n  // For now, the id filter is going to default to\n  // the to/from DDP methods on MongoID, to\n  // specifically deal with mongo/minimongo ObjectIds.\n\n  // Later, you will be able to make this be \"raw\"\n  // if you want to publish a collection that you know\n  // just has strings for keys and no funny business, to\n  // a ddp consumer that isn't minimongo\n\n  self._idFilter = {\n    idStringify: MongoID.idStringify,\n    idParse: MongoID.idParse\n  };\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n  _runHandler: function () {\n    // XXX should we unblock() here? Either before running the publish\n    // function, or before running _publishCursor.\n    //\n    // Right now, each publish function blocks all future publishes and\n    // methods waiting on data from Mongo (or whatever else the function\n    // blocks on). This probably slows page load in common cases.\n\n    var self = this;\n    try {\n      var res = DDP._CurrentPublicationInvocation.withValue(\n        self,\n        () => maybeAuditArgumentChecks(\n          self._handler, self, EJSON.clone(self._params),\n          // It's OK that this would look weird for universal subscriptions,\n          // because they have no arguments so there can never be an\n          // audit-argument-checks failure.\n          \"publisher '\" + self._name + \"'\"\n        )\n      );\n    } catch (e) {\n      self.error(e);\n      return;\n    }\n\n    // Did the handler call this.error or this.stop?\n    if (self._isDeactivated())\n      return;\n\n    self._publishHandlerResult(res);\n  },\n\n  _publishHandlerResult: function (res) {\n    // SPECIAL CASE: Instead of writing their own callbacks that invoke\n    // this.added/changed/ready/etc, the user can just return a collection\n    // cursor or array of cursors from the publish function; we call their\n    // _publishCursor method which starts observing the cursor and publishes the\n    // results. Note that _publishCursor does NOT call ready().\n    //\n    // XXX This uses an undocumented interface which only the Mongo cursor\n    // interface publishes. Should we make this interface public and encourage\n    // users to implement it themselves? Arguably, it's unnecessary; users can\n    // already write their own functions like\n    //   var publishMyReactiveThingy = function (name, handler) {\n    //     Meteor.publish(name, function () {\n    //       var reactiveThingy = handler();\n    //       reactiveThingy.publishMe();\n    //     });\n    //   };\n\n    var self = this;\n    var isCursor = function (c) {\n      return c && c._publishCursor;\n    };\n    if (isCursor(res)) {\n      try {\n        res._publishCursor(self);\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      // _publishCursor only returns after the initial added callbacks have run.\n      // mark subscription as ready.\n      self.ready();\n    } else if (_.isArray(res)) {\n      // check all the elements are cursors\n      if (! _.all(res, isCursor)) {\n        self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n        return;\n      }\n      // find duplicate collection names\n      // XXX we should support overlapping cursors, but that would require the\n      // merge box to allow overlap within a subscription\n      var collectionNames = {};\n      for (var i = 0; i < res.length; ++i) {\n        var collectionName = res[i]._getCollectionName();\n        if (_.has(collectionNames, collectionName)) {\n          self.error(new Error(\n            \"Publish function returned multiple cursors for collection \" +\n              collectionName));\n          return;\n        }\n        collectionNames[collectionName] = true;\n      };\n\n      try {\n        _.each(res, function (cur) {\n          cur._publishCursor(self);\n        });\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      self.ready();\n    } else if (res) {\n      // truthy values other than cursors or arrays are probably a\n      // user mistake (possible returning a Mongo document via, say,\n      // `coll.findOne()`).\n      self.error(new Error(\"Publish function can only return a Cursor or \"\n                           + \"an array of Cursors\"));\n    }\n  },\n\n  // This calls all stop callbacks and prevents the handler from updating any\n  // SessionCollectionViews further. It's used when the user unsubscribes or\n  // disconnects, as well as during setUserId re-runs. It does *NOT* send\n  // removed messages for the published objects; if that is necessary, call\n  // _removeAllDocuments first.\n  _deactivate: function() {\n    var self = this;\n    if (self._deactivated)\n      return;\n    self._deactivated = true;\n    self._callStopCallbacks();\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"subscriptions\", -1);\n  },\n\n  _callStopCallbacks: function () {\n    var self = this;\n    // tell listeners, so they can clean up\n    var callbacks = self._stopCallbacks;\n    self._stopCallbacks = [];\n    _.each(callbacks, function (callback) {\n      callback();\n    });\n  },\n\n  // Send remove messages for every document.\n  _removeAllDocuments: function () {\n    var self = this;\n    Meteor._noYieldsAllowed(function () {\n      self._documents.forEach(function (collectionDocs, collectionName) {\n        collectionDocs.forEach(function (strId) {\n          self.removed(collectionName, self._idFilter.idParse(strId));\n        });\n      });\n    });\n  },\n\n  // Returns a new Subscription for the same session with the same\n  // initial creation parameters. This isn't a clone: it doesn't have\n  // the same _documents cache, stopped state or callbacks; may have a\n  // different _subscriptionHandle, and gets its userId from the\n  // session, not from this object.\n  _recreate: function () {\n    var self = this;\n    return new Subscription(\n      self._session, self._handler, self._subscriptionId, self._params,\n      self._name);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n   * @locus Server\n   * @param {Error} error The error to pass to the client.\n   * @instance\n   * @memberOf Subscription\n   */\n  error: function (error) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId, error);\n  },\n\n  // Note that while our DDP client will notice that you've called stop() on the\n  // server (and clean up its _subscriptions table) we don't actually provide a\n  // mechanism for an app to notice this (the subscribe onError callback only\n  // triggers if there is an error).\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.\n   * @locus Server\n   * @instance\n   * @memberOf Subscription\n   */\n  stop: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {Function} func The callback function\n   */\n  onStop: function (callback) {\n    var self = this;\n    callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n    if (self._isDeactivated())\n      callback();\n    else\n      self._stopCallbacks.push(callback);\n  },\n\n  // This returns true if the sub has been deactivated, *OR* if the session was\n  // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n  // happened yet.\n  _isDeactivated: function () {\n    var self = this;\n    return self._deactivated || self._session.inQueue === null;\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the new document.\n   * @param {String} id The new document's ID.\n   * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.\n   */\n  added: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    let ids = self._documents.get(collectionName);\n    if (ids == null) {\n      ids = new Set();\n      self._documents.set(collectionName, ids);\n    }\n    ids.add(id);\n    self._session.added(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the changed document.\n   * @param {String} id The changed document's ID.\n   * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.\n   */\n  changed: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that the document has been removed from.\n   * @param {String} id The ID of the document that has been removed.\n   */\n  removed: function (collectionName, id) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    // We don't bother to delete sets of things in a collection if the\n    // collection is empty.  It could break _removeAllDocuments.\n    self._documents.get(collectionName).delete(id);\n    self._session.removed(self._subscriptionHandle, collectionName, id);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   */\n  ready: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    if (!self._subscriptionId)\n      return;  // unnecessary but ignored for universal sub\n    if (!self._ready) {\n      self._session.sendReady([self._subscriptionId]);\n      self._ready = true;\n    }\n  }\n});\n\n/******************************************************************************/\n/* Server                                                                     */\n/******************************************************************************/\n\nServer = function (options) {\n  var self = this;\n\n  // The default heartbeat interval is 30 seconds on the server and 35\n  // seconds on the client.  Since the client doesn't need to send a\n  // ping as long as it is receiving pings, this means that pings\n  // normally go from the server to the client.\n  //\n  // Note: Troposphere depends on the ability to mutate\n  // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n  self.options = _.defaults(options || {}, {\n    heartbeatInterval: 15000,\n    heartbeatTimeout: 15000,\n    // For testing, allow responding to pings to be disabled.\n    respondToPings: true\n  });\n\n  // Map of callbacks to call when a new connection comes in to the\n  // server and completes DDP version negotiation. Use an object instead\n  // of an array so we can safely remove one from the list while\n  // iterating over it.\n  self.onConnectionHook = new Hook({\n    debugPrintExceptions: \"onConnection callback\"\n  });\n\n  // Map of callbacks to call when a new message comes in.\n  self.onMessageHook = new Hook({\n    debugPrintExceptions: \"onMessage callback\"\n  });\n\n  self.publish_handlers = {};\n  self.universal_publish_handlers = [];\n\n  self.method_handlers = {};\n\n  self.sessions = new Map(); // map from id to session\n\n  self.stream_server = new StreamServer;\n\n  self.stream_server.register(function (socket) {\n    // socket implements the SockJSConnection interface\n    socket._meteorSession = null;\n\n    var sendError = function (reason, offendingMessage) {\n      var msg = {msg: 'error', reason: reason};\n      if (offendingMessage)\n        msg.offendingMessage = offendingMessage;\n      socket.send(DDPCommon.stringifyDDP(msg));\n    };\n\n    socket.on('data', function (raw_msg) {\n      if (Meteor._printReceivedDDP) {\n        Meteor._debug(\"Received DDP\", raw_msg);\n      }\n      try {\n        try {\n          var msg = DDPCommon.parseDDP(raw_msg);\n        } catch (err) {\n          sendError('Parse error');\n          return;\n        }\n        if (msg === null || !msg.msg) {\n          sendError('Bad request', msg);\n          return;\n        }\n\n        if (msg.msg === 'connect') {\n          if (socket._meteorSession) {\n            sendError(\"Already connected\", msg);\n            return;\n          }\n          Fiber(function () {\n            self._handleConnect(socket, msg);\n          }).run();\n          return;\n        }\n\n        if (!socket._meteorSession) {\n          sendError('Must connect first', msg);\n          return;\n        }\n        socket._meteorSession.processMessage(msg);\n      } catch (e) {\n        // XXX print stack nicely\n        Meteor._debug(\"Internal exception while processing message\", msg, e);\n      }\n    });\n\n    socket.on('close', function () {\n      if (socket._meteorSession) {\n        Fiber(function () {\n          socket._meteorSession.close();\n        }).run();\n      }\n    });\n  });\n};\n\n_.extend(Server.prototype, {\n\n  /**\n   * @summary Register a callback to be called when a new DDP connection is made to the server.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP connection is established.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onConnection: function (fn) {\n    var self = this;\n    return self.onConnectionHook.register(fn);\n  },\n\n  /**\n   * @summary Register a callback to be called when a new DDP message is received.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP message is received.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onMessage: function (fn) {\n    var self = this;\n    return self.onMessageHook.register(fn);\n  },\n\n  _handleConnect: function (socket, msg) {\n    var self = this;\n\n    // The connect message must specify a version and an array of supported\n    // versions, and it must claim to support what it is proposing.\n    if (!(typeof (msg.version) === 'string' &&\n          _.isArray(msg.support) &&\n          _.all(msg.support, _.isString) &&\n          _.contains(msg.support, msg.version))) {\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n                                version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n      socket.close();\n      return;\n    }\n\n    // In the future, handle session resumption: something like:\n    //  socket._meteorSession = self.sessions[msg.session]\n    var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n    if (msg.version !== version) {\n      // The best version to use (according to the client's stated preferences)\n      // is not the one the client is trying to use. Inform them about the best\n      // version to use.\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n      socket.close();\n      return;\n    }\n\n    // Yay, version matches! Create a new session.\n    // Note: Troposphere depends on the ability to mutate\n    // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n    socket._meteorSession = new Session(self, version, socket, self.options);\n    self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n    self.onConnectionHook.each(function (callback) {\n      if (socket._meteorSession)\n        callback(socket._meteorSession.connectionHandle);\n      return true;\n    });\n  },\n  /**\n   * Register a publish handler function.\n   *\n   * @param name {String} identifier for query\n   * @param handler {Function} publish handler\n   * @param options {Object}\n   *\n   * Server will call handler function on each new subscription,\n   * either when receiving DDP sub message for a named subscription, or on\n   * DDP connect for a universal subscription.\n   *\n   * If name is null, this will be a subscription that is\n   * automatically established and permanently on for all connected\n   * client, instead of a subscription that can be turned on and off\n   * with subscribe().\n   *\n   * options to contain:\n   *  - (mostly internal) is_auto: true if generated automatically\n   *    from an autopublish hook. this is for cosmetic purposes only\n   *    (it lets us determine whether to print a warning suggesting\n   *    that you turn off autopublish.)\n   */\n\n  /**\n   * @summary Publish a record set.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   * @locus Server\n   * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n   * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.\n   */\n  publish: function (name, handler, options) {\n    var self = this;\n\n    if (! _.isObject(name)) {\n      options = options || {};\n\n      if (name && name in self.publish_handlers) {\n        Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n        return;\n      }\n\n      if (Package.autopublish && !options.is_auto) {\n        // They have autopublish on, yet they're trying to manually\n        // picking stuff to publish. They probably should turn off\n        // autopublish. (This check isn't perfect -- if you create a\n        // publish before you turn on autopublish, it won't catch\n        // it. But this will definitely handle the simple case where\n        // you've added the autopublish package to your app, and are\n        // calling publish from your app code.)\n        if (!self.warned_about_autopublish) {\n          self.warned_about_autopublish = true;\n          Meteor._debug(\n    \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n    \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n    \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n    \"** will still be sent to all clients.\\n\" +\n    \"**\\n\" +\n    \"** Turn off autopublish by removing the autopublish package:\\n\" +\n    \"**\\n\" +\n    \"**   $ meteor remove autopublish\\n\" +\n    \"**\\n\" +\n    \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n    \"** for each collection that you want clients to see.\\n\");\n        }\n      }\n\n      if (name)\n        self.publish_handlers[name] = handler;\n      else {\n        self.universal_publish_handlers.push(handler);\n        // Spin up the new publisher on any existing session too. Run each\n        // session's subscription in a new Fiber, so that there's no change for\n        // self.sessions to change while we're running this loop.\n        self.sessions.forEach(function (session) {\n          if (!session._dontStartNewUniversalSubs) {\n            Fiber(function() {\n              session._startSubscription(handler);\n            }).run();\n          }\n        });\n      }\n    }\n    else{\n      _.each(name, function(value, key) {\n        self.publish(key, value, {});\n      });\n    }\n  },\n\n  _removeSession: function (session) {\n    var self = this;\n    self.sessions.delete(session.id);\n  },\n\n  /**\n   * @summary Defines functions that can be invoked over the network by clients.\n   * @locus Anywhere\n   * @param {Object} methods Dictionary whose keys are method names and values are functions.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  methods: function (methods) {\n    var self = this;\n    _.each(methods, function (func, name) {\n      if (typeof func !== 'function')\n        throw new Error(\"Method '\" + name + \"' must be a function\");\n      if (self.method_handlers[name])\n        throw new Error(\"A method named '\" + name + \"' is already defined\");\n      self.method_handlers[name] = func;\n    });\n  },\n\n  call: function (name, ...args) {\n    if (args.length && typeof args[args.length - 1] === \"function\") {\n      // If it's a function, the last argument is the result callback, not\n      // a parameter to the remote method.\n      var callback = args.pop();\n    }\n\n    return this.apply(name, args, callback);\n  },\n\n  // A version of the call method that always returns a Promise.\n  callAsync: function (name, ...args) {\n    return this.applyAsync(name, args);\n  },\n\n  apply: function (name, args, options, callback) {\n    // We were passed 3 arguments. They may be either (name, args, options)\n    // or (name, args, callback)\n    if (! callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    } else {\n      options = options || {};\n    }\n\n    const promise = this.applyAsync(name, args, options);\n\n    // Return the result in whichever way the caller asked for it. Note that we\n    // do NOT block on the write fence in an analogous way to how the client\n    // blocks on the relevant data being visible, so you are NOT guaranteed that\n    // cursor observe callbacks have fired when your callback is invoked. (We\n    // can change this if there's a real use case.)\n    if (callback) {\n      promise.then(\n        result => callback(undefined, result),\n        exception => callback(exception)\n      );\n    } else {\n      return promise.await();\n    }\n  },\n\n  // @param options {Optional Object}\n  applyAsync: function (name, args, options) {\n    // Run the handler\n    var handler = this.method_handlers[name];\n    if (! handler) {\n      return Promise.reject(\n        new Meteor.Error(404, `Method '${name}' not found`)\n      );\n    }\n\n    // If this is a method call from within another method or publish function,\n    // get the user state from the outer method or publish function, otherwise\n    // don't allow setUserId to be called\n    var userId = null;\n    var setUserId = function() {\n      throw new Error(\"Can't call setUserId on a server initiated method call\");\n    };\n    var connection = null;\n    var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n    var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n    var randomSeed = null;\n    if (currentMethodInvocation) {\n      userId = currentMethodInvocation.userId;\n      setUserId = function(userId) {\n        currentMethodInvocation.setUserId(userId);\n      };\n      connection = currentMethodInvocation.connection;\n      randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n    } else if (currentPublicationInvocation) {\n      userId = currentPublicationInvocation.userId;\n      setUserId = function(userId) {\n        currentPublicationInvocation._session._setUserId(userId);\n      };\n      connection = currentPublicationInvocation.connection;\n    }\n\n    var invocation = new DDPCommon.MethodInvocation({\n      isSimulation: false,\n      userId,\n      setUserId,\n      connection,\n      randomSeed\n    });\n\n    return new Promise(resolve => resolve(\n      DDP._CurrentMethodInvocation.withValue(\n        invocation,\n        () => maybeAuditArgumentChecks(\n          handler, invocation, EJSON.clone(args),\n          \"internal call to '\" + name + \"'\"\n        )\n      )\n    )).then(EJSON.clone);\n  },\n\n  _urlForSession: function (sessionId) {\n    var self = this;\n    var session = self.sessions.get(sessionId);\n    if (session)\n      return session._socketUrl;\n    else\n      return null;\n  }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n                                 serverSupportedVersions) {\n  var correctVersion = _.find(clientSupportedVersions, function (version) {\n    return _.contains(serverSupportedVersions, version);\n  });\n  if (!correctVersion) {\n    correctVersion = serverSupportedVersions[0];\n  }\n  return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n  if (!exception) return exception;\n\n  // To allow packages to throw errors intended for the client but not have to\n  // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n  // error before it is thrown.\n  if (exception.isClientSafe) {\n    if (!(exception instanceof Meteor.Error)) {\n      const originalMessage = exception.message;\n      exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n      exception.message = originalMessage;\n    }\n    return exception;\n  }\n\n  // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n  // the server log.\n  if (!exception._expectedByTest) {\n    Meteor._debug(\"Exception \" + context, exception.stack);\n    if (exception.sanitizedError) {\n      Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n      Meteor._debug();\n    }\n  }\n\n  // Did the error contain more details that could have been useful if caught in\n  // server code (or if thrown from non-client-originated code), but also\n  // provided a \"sanitized\" version with more context than 500 Internal server\n  // error? Use that.\n  if (exception.sanitizedError) {\n    if (exception.sanitizedError.isClientSafe)\n      return exception.sanitizedError;\n    Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n                  \"does not have isClientSafe property set; ignoring\");\n  }\n\n  return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n  args = args || [];\n  if (Package['audit-argument-checks']) {\n    return Match._failIfArgumentsAreNotAllChecked(\n      f, context, args, description);\n  }\n  return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n  var self = this;\n\n  self.armed = false;\n  self.fired = false;\n  self.retired = false;\n  self.outstanding_writes = 0;\n  self.before_fire_callbacks = [];\n  self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n  // Start tracking a write, and return an object to represent it. The\n  // object has a single method, committed(). This method should be\n  // called when the write is fully committed and propagated. You can\n  // continue to add writes to the WriteFence up until it is triggered\n  // (calls its callbacks because all writes have committed.)\n  beginWrite: function () {\n    var self = this;\n\n    if (self.retired)\n      return { committed: function () {} };\n\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to add writes\");\n\n    self.outstanding_writes++;\n    var committed = false;\n    return {\n      committed: function () {\n        if (committed)\n          throw new Error(\"committed called twice on the same write\");\n        committed = true;\n        self.outstanding_writes--;\n        self._maybeFire();\n      }\n    };\n  },\n\n  // Arm the fence. Once the fence is armed, and there are no more\n  // uncommitted writes, it will activate.\n  arm: function () {\n    var self = this;\n    if (self === DDPServer._CurrentWriteFence.get())\n      throw Error(\"Can't arm the current fence\");\n    self.armed = true;\n    self._maybeFire();\n  },\n\n  // Register a function to be called once before firing the fence.\n  // Callback function can add new writes to the fence, in which case\n  // it won't fire until those writes are done as well.\n  onBeforeFire: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.before_fire_callbacks.push(func);\n  },\n\n  // Register a function to be called when the fence fires.\n  onAllCommitted: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.completion_callbacks.push(func);\n  },\n\n  // Convenience function. Arms the fence, then blocks until it fires.\n  armAndWait: function () {\n    var self = this;\n    var future = new Future;\n    self.onAllCommitted(function () {\n      future['return']();\n    });\n    self.arm();\n    future.wait();\n  },\n\n  _maybeFire: function () {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"write fence already activated?\");\n    if (self.armed && !self.outstanding_writes) {\n      function invokeCallback (func) {\n        try {\n          func(self);\n        } catch (err) {\n          Meteor._debug(\"exception in write fence callback\", err);\n        }\n      }\n\n      self.outstanding_writes++;\n      while (self.before_fire_callbacks.length > 0) {\n        var callbacks = self.before_fire_callbacks;\n        self.before_fire_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n      self.outstanding_writes--;\n\n      if (!self.outstanding_writes) {\n        self.fired = true;\n        var callbacks = self.completion_callbacks;\n        self.completion_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n    }\n  },\n\n  // Deactivate this fence so that adding more writes has no effect.\n  // The fence must have already fired.\n  retire: function () {\n    var self = this;\n    if (! self.fired)\n      throw new Error(\"Can't retire a fence that hasn't fired.\");\n    self.retired = true;\n  }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n  var self = this;\n  options = options || {};\n\n  self.nextId = 1;\n  // map from collection name (string) -> listener id -> object. each object has\n  // keys 'trigger', 'callback'.  As a hack, the empty string means \"no\n  // collection\".\n  self.listenersByCollection = {};\n  self.listenersByCollectionCount = {};\n  self.factPackage = options.factPackage || \"livedata\";\n  self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n  // msg is a trigger or a notification\n  _collectionForMessage: function (msg) {\n    var self = this;\n    if (! _.has(msg, 'collection')) {\n      return '';\n    } else if (typeof(msg.collection) === 'string') {\n      if (msg.collection === '')\n        throw Error(\"Message has empty collection!\");\n      return msg.collection;\n    } else {\n      throw Error(\"Message has non-string collection!\");\n    }\n  },\n\n  // Listen for notification that match 'trigger'. A notification\n  // matches if it has the key-value pairs in trigger as a\n  // subset. When a notification matches, call 'callback', passing\n  // the actual notification.\n  //\n  // Returns a listen handle, which is an object with a method\n  // stop(). Call stop() to stop listening.\n  //\n  // XXX It should be legal to call fire() from inside a listen()\n  // callback?\n  listen: function (trigger, callback) {\n    var self = this;\n    var id = self.nextId++;\n\n    var collection = self._collectionForMessage(trigger);\n    var record = {trigger: EJSON.clone(trigger), callback: callback};\n    if (! _.has(self.listenersByCollection, collection)) {\n      self.listenersByCollection[collection] = {};\n      self.listenersByCollectionCount[collection] = 0;\n    }\n    self.listenersByCollection[collection][id] = record;\n    self.listenersByCollectionCount[collection]++;\n\n    if (self.factName && Package['facts-base']) {\n      Package['facts-base'].Facts.incrementServerFact(\n        self.factPackage, self.factName, 1);\n    }\n\n    return {\n      stop: function () {\n        if (self.factName && Package['facts-base']) {\n          Package['facts-base'].Facts.incrementServerFact(\n            self.factPackage, self.factName, -1);\n        }\n        delete self.listenersByCollection[collection][id];\n        self.listenersByCollectionCount[collection]--;\n        if (self.listenersByCollectionCount[collection] === 0) {\n          delete self.listenersByCollection[collection];\n          delete self.listenersByCollectionCount[collection];\n        }\n      }\n    };\n  },\n\n  // Fire the provided 'notification' (an object whose attribute\n  // values are all JSON-compatibile) -- inform all matching listeners\n  // (registered with listen()).\n  //\n  // If fire() is called inside a write fence, then each of the\n  // listener callbacks will be called inside the write fence as well.\n  //\n  // The listeners may be invoked in parallel, rather than serially.\n  fire: function (notification) {\n    var self = this;\n\n    var collection = self._collectionForMessage(notification);\n\n    if (! _.has(self.listenersByCollection, collection)) {\n      return;\n    }\n\n    var listenersForCollection = self.listenersByCollection[collection];\n    var callbackIds = [];\n    _.each(listenersForCollection, function (l, id) {\n      if (self._matches(notification, l.trigger)) {\n        callbackIds.push(id);\n      }\n    });\n\n    // Listener callbacks can yield, so we need to first find all the ones that\n    // match in a single iteration over self.listenersByCollection (which can't\n    // be mutated during this iteration), and then invoke the matching\n    // callbacks, checking before each call to ensure they haven't stopped.\n    // Note that we don't have to check that\n    // self.listenersByCollection[collection] still === listenersForCollection,\n    // because the only way that stops being true is if listenersForCollection\n    // first gets reduced down to the empty object (and then never gets\n    // increased again).\n    _.each(callbackIds, function (id) {\n      if (_.has(listenersForCollection, id)) {\n        listenersForCollection[id].callback(notification);\n      }\n    });\n  },\n\n  // A notification matches a trigger if all keys that exist in both are equal.\n  //\n  // Examples:\n  //  N:{collection: \"C\"} matches T:{collection: \"C\"}\n  //    (a non-targeted write to a collection matches a\n  //     non-targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n  //    (a targeted write to a collection matches a non-targeted query)\n  //  N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a non-targeted write to a collection matches a\n  //     targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a targeted write to a collection matches a targeted query targeted\n  //     at the same document)\n  //  N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n  //    (a targeted write to a collection does not match a targeted query\n  //     targeted at a different document)\n  _matches: function (notification, trigger) {\n    // Most notifications that use the crossbar have a string `collection` and\n    // maybe an `id` that is a string or ObjectID. We're already dividing up\n    // triggers by collection, but let's fast-track \"nope, different ID\" (and\n    // avoid the overly generic EJSON.equals). This makes a noticeable\n    // performance difference; see https://github.com/meteor/meteor/pull/3697\n    if (typeof(notification.id) === 'string' &&\n        typeof(trigger.id) === 'string' &&\n        notification.id !== trigger.id) {\n      return false;\n    }\n    if (notification.id instanceof MongoID.ObjectID &&\n        trigger.id instanceof MongoID.ObjectID &&\n        ! notification.id.equals(trigger.id)) {\n      return false;\n    }\n\n    return _.all(trigger, function (triggerValue, key) {\n      return !_.has(notification, key) ||\n        EJSON.equals(triggerValue, notification[key]);\n    });\n  }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n  factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n  __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n    process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n  DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n       function (name) {\n         Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n       });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","disable_cors","DISABLE_SOCKJS_CORS","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n  var extensions = [];\n\n  var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n    ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n  if (websocketCompressionConfig) {\n    extensions.push(Npm.require('permessage-deflate').configure(\n      websocketCompressionConfig\n    ));\n  }\n\n  return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n  var self = this;\n  self.registration_callbacks = [];\n  self.open_sockets = [];\n\n  // Because we are installing directly onto WebApp.httpServer instead of using\n  // WebApp.app, we have to process the path prefix ourselves.\n  self.prefix = pathPrefix + '/sockjs';\n  RoutePolicy.declare(self.prefix + '/', 'network');\n\n  // set up sockjs\n  var sockjs = Npm.require('sockjs');\n  var serverOptions = {\n    prefix: self.prefix,\n    log: function () { },\n    // this is the default, but we code it explicitly because we depend\n    // on it in stream_client:HEARTBEAT_TIMEOUT\n    heartbeat_delay: 45000,\n    // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n    // bound for that much time, SockJS might not notice that the user has\n    // reconnected because the timer (of disconnect_delay ms) can fire before\n    // SockJS processes the new connection. Eventually we'll fix this by not\n    // combining CPU-heavy processing with SockJS termination (eg a proxy which\n    // converts to Unix sockets) but for now, raise the delay.\n    disconnect_delay: 60 * 1000,\n    // Allow disabling of CORS requests to address\n    // https://github.com/meteor/meteor/issues/8317.\n    disable_cors: !!process.env.DISABLE_SOCKJS_CORS,\n    // Set the USE_JSESSIONID environment variable to enable setting the\n    // JSESSIONID cookie. This is useful for setting up proxies with\n    // session affinity.\n    jsessionid: !!process.env.USE_JSESSIONID\n  };\n\n  // If you know your server environment (eg, proxies) will prevent websockets\n  // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n  // browsers) will not waste time attempting to use them.\n  // (Your server will still have a /websocket endpoint.)\n  if (process.env.DISABLE_WEBSOCKETS) {\n    serverOptions.websocket = false;\n  } else {\n    serverOptions.faye_server_options = {\n      extensions: websocketExtensions()\n    };\n  }\n\n  self.server = sockjs.createServer(serverOptions);\n\n  // Install the sockjs handlers, but we want to keep around our own particular\n  // request handler that adjusts idle timeouts while we have an outstanding\n  // request.  This compensates for the fact that sockjs removes all listeners\n  // for \"request\" to add its own.\n  WebApp.httpServer.removeListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n  self.server.installHandlers(WebApp.httpServer);\n  WebApp.httpServer.addListener(\n    'request', WebApp._timeoutAdjustmentRequestCallback);\n\n  // Support the /websocket endpoint\n  self._redirectWebsocketEndpoint();\n\n  self.server.on('connection', function (socket) {\n    // We want to make sure that if a client connects to us and does the initial\n    // Websocket handshake but never gets to the DDP handshake, that we\n    // eventually kill the socket.  Once the DDP handshake happens, DDP\n    // heartbeating will work. And before the Websocket handshake, the timeouts\n    // we set at the server level in webapp_server.js will work. But\n    // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n    // is an \"in between\" state where this doesn't happen.  We work around this\n    // by explicitly setting the socket timeout to a relatively large time here,\n    // and setting it back to zero when we set up the heartbeat in\n    // livedata_server.js.\n    socket.setWebsocketTimeout = function (timeout) {\n      if ((socket.protocol === 'websocket' ||\n        socket.protocol === 'websocket-raw')\n        && socket._session.recv) {\n        socket._session.recv.connection.setTimeout(timeout);\n      }\n    };\n    socket.setWebsocketTimeout(45 * 1000);\n\n    socket.send = function (data) {\n      socket.write(data);\n    };\n    socket.on('close', function () {\n      self.open_sockets = _.without(self.open_sockets, socket);\n    });\n    self.open_sockets.push(socket);\n\n    // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n    // will force old clients to reload. Remove this once we're not\n    // concerned about people upgrading from a pre-0.7.0 release. Also,\n    // remove the clause in the client that ignores the welcome message\n    // (livedata_connection.js)\n    socket.send(JSON.stringify({ server_id: \"0\" }));\n\n    // call all our callbacks when we get a new socket. they will do the\n    // work of setting up handlers and such for specific messages.\n    _.each(self.registration_callbacks, function (callback) {\n      callback(socket);\n    });\n  });\n\n};\n\n_.extend(StreamServer.prototype, {\n  // call my callback when a new socket connects.\n  // also call it for all current connections.\n  register: function (callback) {\n    var self = this;\n    self.registration_callbacks.push(callback);\n    _.each(self.all_sockets(), function (socket) {\n      callback(socket);\n    });\n  },\n\n  // get a list of all sockets\n  all_sockets: function () {\n    var self = this;\n    return _.values(self.open_sockets);\n  },\n\n  // Redirect /websocket to /sockjs/websocket in order to not expose\n  // sockjs to clients that want to use raw websockets\n  _redirectWebsocketEndpoint: function () {\n    var self = this;\n    // Unfortunately we can't use a connect middleware here since\n    // sockjs installs itself prior to all existing listeners\n    // (meaning prior to any connect middlewares) so we need to take\n    // an approach similar to overshadowListeners in\n    // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n    _.each(['request', 'upgrade'], function (event) {\n      var httpServer = WebApp.httpServer;\n      var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n      httpServer.removeAllListeners(event);\n\n      // request and upgrade have different arguments passed but\n      // we only care about the first one which is always request\n      var newListener = function (request /*, moreArguments */) {\n        // Store arguments for use within the closure below\n        var args = arguments;\n\n        // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n        // preserving query string.\n        var parsedUrl = url.parse(request.url);\n        if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n          parsedUrl.pathname === pathPrefix + '/websocket/') {\n          parsedUrl.pathname = self.prefix + '/websocket';\n          request.url = url.format(parsedUrl);\n        }\n        _.each(oldHttpServerListeners, function (oldListener) {\n          oldListener.apply(httpServer, args);\n        });\n      };\n      httpServer.addListener(event, newListener);\n    });\n  }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n  var self = this;\n  self.existsIn = new Set(); // set of subscriptionHandle\n  self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n  getFields: function () {\n    var self = this;\n    var ret = {};\n    self.dataByKey.forEach(function (precedenceList, key) {\n      ret[key] = precedenceList[0].value;\n    });\n    return ret;\n  },\n\n  clearField: function (subscriptionHandle, key, changeCollector) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n    var precedenceList = self.dataByKey.get(key);\n\n    // It's okay to clear fields that didn't exist. No need to throw\n    // an error.\n    if (!precedenceList)\n      return;\n\n    var removedValue = undefined;\n    for (var i = 0; i < precedenceList.length; i++) {\n      var precedence = precedenceList[i];\n      if (precedence.subscriptionHandle === subscriptionHandle) {\n        // The view's value can only change if this subscription is the one that\n        // used to have precedence.\n        if (i === 0)\n          removedValue = precedence.value;\n        precedenceList.splice(i, 1);\n        break;\n      }\n    }\n    if (precedenceList.length === 0) {\n      self.dataByKey.delete(key);\n      changeCollector[key] = undefined;\n    } else if (removedValue !== undefined &&\n               !EJSON.equals(removedValue, precedenceList[0].value)) {\n      changeCollector[key] = precedenceList[0].value;\n    }\n  },\n\n  changeField: function (subscriptionHandle, key, value,\n                         changeCollector, isAdd) {\n    var self = this;\n    // Publish API ignores _id if present in fields\n    if (key === \"_id\")\n      return;\n\n    // Don't share state with the data passed in by the user.\n    value = EJSON.clone(value);\n\n    if (!self.dataByKey.has(key)) {\n      self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n                                value: value}]);\n      changeCollector[key] = value;\n      return;\n    }\n    var precedenceList = self.dataByKey.get(key);\n    var elt;\n    if (!isAdd) {\n      elt = precedenceList.find(function (precedence) {\n          return precedence.subscriptionHandle === subscriptionHandle;\n      });\n    }\n\n    if (elt) {\n      if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n        // this subscription is changing the value of this field.\n        changeCollector[key] = value;\n      }\n      elt.value = value;\n    } else {\n      // this subscription is newly caring about this field\n      precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n    }\n\n  }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.<String, Function>} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n  var self = this;\n  self.collectionName = collectionName;\n  self.documents = new Map();\n  self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n  isEmpty: function () {\n    var self = this;\n    return self.documents.size === 0;\n  },\n\n  diff: function (previous) {\n    var self = this;\n    DiffSequence.diffMaps(previous.documents, self.documents, {\n      both: _.bind(self.diffDocument, self),\n\n      rightOnly: function (id, nowDV) {\n        self.callbacks.added(self.collectionName, id, nowDV.getFields());\n      },\n\n      leftOnly: function (id, prevDV) {\n        self.callbacks.removed(self.collectionName, id);\n      }\n    });\n  },\n\n  diffDocument: function (id, prevDV, nowDV) {\n    var self = this;\n    var fields = {};\n    DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n      both: function (key, prev, now) {\n        if (!EJSON.equals(prev, now))\n          fields[key] = now;\n      },\n      rightOnly: function (key, now) {\n        fields[key] = now;\n      },\n      leftOnly: function(key, prev) {\n        fields[key] = undefined;\n      }\n    });\n    self.callbacks.changed(self.collectionName, id, fields);\n  },\n\n  added: function (subscriptionHandle, id, fields) {\n    var self = this;\n    var docView = self.documents.get(id);\n    var added = false;\n    if (!docView) {\n      added = true;\n      docView = new SessionDocumentView();\n      self.documents.set(id, docView);\n    }\n    docView.existsIn.add(subscriptionHandle);\n    var changeCollector = {};\n    _.each(fields, function (value, key) {\n      docView.changeField(\n        subscriptionHandle, key, value, changeCollector, true);\n    });\n    if (added)\n      self.callbacks.added(self.collectionName, id, changeCollector);\n    else\n      self.callbacks.changed(self.collectionName, id, changeCollector);\n  },\n\n  changed: function (subscriptionHandle, id, changed) {\n    var self = this;\n    var changedResult = {};\n    var docView = self.documents.get(id);\n    if (!docView)\n      throw new Error(\"Could not find element with id \" + id + \" to change\");\n    _.each(changed, function (value, key) {\n      if (value === undefined)\n        docView.clearField(subscriptionHandle, key, changedResult);\n      else\n        docView.changeField(subscriptionHandle, key, value, changedResult);\n    });\n    self.callbacks.changed(self.collectionName, id, changedResult);\n  },\n\n  removed: function (subscriptionHandle, id) {\n    var self = this;\n    var docView = self.documents.get(id);\n    if (!docView) {\n      var err = new Error(\"Removed nonexistent document \" + id);\n      throw err;\n    }\n    docView.existsIn.delete(subscriptionHandle);\n    if (docView.existsIn.size === 0) {\n      // it is gone from everyone\n      self.callbacks.removed(self.collectionName, id);\n      self.documents.delete(id);\n    } else {\n      var changed = {};\n      // remove this subscription from every precedence list\n      // and record the changes\n      docView.dataByKey.forEach(function (precedenceList, key) {\n        docView.clearField(subscriptionHandle, key, changed);\n      });\n\n      self.callbacks.changed(self.collectionName, id, changed);\n    }\n  }\n});\n\n/******************************************************************************/\n/* Session                                                                    */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n  var self = this;\n  self.id = Random.id();\n\n  self.server = server;\n  self.version = version;\n\n  self.initialized = false;\n  self.socket = socket;\n\n  // set to null when the session is destroyed. multiple places below\n  // use this to determine if the session is alive or not.\n  self.inQueue = new Meteor._DoubleEndedQueue();\n\n  self.blocked = false;\n  self.workerRunning = false;\n\n  // Sub objects for active subscriptions\n  self._namedSubs = new Map();\n  self._universalSubs = [];\n\n  self.userId = null;\n\n  self.collectionViews = new Map();\n\n  // Set this to false to not send messages when collectionViews are\n  // modified. This is done when rerunning subs in _setUserId and those messages\n  // are calculated via a diff instead.\n  self._isSending = true;\n\n  // If this is true, don't start a newly-created universal publisher on this\n  // session. The session will take care of starting it when appropriate.\n  self._dontStartNewUniversalSubs = false;\n\n  // when we are rerunning subscriptions, any ready messages\n  // we want to buffer up for when we are done rerunning subscriptions\n  self._pendingReady = [];\n\n  // List of callbacks to call when this connection is closed.\n  self._closeCallbacks = [];\n\n\n  // XXX HACK: If a sockjs connection, save off the URL. This is\n  // temporary and will go away in the near future.\n  self._socketUrl = socket.url;\n\n  // Allow tests to disable responding to pings.\n  self._respondToPings = options.respondToPings;\n\n  // This object is the public interface to the session. In the public\n  // API, it is called the `connection` object.  Internally we call it\n  // a `connectionHandle` to avoid ambiguity.\n  self.connectionHandle = {\n    id: self.id,\n    close: function () {\n      self.close();\n    },\n    onClose: function (fn) {\n      var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n      if (self.inQueue) {\n        self._closeCallbacks.push(cb);\n      } else {\n        // if we're already closed, call the callback.\n        Meteor.defer(cb);\n      }\n    },\n    clientAddress: self._clientAddress(),\n    httpHeaders: self.socket.headers\n  };\n\n  self.send({ msg: 'connected', session: self.id });\n\n  // On initial connect, spin up all the universal publishers.\n  Fiber(function () {\n    self.startUniversalSubs();\n  }).run();\n\n  if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n    // We no longer need the low level timeout because we have heartbeating.\n    socket.setWebsocketTimeout(0);\n\n    self.heartbeat = new DDPCommon.Heartbeat({\n      heartbeatInterval: options.heartbeatInterval,\n      heartbeatTimeout: options.heartbeatTimeout,\n      onTimeout: function () {\n        self.close();\n      },\n      sendPing: function () {\n        self.send({msg: 'ping'});\n      }\n    });\n    self.heartbeat.start();\n  }\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n  sendReady: function (subscriptionIds) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"ready\", subs: subscriptionIds});\n    else {\n      _.each(subscriptionIds, function (subscriptionId) {\n        self._pendingReady.push(subscriptionId);\n      });\n    }\n  },\n\n  sendAdded: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n  },\n\n  sendChanged: function (collectionName, id, fields) {\n    var self = this;\n    if (_.isEmpty(fields))\n      return;\n\n    if (self._isSending) {\n      self.send({\n        msg: \"changed\",\n        collection: collectionName,\n        id: id,\n        fields: fields\n      });\n    }\n  },\n\n  sendRemoved: function (collectionName, id) {\n    var self = this;\n    if (self._isSending)\n      self.send({msg: \"removed\", collection: collectionName, id: id});\n  },\n\n  getSendCallbacks: function () {\n    var self = this;\n    return {\n      added: _.bind(self.sendAdded, self),\n      changed: _.bind(self.sendChanged, self),\n      removed: _.bind(self.sendRemoved, self)\n    };\n  },\n\n  getCollectionView: function (collectionName) {\n    var self = this;\n    var ret = self.collectionViews.get(collectionName);\n    if (!ret) {\n      ret = new SessionCollectionView(collectionName,\n                                        self.getSendCallbacks());\n      self.collectionViews.set(collectionName, ret);\n    }\n    return ret;\n  },\n\n  added: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.added(subscriptionHandle, id, fields);\n  },\n\n  removed: function (subscriptionHandle, collectionName, id) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.removed(subscriptionHandle, id);\n    if (view.isEmpty()) {\n       self.collectionViews.delete(collectionName);\n    }\n  },\n\n  changed: function (subscriptionHandle, collectionName, id, fields) {\n    var self = this;\n    var view = self.getCollectionView(collectionName);\n    view.changed(subscriptionHandle, id, fields);\n  },\n\n  startUniversalSubs: function () {\n    var self = this;\n    // Make a shallow copy of the set of universal handlers and start them. If\n    // additional universal publishers start while we're running them (due to\n    // yielding), they will run separately as part of Server.publish.\n    var handlers = _.clone(self.server.universal_publish_handlers);\n    _.each(handlers, function (handler) {\n      self._startSubscription(handler);\n    });\n  },\n\n  // Destroy this session and unregister it at the server.\n  close: function () {\n    var self = this;\n\n    // Destroy this session, even if it's not registered at the\n    // server. Stop all processing and tear everything down. If a socket\n    // was attached, close it.\n\n    // Already destroyed.\n    if (! self.inQueue)\n      return;\n\n    // Drop the merge box data immediately.\n    self.inQueue = null;\n    self.collectionViews = new Map();\n\n    if (self.heartbeat) {\n      self.heartbeat.stop();\n      self.heartbeat = null;\n    }\n\n    if (self.socket) {\n      self.socket.close();\n      self.socket._meteorSession = null;\n    }\n\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"sessions\", -1);\n\n    Meteor.defer(function () {\n      // stop callbacks can yield, so we defer this on close.\n      // sub._isDeactivated() detects that we set inQueue to null and\n      // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n      self._deactivateAllSubscriptions();\n\n      // Defer calling the close callbacks, so that the caller closing\n      // the session isn't waiting for all the callbacks to complete.\n      _.each(self._closeCallbacks, function (callback) {\n        callback();\n      });\n    });\n\n    // Unregister the session.\n    self.server._removeSession(self);\n  },\n\n  // Send a message (doing nothing if no socket is connected right now.)\n  // It should be a JSON object (it will be stringified.)\n  send: function (msg) {\n    var self = this;\n    if (self.socket) {\n      if (Meteor._printSentDDP)\n        Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n      self.socket.send(DDPCommon.stringifyDDP(msg));\n    }\n  },\n\n  // Send a connection error.\n  sendError: function (reason, offendingMessage) {\n    var self = this;\n    var msg = {msg: 'error', reason: reason};\n    if (offendingMessage)\n      msg.offendingMessage = offendingMessage;\n    self.send(msg);\n  },\n\n  // Process 'msg' as an incoming message. (But as a guard against\n  // race conditions during reconnection, ignore the message if\n  // 'socket' is not the currently connected socket.)\n  //\n  // We run the messages from the client one at a time, in the order\n  // given by the client. The message handler is passed an idempotent\n  // function 'unblock' which it may call to allow other messages to\n  // begin running in parallel in another fiber (for example, a method\n  // that wants to yield.) Otherwise, it is automatically unblocked\n  // when it returns.\n  //\n  // Actually, we don't have to 'totally order' the messages in this\n  // way, but it's the easiest thing that's correct. (unsub needs to\n  // be ordered against sub, methods need to be ordered against each\n  // other.)\n  processMessage: function (msg_in) {\n    var self = this;\n    if (!self.inQueue) // we have been destroyed.\n      return;\n\n    // Respond to ping and pong messages immediately without queuing.\n    // If the negotiated DDP version is \"pre1\" which didn't support\n    // pings, preserve the \"pre1\" behavior of responding with a \"bad\n    // request\" for the unknown messages.\n    //\n    // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n    // needs a Fiber. We could actually use regular setTimeout and avoid\n    // these new fibers, but it is easier to just make everything use\n    // Meteor.setTimeout and not think too hard.\n    //\n    // Any message counts as receiving a pong, as it demonstrates that\n    // the client is still alive.\n    if (self.heartbeat) {\n      Fiber(function () {\n        self.heartbeat.messageReceived();\n      }).run();\n    }\n\n    if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n      if (self._respondToPings)\n        self.send({msg: \"pong\", id: msg_in.id});\n      return;\n    }\n    if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n      // Since everything is a pong, nothing to do\n      return;\n    }\n\n    self.inQueue.push(msg_in);\n    if (self.workerRunning)\n      return;\n    self.workerRunning = true;\n\n    var processNext = function () {\n      var msg = self.inQueue && self.inQueue.shift();\n      if (!msg) {\n        self.workerRunning = false;\n        return;\n      }\n\n      Fiber(function () {\n        var blocked = true;\n\n        var unblock = function () {\n          if (!blocked)\n            return; // idempotent\n          blocked = false;\n          processNext();\n        };\n\n        self.server.onMessageHook.each(function (callback) {\n          callback(msg, self);\n          return true;\n        });\n\n        if (_.has(self.protocol_handlers, msg.msg))\n          self.protocol_handlers[msg.msg].call(self, msg, unblock);\n        else\n          self.sendError('Bad request', msg);\n        unblock(); // in case the handler didn't already do it\n      }).run();\n    };\n\n    processNext();\n  },\n\n  protocol_handlers: {\n    sub: function (msg) {\n      var self = this;\n\n      // reject malformed messages\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.name) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array))) {\n        self.sendError(\"Malformed subscription\", msg);\n        return;\n      }\n\n      if (!self.server.publish_handlers[msg.name]) {\n        self.send({\n          msg: 'nosub', id: msg.id,\n          error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n        return;\n      }\n\n      if (self._namedSubs.has(msg.id))\n        // subs are idempotent, or rather, they are ignored if a sub\n        // with that id already exists. this is important during\n        // reconnect.\n        return;\n\n      // XXX It'd be much better if we had generic hooks where any package can\n      // hook into subscription handling, but in the mean while we special case\n      // ddp-rate-limiter package. This is also done for weak requirements to\n      // add the ddp-rate-limiter package in case we don't have Accounts. A\n      // user trying to use the ddp-rate-limiter must explicitly require it.\n      if (Package['ddp-rate-limiter']) {\n        var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n        var rateLimiterInput = {\n          userId: self.userId,\n          clientAddress: self.connectionHandle.clientAddress,\n          type: \"subscription\",\n          name: msg.name,\n          connectionId: self.id\n        };\n\n        DDPRateLimiter._increment(rateLimiterInput);\n        var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n        if (!rateLimitResult.allowed) {\n          self.send({\n            msg: 'nosub', id: msg.id,\n            error: new Meteor.Error(\n              'too-many-requests',\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset})\n          });\n          return;\n        }\n      }\n\n      var handler = self.server.publish_handlers[msg.name];\n\n      self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n    },\n\n    unsub: function (msg) {\n      var self = this;\n\n      self._stopSubscription(msg.id);\n    },\n\n    method: function (msg, unblock) {\n      var self = this;\n\n      // reject malformed messages\n      // For now, we silently ignore unknown attributes,\n      // for forwards compatibility.\n      if (typeof (msg.id) !== \"string\" ||\n          typeof (msg.method) !== \"string\" ||\n          (('params' in msg) && !(msg.params instanceof Array)) ||\n          (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n        self.sendError(\"Malformed method invocation\", msg);\n        return;\n      }\n\n      var randomSeed = msg.randomSeed || null;\n\n      // set up to mark the method as satisfied once all observers\n      // (and subscriptions) have reacted to any writes that were\n      // done.\n      var fence = new DDPServer._WriteFence;\n      fence.onAllCommitted(function () {\n        // Retire the fence so that future writes are allowed.\n        // This means that callbacks like timers are free to use\n        // the fence, and if they fire before it's armed (for\n        // example, because the method waits for them) their\n        // writes will be included in the fence.\n        fence.retire();\n        self.send({\n          msg: 'updated', methods: [msg.id]});\n      });\n\n      // find the handler\n      var handler = self.server.method_handlers[msg.method];\n      if (!handler) {\n        self.send({\n          msg: 'result', id: msg.id,\n          error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n        fence.arm();\n        return;\n      }\n\n      var setUserId = function(userId) {\n        self._setUserId(userId);\n      };\n\n      var invocation = new DDPCommon.MethodInvocation({\n        isSimulation: false,\n        userId: self.userId,\n        setUserId: setUserId,\n        unblock: unblock,\n        connection: self.connectionHandle,\n        randomSeed: randomSeed\n      });\n\n      const promise = new Promise((resolve, reject) => {\n        // XXX It'd be better if we could hook into method handlers better but\n        // for now, we need to check if the ddp-rate-limiter exists since we\n        // have a weak requirement for the ddp-rate-limiter package to be added\n        // to our application.\n        if (Package['ddp-rate-limiter']) {\n          var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n          var rateLimiterInput = {\n            userId: self.userId,\n            clientAddress: self.connectionHandle.clientAddress,\n            type: \"method\",\n            name: msg.method,\n            connectionId: self.id\n          };\n          DDPRateLimiter._increment(rateLimiterInput);\n          var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n          if (!rateLimitResult.allowed) {\n            reject(new Meteor.Error(\n              \"too-many-requests\",\n              DDPRateLimiter.getErrorMessage(rateLimitResult),\n              {timeToReset: rateLimitResult.timeToReset}\n            ));\n            return;\n          }\n        }\n\n        resolve(DDPServer._CurrentWriteFence.withValue(\n          fence,\n          () => DDP._CurrentMethodInvocation.withValue(\n            invocation,\n            () => maybeAuditArgumentChecks(\n              handler, invocation, msg.params,\n              \"call to '\" + msg.method + \"'\"\n            )\n          )\n        ));\n      });\n\n      function finish() {\n        fence.arm();\n        unblock();\n      }\n\n      const payload = {\n        msg: \"result\",\n        id: msg.id\n      };\n\n      promise.then((result) => {\n        finish();\n        if (result !== undefined) {\n          payload.result = result;\n        }\n        self.send(payload);\n      }, (exception) => {\n        finish();\n        payload.error = wrapInternalException(\n          exception,\n          `while invoking method '${msg.method}'`\n        );\n        self.send(payload);\n      });\n    }\n  },\n\n  _eachSub: function (f) {\n    var self = this;\n    self._namedSubs.forEach(f);\n    self._universalSubs.forEach(f);\n  },\n\n  _diffCollectionViews: function (beforeCVs) {\n    var self = this;\n    DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n      both: function (collectionName, leftValue, rightValue) {\n        rightValue.diff(leftValue);\n      },\n      rightOnly: function (collectionName, rightValue) {\n        rightValue.documents.forEach(function (docView, id) {\n          self.sendAdded(collectionName, id, docView.getFields());\n        });\n      },\n      leftOnly: function (collectionName, leftValue) {\n        leftValue.documents.forEach(function (doc, id) {\n          self.sendRemoved(collectionName, id);\n        });\n      }\n    });\n  },\n\n  // Sets the current user id in all appropriate contexts and reruns\n  // all subscriptions\n  _setUserId: function(userId) {\n    var self = this;\n\n    if (userId !== null && typeof userId !== \"string\")\n      throw new Error(\"setUserId must be called on string or null, not \" +\n                      typeof userId);\n\n    // Prevent newly-created universal subscriptions from being added to our\n    // session; they will be found below when we call startUniversalSubs.\n    //\n    // (We don't have to worry about named subscriptions, because we only add\n    // them when we process a 'sub' message. We are currently processing a\n    // 'method' message, and the method did not unblock, because it is illegal\n    // to call setUserId after unblock. Thus we cannot be concurrently adding a\n    // new named subscription.)\n    self._dontStartNewUniversalSubs = true;\n\n    // Prevent current subs from updating our collectionViews and call their\n    // stop callbacks. This may yield.\n    self._eachSub(function (sub) {\n      sub._deactivate();\n    });\n\n    // All subs should now be deactivated. Stop sending messages to the client,\n    // save the state of the published collections, reset to an empty view, and\n    // update the userId.\n    self._isSending = false;\n    var beforeCVs = self.collectionViews;\n    self.collectionViews = new Map();\n    self.userId = userId;\n\n    // _setUserId is normally called from a Meteor method with\n    // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n    // expected to be set inside a publish function, so we temporary unset it.\n    // Inside a publish function DDP._CurrentPublicationInvocation is set.\n    DDP._CurrentMethodInvocation.withValue(undefined, function () {\n      // Save the old named subs, and reset to having no subscriptions.\n      var oldNamedSubs = self._namedSubs;\n      self._namedSubs = new Map();\n      self._universalSubs = [];\n\n      oldNamedSubs.forEach(function (sub, subscriptionId) {\n        var newSub = sub._recreate();\n        self._namedSubs.set(subscriptionId, newSub);\n        // nb: if the handler throws or calls this.error(), it will in fact\n        // immediately send its 'nosub'. This is OK, though.\n        newSub._runHandler();\n      });\n\n      // Allow newly-created universal subs to be started on our connection in\n      // parallel with the ones we're spinning up here, and spin up universal\n      // subs.\n      self._dontStartNewUniversalSubs = false;\n      self.startUniversalSubs();\n    });\n\n    // Start sending messages again, beginning with the diff from the previous\n    // state of the world to the current state. No yields are allowed during\n    // this diff, so that other changes cannot interleave.\n    Meteor._noYieldsAllowed(function () {\n      self._isSending = true;\n      self._diffCollectionViews(beforeCVs);\n      if (!_.isEmpty(self._pendingReady)) {\n        self.sendReady(self._pendingReady);\n        self._pendingReady = [];\n      }\n    });\n  },\n\n  _startSubscription: function (handler, subId, params, name) {\n    var self = this;\n\n    var sub = new Subscription(\n      self, handler, subId, params, name);\n    if (subId)\n      self._namedSubs.set(subId, sub);\n    else\n      self._universalSubs.push(sub);\n\n    sub._runHandler();\n  },\n\n  // tear down specified subscription\n  _stopSubscription: function (subId, error) {\n    var self = this;\n\n    var subName = null;\n    if (subId) {\n      var maybeSub = self._namedSubs.get(subId);\n      if (maybeSub) {\n        subName = maybeSub._name;\n        maybeSub._removeAllDocuments();\n        maybeSub._deactivate();\n        self._namedSubs.delete(subId);\n      }\n    }\n\n    var response = {msg: 'nosub', id: subId};\n\n    if (error) {\n      response.error = wrapInternalException(\n        error,\n        subName ? (\"from sub \" + subName + \" id \" + subId)\n          : (\"from sub id \" + subId));\n    }\n\n    self.send(response);\n  },\n\n  // tear down all subscriptions. Note that this does NOT send removed or nosub\n  // messages, since we assume the client is gone.\n  _deactivateAllSubscriptions: function () {\n    var self = this;\n\n    self._namedSubs.forEach(function (sub, id) {\n      sub._deactivate();\n    });\n    self._namedSubs = new Map();\n\n    self._universalSubs.forEach(function (sub) {\n      sub._deactivate();\n    });\n    self._universalSubs = [];\n  },\n\n  // Determine the remote client's IP address, based on the\n  // HTTP_FORWARDED_COUNT environment variable representing how many\n  // proxies the server is behind.\n  _clientAddress: function () {\n    var self = this;\n\n    // For the reported client address for a connection to be correct,\n    // the developer must set the HTTP_FORWARDED_COUNT environment\n    // variable to an integer representing the number of hops they\n    // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n    // server is behind one proxy.\n    //\n    // This could be computed once at startup instead of every time.\n    var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n    if (httpForwardedCount === 0)\n      return self.socket.remoteAddress;\n\n    var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n    if (! _.isString(forwardedFor))\n      return null;\n    forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n    // Typically the first value in the `x-forwarded-for` header is\n    // the original IP address of the client connecting to the first\n    // proxy.  However, the end user can easily spoof the header, in\n    // which case the first value(s) will be the fake IP address from\n    // the user pretending to be a proxy reporting the original IP\n    // address value.  By counting HTTP_FORWARDED_COUNT back from the\n    // end of the list, we ensure that we get the IP address being\n    // reported by *our* first proxy.\n\n    if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n      return null;\n\n    return forwardedFor[forwardedFor.length - httpForwardedCount];\n  }\n});\n\n/******************************************************************************/\n/* Subscription                                                               */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n    session, handler, subscriptionId, params, name) {\n  var self = this;\n  self._session = session; // type is Session\n\n  /**\n   * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n   * @locus Server\n   * @name  connection\n   * @memberOf Subscription\n   * @instance\n   */\n  self.connection = session.connectionHandle; // public API object\n\n  self._handler = handler;\n\n  // my subscription ID (generated by client, undefined for universal subs).\n  self._subscriptionId = subscriptionId;\n  // undefined for universal subs\n  self._name = name;\n\n  self._params = params || [];\n\n  // Only named subscriptions have IDs, but we need some sort of string\n  // internally to keep track of all subscriptions inside\n  // SessionDocumentViews. We use this subscriptionHandle for that.\n  if (self._subscriptionId) {\n    self._subscriptionHandle = 'N' + self._subscriptionId;\n  } else {\n    self._subscriptionHandle = 'U' + Random.id();\n  }\n\n  // has _deactivate been called?\n  self._deactivated = false;\n\n  // stop callbacks to g/c this sub.  called w/ zero arguments.\n  self._stopCallbacks = [];\n\n  // the set of (collection, documentid) that this subscription has\n  // an opinion about\n  self._documents = new Map();\n\n  // remember if we are ready.\n  self._ready = false;\n\n  // Part of the public API: the user of this sub.\n\n  /**\n   * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n   * @locus Server\n   * @memberOf Subscription\n   * @name  userId\n   * @instance\n   */\n  self.userId = session.userId;\n\n  // For now, the id filter is going to default to\n  // the to/from DDP methods on MongoID, to\n  // specifically deal with mongo/minimongo ObjectIds.\n\n  // Later, you will be able to make this be \"raw\"\n  // if you want to publish a collection that you know\n  // just has strings for keys and no funny business, to\n  // a ddp consumer that isn't minimongo\n\n  self._idFilter = {\n    idStringify: MongoID.idStringify,\n    idParse: MongoID.idParse\n  };\n\n  Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n    \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n  _runHandler: function () {\n    // XXX should we unblock() here? Either before running the publish\n    // function, or before running _publishCursor.\n    //\n    // Right now, each publish function blocks all future publishes and\n    // methods waiting on data from Mongo (or whatever else the function\n    // blocks on). This probably slows page load in common cases.\n\n    var self = this;\n    try {\n      var res = DDP._CurrentPublicationInvocation.withValue(\n        self,\n        () => maybeAuditArgumentChecks(\n          self._handler, self, EJSON.clone(self._params),\n          // It's OK that this would look weird for universal subscriptions,\n          // because they have no arguments so there can never be an\n          // audit-argument-checks failure.\n          \"publisher '\" + self._name + \"'\"\n        )\n      );\n    } catch (e) {\n      self.error(e);\n      return;\n    }\n\n    // Did the handler call this.error or this.stop?\n    if (self._isDeactivated())\n      return;\n\n    self._publishHandlerResult(res);\n  },\n\n  _publishHandlerResult: function (res) {\n    // SPECIAL CASE: Instead of writing their own callbacks that invoke\n    // this.added/changed/ready/etc, the user can just return a collection\n    // cursor or array of cursors from the publish function; we call their\n    // _publishCursor method which starts observing the cursor and publishes the\n    // results. Note that _publishCursor does NOT call ready().\n    //\n    // XXX This uses an undocumented interface which only the Mongo cursor\n    // interface publishes. Should we make this interface public and encourage\n    // users to implement it themselves? Arguably, it's unnecessary; users can\n    // already write their own functions like\n    //   var publishMyReactiveThingy = function (name, handler) {\n    //     Meteor.publish(name, function () {\n    //       var reactiveThingy = handler();\n    //       reactiveThingy.publishMe();\n    //     });\n    //   };\n\n    var self = this;\n    var isCursor = function (c) {\n      return c && c._publishCursor;\n    };\n    if (isCursor(res)) {\n      try {\n        res._publishCursor(self);\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      // _publishCursor only returns after the initial added callbacks have run.\n      // mark subscription as ready.\n      self.ready();\n    } else if (_.isArray(res)) {\n      // check all the elements are cursors\n      if (! _.all(res, isCursor)) {\n        self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n        return;\n      }\n      // find duplicate collection names\n      // XXX we should support overlapping cursors, but that would require the\n      // merge box to allow overlap within a subscription\n      var collectionNames = {};\n      for (var i = 0; i < res.length; ++i) {\n        var collectionName = res[i]._getCollectionName();\n        if (_.has(collectionNames, collectionName)) {\n          self.error(new Error(\n            \"Publish function returned multiple cursors for collection \" +\n              collectionName));\n          return;\n        }\n        collectionNames[collectionName] = true;\n      };\n\n      try {\n        _.each(res, function (cur) {\n          cur._publishCursor(self);\n        });\n      } catch (e) {\n        self.error(e);\n        return;\n      }\n      self.ready();\n    } else if (res) {\n      // truthy values other than cursors or arrays are probably a\n      // user mistake (possible returning a Mongo document via, say,\n      // `coll.findOne()`).\n      self.error(new Error(\"Publish function can only return a Cursor or \"\n                           + \"an array of Cursors\"));\n    }\n  },\n\n  // This calls all stop callbacks and prevents the handler from updating any\n  // SessionCollectionViews further. It's used when the user unsubscribes or\n  // disconnects, as well as during setUserId re-runs. It does *NOT* send\n  // removed messages for the published objects; if that is necessary, call\n  // _removeAllDocuments first.\n  _deactivate: function() {\n    var self = this;\n    if (self._deactivated)\n      return;\n    self._deactivated = true;\n    self._callStopCallbacks();\n    Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n      \"livedata\", \"subscriptions\", -1);\n  },\n\n  _callStopCallbacks: function () {\n    var self = this;\n    // tell listeners, so they can clean up\n    var callbacks = self._stopCallbacks;\n    self._stopCallbacks = [];\n    _.each(callbacks, function (callback) {\n      callback();\n    });\n  },\n\n  // Send remove messages for every document.\n  _removeAllDocuments: function () {\n    var self = this;\n    Meteor._noYieldsAllowed(function () {\n      self._documents.forEach(function (collectionDocs, collectionName) {\n        collectionDocs.forEach(function (strId) {\n          self.removed(collectionName, self._idFilter.idParse(strId));\n        });\n      });\n    });\n  },\n\n  // Returns a new Subscription for the same session with the same\n  // initial creation parameters. This isn't a clone: it doesn't have\n  // the same _documents cache, stopped state or callbacks; may have a\n  // different _subscriptionHandle, and gets its userId from the\n  // session, not from this object.\n  _recreate: function () {\n    var self = this;\n    return new Subscription(\n      self._session, self._handler, self._subscriptionId, self._params,\n      self._name);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n   * @locus Server\n   * @param {Error} error The error to pass to the client.\n   * @instance\n   * @memberOf Subscription\n   */\n  error: function (error) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId, error);\n  },\n\n  // Note that while our DDP client will notice that you've called stop() on the\n  // server (and clean up its _subscriptions table) we don't actually provide a\n  // mechanism for an app to notice this (the subscribe onError callback only\n  // triggers if there is an error).\n\n  /**\n   * @summary Call inside the publish function.  Stops this client's subscription and invokes the client's `onStop` callback with no error.\n   * @locus Server\n   * @instance\n   * @memberOf Subscription\n   */\n  stop: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    self._session._stopSubscription(self._subscriptionId);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Registers a callback function to run when the subscription is stopped.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {Function} func The callback function\n   */\n  onStop: function (callback) {\n    var self = this;\n    callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n    if (self._isDeactivated())\n      callback();\n    else\n      self._stopCallbacks.push(callback);\n  },\n\n  // This returns true if the sub has been deactivated, *OR* if the session was\n  // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n  // happened yet.\n  _isDeactivated: function () {\n    var self = this;\n    return self._deactivated || self._session.inQueue === null;\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been added to the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the new document.\n   * @param {String} id The new document's ID.\n   * @param {Object} fields The fields in the new document.  If `_id` is present it is ignored.\n   */\n  added: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    let ids = self._documents.get(collectionName);\n    if (ids == null) {\n      ids = new Set();\n      self._documents.set(collectionName, ids);\n    }\n    ids.add(id);\n    self._session.added(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document in the record set has been modified.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that contains the changed document.\n   * @param {String} id The changed document's ID.\n   * @param {Object} fields The fields in the document that have changed, together with their new values.  If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document.  If `_id` is present it is ignored.\n   */\n  changed: function (collectionName, id, fields) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that a document has been removed from the record set.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   * @param {String} collection The name of the collection that the document has been removed from.\n   * @param {String} id The ID of the document that has been removed.\n   */\n  removed: function (collectionName, id) {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    id = self._idFilter.idStringify(id);\n    // We don't bother to delete sets of things in a collection if the\n    // collection is empty.  It could break _removeAllDocuments.\n    self._documents.get(collectionName).delete(id);\n    self._session.removed(self._subscriptionHandle, collectionName, id);\n  },\n\n  /**\n   * @summary Call inside the publish function.  Informs the subscriber that an initial, complete snapshot of the record set has been sent.  This will trigger a call on the client to the `onReady` callback passed to  [`Meteor.subscribe`](#meteor_subscribe), if any.\n   * @locus Server\n   * @memberOf Subscription\n   * @instance\n   */\n  ready: function () {\n    var self = this;\n    if (self._isDeactivated())\n      return;\n    if (!self._subscriptionId)\n      return;  // unnecessary but ignored for universal sub\n    if (!self._ready) {\n      self._session.sendReady([self._subscriptionId]);\n      self._ready = true;\n    }\n  }\n});\n\n/******************************************************************************/\n/* Server                                                                     */\n/******************************************************************************/\n\nServer = function (options) {\n  var self = this;\n\n  // The default heartbeat interval is 30 seconds on the server and 35\n  // seconds on the client.  Since the client doesn't need to send a\n  // ping as long as it is receiving pings, this means that pings\n  // normally go from the server to the client.\n  //\n  // Note: Troposphere depends on the ability to mutate\n  // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n  self.options = _.defaults(options || {}, {\n    heartbeatInterval: 15000,\n    heartbeatTimeout: 15000,\n    // For testing, allow responding to pings to be disabled.\n    respondToPings: true\n  });\n\n  // Map of callbacks to call when a new connection comes in to the\n  // server and completes DDP version negotiation. Use an object instead\n  // of an array so we can safely remove one from the list while\n  // iterating over it.\n  self.onConnectionHook = new Hook({\n    debugPrintExceptions: \"onConnection callback\"\n  });\n\n  // Map of callbacks to call when a new message comes in.\n  self.onMessageHook = new Hook({\n    debugPrintExceptions: \"onMessage callback\"\n  });\n\n  self.publish_handlers = {};\n  self.universal_publish_handlers = [];\n\n  self.method_handlers = {};\n\n  self.sessions = new Map(); // map from id to session\n\n  self.stream_server = new StreamServer;\n\n  self.stream_server.register(function (socket) {\n    // socket implements the SockJSConnection interface\n    socket._meteorSession = null;\n\n    var sendError = function (reason, offendingMessage) {\n      var msg = {msg: 'error', reason: reason};\n      if (offendingMessage)\n        msg.offendingMessage = offendingMessage;\n      socket.send(DDPCommon.stringifyDDP(msg));\n    };\n\n    socket.on('data', function (raw_msg) {\n      if (Meteor._printReceivedDDP) {\n        Meteor._debug(\"Received DDP\", raw_msg);\n      }\n      try {\n        try {\n          var msg = DDPCommon.parseDDP(raw_msg);\n        } catch (err) {\n          sendError('Parse error');\n          return;\n        }\n        if (msg === null || !msg.msg) {\n          sendError('Bad request', msg);\n          return;\n        }\n\n        if (msg.msg === 'connect') {\n          if (socket._meteorSession) {\n            sendError(\"Already connected\", msg);\n            return;\n          }\n          Fiber(function () {\n            self._handleConnect(socket, msg);\n          }).run();\n          return;\n        }\n\n        if (!socket._meteorSession) {\n          sendError('Must connect first', msg);\n          return;\n        }\n        socket._meteorSession.processMessage(msg);\n      } catch (e) {\n        // XXX print stack nicely\n        Meteor._debug(\"Internal exception while processing message\", msg, e);\n      }\n    });\n\n    socket.on('close', function () {\n      if (socket._meteorSession) {\n        Fiber(function () {\n          socket._meteorSession.close();\n        }).run();\n      }\n    });\n  });\n};\n\n_.extend(Server.prototype, {\n\n  /**\n   * @summary Register a callback to be called when a new DDP connection is made to the server.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP connection is established.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onConnection: function (fn) {\n    var self = this;\n    return self.onConnectionHook.register(fn);\n  },\n\n  /**\n   * @summary Register a callback to be called when a new DDP message is received.\n   * @locus Server\n   * @param {function} callback The function to call when a new DDP message is received.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  onMessage: function (fn) {\n    var self = this;\n    return self.onMessageHook.register(fn);\n  },\n\n  _handleConnect: function (socket, msg) {\n    var self = this;\n\n    // The connect message must specify a version and an array of supported\n    // versions, and it must claim to support what it is proposing.\n    if (!(typeof (msg.version) === 'string' &&\n          _.isArray(msg.support) &&\n          _.all(msg.support, _.isString) &&\n          _.contains(msg.support, msg.version))) {\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n                                version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n      socket.close();\n      return;\n    }\n\n    // In the future, handle session resumption: something like:\n    //  socket._meteorSession = self.sessions[msg.session]\n    var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n    if (msg.version !== version) {\n      // The best version to use (according to the client's stated preferences)\n      // is not the one the client is trying to use. Inform them about the best\n      // version to use.\n      socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n      socket.close();\n      return;\n    }\n\n    // Yay, version matches! Create a new session.\n    // Note: Troposphere depends on the ability to mutate\n    // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n    socket._meteorSession = new Session(self, version, socket, self.options);\n    self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n    self.onConnectionHook.each(function (callback) {\n      if (socket._meteorSession)\n        callback(socket._meteorSession.connectionHandle);\n      return true;\n    });\n  },\n  /**\n   * Register a publish handler function.\n   *\n   * @param name {String} identifier for query\n   * @param handler {Function} publish handler\n   * @param options {Object}\n   *\n   * Server will call handler function on each new subscription,\n   * either when receiving DDP sub message for a named subscription, or on\n   * DDP connect for a universal subscription.\n   *\n   * If name is null, this will be a subscription that is\n   * automatically established and permanently on for all connected\n   * client, instead of a subscription that can be turned on and off\n   * with subscribe().\n   *\n   * options to contain:\n   *  - (mostly internal) is_auto: true if generated automatically\n   *    from an autopublish hook. this is for cosmetic purposes only\n   *    (it lets us determine whether to print a warning suggesting\n   *    that you turn off autopublish.)\n   */\n\n  /**\n   * @summary Publish a record set.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   * @locus Server\n   * @param {String|Object} name If String, name of the record set.  If Object, publications Dictionary of publish functions by name.  If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n   * @param {Function} func Function called on the server each time a client subscribes.  Inside the function, `this` is the publish handler object, described below.  If the client passed arguments to `subscribe`, the function is called with the same arguments.\n   */\n  publish: function (name, handler, options) {\n    var self = this;\n\n    if (! _.isObject(name)) {\n      options = options || {};\n\n      if (name && name in self.publish_handlers) {\n        Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n        return;\n      }\n\n      if (Package.autopublish && !options.is_auto) {\n        // They have autopublish on, yet they're trying to manually\n        // picking stuff to publish. They probably should turn off\n        // autopublish. (This check isn't perfect -- if you create a\n        // publish before you turn on autopublish, it won't catch\n        // it. But this will definitely handle the simple case where\n        // you've added the autopublish package to your app, and are\n        // calling publish from your app code.)\n        if (!self.warned_about_autopublish) {\n          self.warned_about_autopublish = true;\n          Meteor._debug(\n    \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n    \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n    \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n    \"** will still be sent to all clients.\\n\" +\n    \"**\\n\" +\n    \"** Turn off autopublish by removing the autopublish package:\\n\" +\n    \"**\\n\" +\n    \"**   $ meteor remove autopublish\\n\" +\n    \"**\\n\" +\n    \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n    \"** for each collection that you want clients to see.\\n\");\n        }\n      }\n\n      if (name)\n        self.publish_handlers[name] = handler;\n      else {\n        self.universal_publish_handlers.push(handler);\n        // Spin up the new publisher on any existing session too. Run each\n        // session's subscription in a new Fiber, so that there's no change for\n        // self.sessions to change while we're running this loop.\n        self.sessions.forEach(function (session) {\n          if (!session._dontStartNewUniversalSubs) {\n            Fiber(function() {\n              session._startSubscription(handler);\n            }).run();\n          }\n        });\n      }\n    }\n    else{\n      _.each(name, function(value, key) {\n        self.publish(key, value, {});\n      });\n    }\n  },\n\n  _removeSession: function (session) {\n    var self = this;\n    self.sessions.delete(session.id);\n  },\n\n  /**\n   * @summary Defines functions that can be invoked over the network by clients.\n   * @locus Anywhere\n   * @param {Object} methods Dictionary whose keys are method names and values are functions.\n   * @memberOf Meteor\n   * @importFromPackage meteor\n   */\n  methods: function (methods) {\n    var self = this;\n    _.each(methods, function (func, name) {\n      if (typeof func !== 'function')\n        throw new Error(\"Method '\" + name + \"' must be a function\");\n      if (self.method_handlers[name])\n        throw new Error(\"A method named '\" + name + \"' is already defined\");\n      self.method_handlers[name] = func;\n    });\n  },\n\n  call: function (name, ...args) {\n    if (args.length && typeof args[args.length - 1] === \"function\") {\n      // If it's a function, the last argument is the result callback, not\n      // a parameter to the remote method.\n      var callback = args.pop();\n    }\n\n    return this.apply(name, args, callback);\n  },\n\n  // A version of the call method that always returns a Promise.\n  callAsync: function (name, ...args) {\n    return this.applyAsync(name, args);\n  },\n\n  apply: function (name, args, options, callback) {\n    // We were passed 3 arguments. They may be either (name, args, options)\n    // or (name, args, callback)\n    if (! callback && typeof options === 'function') {\n      callback = options;\n      options = {};\n    } else {\n      options = options || {};\n    }\n\n    const promise = this.applyAsync(name, args, options);\n\n    // Return the result in whichever way the caller asked for it. Note that we\n    // do NOT block on the write fence in an analogous way to how the client\n    // blocks on the relevant data being visible, so you are NOT guaranteed that\n    // cursor observe callbacks have fired when your callback is invoked. (We\n    // can change this if there's a real use case.)\n    if (callback) {\n      promise.then(\n        result => callback(undefined, result),\n        exception => callback(exception)\n      );\n    } else {\n      return promise.await();\n    }\n  },\n\n  // @param options {Optional Object}\n  applyAsync: function (name, args, options) {\n    // Run the handler\n    var handler = this.method_handlers[name];\n    if (! handler) {\n      return Promise.reject(\n        new Meteor.Error(404, `Method '${name}' not found`)\n      );\n    }\n\n    // If this is a method call from within another method or publish function,\n    // get the user state from the outer method or publish function, otherwise\n    // don't allow setUserId to be called\n    var userId = null;\n    var setUserId = function() {\n      throw new Error(\"Can't call setUserId on a server initiated method call\");\n    };\n    var connection = null;\n    var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n    var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n    var randomSeed = null;\n    if (currentMethodInvocation) {\n      userId = currentMethodInvocation.userId;\n      setUserId = function(userId) {\n        currentMethodInvocation.setUserId(userId);\n      };\n      connection = currentMethodInvocation.connection;\n      randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n    } else if (currentPublicationInvocation) {\n      userId = currentPublicationInvocation.userId;\n      setUserId = function(userId) {\n        currentPublicationInvocation._session._setUserId(userId);\n      };\n      connection = currentPublicationInvocation.connection;\n    }\n\n    var invocation = new DDPCommon.MethodInvocation({\n      isSimulation: false,\n      userId,\n      setUserId,\n      connection,\n      randomSeed\n    });\n\n    return new Promise(resolve => resolve(\n      DDP._CurrentMethodInvocation.withValue(\n        invocation,\n        () => maybeAuditArgumentChecks(\n          handler, invocation, EJSON.clone(args),\n          \"internal call to '\" + name + \"'\"\n        )\n      )\n    )).then(EJSON.clone);\n  },\n\n  _urlForSession: function (sessionId) {\n    var self = this;\n    var session = self.sessions.get(sessionId);\n    if (session)\n      return session._socketUrl;\n    else\n      return null;\n  }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n                                 serverSupportedVersions) {\n  var correctVersion = _.find(clientSupportedVersions, function (version) {\n    return _.contains(serverSupportedVersions, version);\n  });\n  if (!correctVersion) {\n    correctVersion = serverSupportedVersions[0];\n  }\n  return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n  if (!exception) return exception;\n\n  // To allow packages to throw errors intended for the client but not have to\n  // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n  // error before it is thrown.\n  if (exception.isClientSafe) {\n    if (!(exception instanceof Meteor.Error)) {\n      const originalMessage = exception.message;\n      exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n      exception.message = originalMessage;\n    }\n    return exception;\n  }\n\n  // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n  // the server log.\n  if (!exception._expectedByTest) {\n    Meteor._debug(\"Exception \" + context, exception.stack);\n    if (exception.sanitizedError) {\n      Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n      Meteor._debug();\n    }\n  }\n\n  // Did the error contain more details that could have been useful if caught in\n  // server code (or if thrown from non-client-originated code), but also\n  // provided a \"sanitized\" version with more context than 500 Internal server\n  // error? Use that.\n  if (exception.sanitizedError) {\n    if (exception.sanitizedError.isClientSafe)\n      return exception.sanitizedError;\n    Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n                  \"does not have isClientSafe property set; ignoring\");\n  }\n\n  return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n  args = args || [];\n  if (Package['audit-argument-checks']) {\n    return Match._failIfArgumentsAreNotAllChecked(\n      f, context, args, description);\n  }\n  return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n  var self = this;\n\n  self.armed = false;\n  self.fired = false;\n  self.retired = false;\n  self.outstanding_writes = 0;\n  self.before_fire_callbacks = [];\n  self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n  // Start tracking a write, and return an object to represent it. The\n  // object has a single method, committed(). This method should be\n  // called when the write is fully committed and propagated. You can\n  // continue to add writes to the WriteFence up until it is triggered\n  // (calls its callbacks because all writes have committed.)\n  beginWrite: function () {\n    var self = this;\n\n    if (self.retired)\n      return { committed: function () {} };\n\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to add writes\");\n\n    self.outstanding_writes++;\n    var committed = false;\n    return {\n      committed: function () {\n        if (committed)\n          throw new Error(\"committed called twice on the same write\");\n        committed = true;\n        self.outstanding_writes--;\n        self._maybeFire();\n      }\n    };\n  },\n\n  // Arm the fence. Once the fence is armed, and there are no more\n  // uncommitted writes, it will activate.\n  arm: function () {\n    var self = this;\n    if (self === DDPServer._CurrentWriteFence.get())\n      throw Error(\"Can't arm the current fence\");\n    self.armed = true;\n    self._maybeFire();\n  },\n\n  // Register a function to be called once before firing the fence.\n  // Callback function can add new writes to the fence, in which case\n  // it won't fire until those writes are done as well.\n  onBeforeFire: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.before_fire_callbacks.push(func);\n  },\n\n  // Register a function to be called when the fence fires.\n  onAllCommitted: function (func) {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"fence has already activated -- too late to \" +\n                      \"add a callback\");\n    self.completion_callbacks.push(func);\n  },\n\n  // Convenience function. Arms the fence, then blocks until it fires.\n  armAndWait: function () {\n    var self = this;\n    var future = new Future;\n    self.onAllCommitted(function () {\n      future['return']();\n    });\n    self.arm();\n    future.wait();\n  },\n\n  _maybeFire: function () {\n    var self = this;\n    if (self.fired)\n      throw new Error(\"write fence already activated?\");\n    if (self.armed && !self.outstanding_writes) {\n      function invokeCallback (func) {\n        try {\n          func(self);\n        } catch (err) {\n          Meteor._debug(\"exception in write fence callback\", err);\n        }\n      }\n\n      self.outstanding_writes++;\n      while (self.before_fire_callbacks.length > 0) {\n        var callbacks = self.before_fire_callbacks;\n        self.before_fire_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n      self.outstanding_writes--;\n\n      if (!self.outstanding_writes) {\n        self.fired = true;\n        var callbacks = self.completion_callbacks;\n        self.completion_callbacks = [];\n        _.each(callbacks, invokeCallback);\n      }\n    }\n  },\n\n  // Deactivate this fence so that adding more writes has no effect.\n  // The fence must have already fired.\n  retire: function () {\n    var self = this;\n    if (! self.fired)\n      throw new Error(\"Can't retire a fence that hasn't fired.\");\n    self.retired = true;\n  }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n  var self = this;\n  options = options || {};\n\n  self.nextId = 1;\n  // map from collection name (string) -> listener id -> object. each object has\n  // keys 'trigger', 'callback'.  As a hack, the empty string means \"no\n  // collection\".\n  self.listenersByCollection = {};\n  self.listenersByCollectionCount = {};\n  self.factPackage = options.factPackage || \"livedata\";\n  self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n  // msg is a trigger or a notification\n  _collectionForMessage: function (msg) {\n    var self = this;\n    if (! _.has(msg, 'collection')) {\n      return '';\n    } else if (typeof(msg.collection) === 'string') {\n      if (msg.collection === '')\n        throw Error(\"Message has empty collection!\");\n      return msg.collection;\n    } else {\n      throw Error(\"Message has non-string collection!\");\n    }\n  },\n\n  // Listen for notification that match 'trigger'. A notification\n  // matches if it has the key-value pairs in trigger as a\n  // subset. When a notification matches, call 'callback', passing\n  // the actual notification.\n  //\n  // Returns a listen handle, which is an object with a method\n  // stop(). Call stop() to stop listening.\n  //\n  // XXX It should be legal to call fire() from inside a listen()\n  // callback?\n  listen: function (trigger, callback) {\n    var self = this;\n    var id = self.nextId++;\n\n    var collection = self._collectionForMessage(trigger);\n    var record = {trigger: EJSON.clone(trigger), callback: callback};\n    if (! _.has(self.listenersByCollection, collection)) {\n      self.listenersByCollection[collection] = {};\n      self.listenersByCollectionCount[collection] = 0;\n    }\n    self.listenersByCollection[collection][id] = record;\n    self.listenersByCollectionCount[collection]++;\n\n    if (self.factName && Package['facts-base']) {\n      Package['facts-base'].Facts.incrementServerFact(\n        self.factPackage, self.factName, 1);\n    }\n\n    return {\n      stop: function () {\n        if (self.factName && Package['facts-base']) {\n          Package['facts-base'].Facts.incrementServerFact(\n            self.factPackage, self.factName, -1);\n        }\n        delete self.listenersByCollection[collection][id];\n        self.listenersByCollectionCount[collection]--;\n        if (self.listenersByCollectionCount[collection] === 0) {\n          delete self.listenersByCollection[collection];\n          delete self.listenersByCollectionCount[collection];\n        }\n      }\n    };\n  },\n\n  // Fire the provided 'notification' (an object whose attribute\n  // values are all JSON-compatibile) -- inform all matching listeners\n  // (registered with listen()).\n  //\n  // If fire() is called inside a write fence, then each of the\n  // listener callbacks will be called inside the write fence as well.\n  //\n  // The listeners may be invoked in parallel, rather than serially.\n  fire: function (notification) {\n    var self = this;\n\n    var collection = self._collectionForMessage(notification);\n\n    if (! _.has(self.listenersByCollection, collection)) {\n      return;\n    }\n\n    var listenersForCollection = self.listenersByCollection[collection];\n    var callbackIds = [];\n    _.each(listenersForCollection, function (l, id) {\n      if (self._matches(notification, l.trigger)) {\n        callbackIds.push(id);\n      }\n    });\n\n    // Listener callbacks can yield, so we need to first find all the ones that\n    // match in a single iteration over self.listenersByCollection (which can't\n    // be mutated during this iteration), and then invoke the matching\n    // callbacks, checking before each call to ensure they haven't stopped.\n    // Note that we don't have to check that\n    // self.listenersByCollection[collection] still === listenersForCollection,\n    // because the only way that stops being true is if listenersForCollection\n    // first gets reduced down to the empty object (and then never gets\n    // increased again).\n    _.each(callbackIds, function (id) {\n      if (_.has(listenersForCollection, id)) {\n        listenersForCollection[id].callback(notification);\n      }\n    });\n  },\n\n  // A notification matches a trigger if all keys that exist in both are equal.\n  //\n  // Examples:\n  //  N:{collection: \"C\"} matches T:{collection: \"C\"}\n  //    (a non-targeted write to a collection matches a\n  //     non-targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n  //    (a targeted write to a collection matches a non-targeted query)\n  //  N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a non-targeted write to a collection matches a\n  //     targeted query)\n  //  N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n  //    (a targeted write to a collection matches a targeted query targeted\n  //     at the same document)\n  //  N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n  //    (a targeted write to a collection does not match a targeted query\n  //     targeted at a different document)\n  _matches: function (notification, trigger) {\n    // Most notifications that use the crossbar have a string `collection` and\n    // maybe an `id` that is a string or ObjectID. We're already dividing up\n    // triggers by collection, but let's fast-track \"nope, different ID\" (and\n    // avoid the overly generic EJSON.equals). This makes a noticeable\n    // performance difference; see https://github.com/meteor/meteor/pull/3697\n    if (typeof(notification.id) === 'string' &&\n        typeof(trigger.id) === 'string' &&\n        notification.id !== trigger.id) {\n      return false;\n    }\n    if (notification.id instanceof MongoID.ObjectID &&\n        trigger.id instanceof MongoID.ObjectID &&\n        ! notification.id.equals(trigger.id)) {\n      return false;\n    }\n\n    return _.all(trigger, function (triggerValue, key) {\n      return !_.has(notification, key) ||\n        EJSON.equals(triggerValue, notification[key]);\n    });\n  }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n  factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n  __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n    process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n  DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n       function (name) {\n         Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n       });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} diff --git a/server/bundle/programs/server/packages/ddp-server.js.map b/server/bundle/programs/server/packages/ddp-server.js.map index 7f7cbe1659..066ef88f20 100644 --- a/server/bundle/programs/server/packages/ddp-server.js.map +++ b/server/bundle/programs/server/packages/ddp-server.js.map @@ -1 +1 @@ -{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","jsessionid","USE_JSESSIONID","disable_cors","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":"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","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n var extensions = [];\n\n var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n if (websocketCompressionConfig) {\n extensions.push(Npm.require('permessage-deflate').configure(\n websocketCompressionConfig\n ));\n }\n\n return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n var self = this;\n self.registration_callbacks = [];\n self.open_sockets = [];\n\n // Because we are installing directly onto WebApp.httpServer instead of using\n // WebApp.app, we have to process the path prefix ourselves.\n self.prefix = pathPrefix + '/sockjs';\n RoutePolicy.declare(self.prefix + '/', 'network');\n\n // set up sockjs\n var sockjs = Npm.require('sockjs');\n var serverOptions = {\n prefix: self.prefix,\n log: function () { },\n // this is the default, but we code it explicitly because we depend\n // on it in stream_client:HEARTBEAT_TIMEOUT\n heartbeat_delay: 45000,\n // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n // bound for that much time, SockJS might not notice that the user has\n // reconnected because the timer (of disconnect_delay ms) can fire before\n // SockJS processes the new connection. Eventually we'll fix this by not\n // combining CPU-heavy processing with SockJS termination (eg a proxy which\n // converts to Unix sockets) but for now, raise the delay.\n disconnect_delay: 60 * 1000,\n // Set the USE_JSESSIONID environment variable to enable setting the\n // JSESSIONID cookie. This is useful for setting up proxies with\n // session affinity.\n jsessionid: !!process.env.USE_JSESSIONID,\n // 禁用cors，防止请求response返回Access-Control-Allow-Origin:*\n disable_cors: true\n };\n\n // If you know your server environment (eg, proxies) will prevent websockets\n // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n // browsers) will not waste time attempting to use them.\n // (Your server will still have a /websocket endpoint.)\n if (process.env.DISABLE_WEBSOCKETS) {\n serverOptions.websocket = false;\n } else {\n serverOptions.faye_server_options = {\n extensions: websocketExtensions()\n };\n }\n\n self.server = sockjs.createServer(serverOptions);\n\n // Install the sockjs handlers, but we want to keep around our own particular\n // request handler that adjusts idle timeouts while we have an outstanding\n // request. This compensates for the fact that sockjs removes all listeners\n // for \"request\" to add its own.\n WebApp.httpServer.removeListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n self.server.installHandlers(WebApp.httpServer);\n WebApp.httpServer.addListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n\n // Support the /websocket endpoint\n self._redirectWebsocketEndpoint();\n\n self.server.on('connection', function (socket) {\n // We want to make sure that if a client connects to us and does the initial\n // Websocket handshake but never gets to the DDP handshake, that we\n // eventually kill the socket. Once the DDP handshake happens, DDP\n // heartbeating will work. And before the Websocket handshake, the timeouts\n // we set at the server level in webapp_server.js will work. But\n // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n // is an \"in between\" state where this doesn't happen. We work around this\n // by explicitly setting the socket timeout to a relatively large time here,\n // and setting it back to zero when we set up the heartbeat in\n // livedata_server.js.\n socket.setWebsocketTimeout = function (timeout) {\n if ((socket.protocol === 'websocket' ||\n socket.protocol === 'websocket-raw')\n && socket._session.recv) {\n socket._session.recv.connection.setTimeout(timeout);\n }\n };\n socket.setWebsocketTimeout(45 * 1000);\n\n socket.send = function (data) {\n socket.write(data);\n };\n socket.on('close', function () {\n self.open_sockets = _.without(self.open_sockets, socket);\n });\n self.open_sockets.push(socket);\n\n // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n // will force old clients to reload. Remove this once we're not\n // concerned about people upgrading from a pre-0.7.0 release. Also,\n // remove the clause in the client that ignores the welcome message\n // (livedata_connection.js)\n socket.send(JSON.stringify({ server_id: \"0\" }));\n\n // call all our callbacks when we get a new socket. they will do the\n // work of setting up handlers and such for specific messages.\n _.each(self.registration_callbacks, function (callback) {\n callback(socket);\n });\n });\n\n};\n\n_.extend(StreamServer.prototype, {\n // call my callback when a new socket connects.\n // also call it for all current connections.\n register: function (callback) {\n var self = this;\n self.registration_callbacks.push(callback);\n _.each(self.all_sockets(), function (socket) {\n callback(socket);\n });\n },\n\n // get a list of all sockets\n all_sockets: function () {\n var self = this;\n return _.values(self.open_sockets);\n },\n\n // Redirect /websocket to /sockjs/websocket in order to not expose\n // sockjs to clients that want to use raw websockets\n _redirectWebsocketEndpoint: function () {\n var self = this;\n // Unfortunately we can't use a connect middleware here since\n // sockjs installs itself prior to all existing listeners\n // (meaning prior to any connect middlewares) so we need to take\n // an approach similar to overshadowListeners in\n // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n _.each(['request', 'upgrade'], function (event) {\n var httpServer = WebApp.httpServer;\n var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n httpServer.removeAllListeners(event);\n\n // request and upgrade have different arguments passed but\n // we only care about the first one which is always request\n var newListener = function (request /*, moreArguments */) {\n // Store arguments for use within the closure below\n var args = arguments;\n\n // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n // preserving query string.\n var parsedUrl = url.parse(request.url);\n if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n parsedUrl.pathname === pathPrefix + '/websocket/') {\n parsedUrl.pathname = self.prefix + '/websocket';\n request.url = url.format(parsedUrl);\n }\n _.each(oldHttpServerListeners, function (oldListener) {\n oldListener.apply(httpServer, args);\n });\n };\n httpServer.addListener(event, newListener);\n });\n }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n var self = this;\n self.existsIn = new Set(); // set of subscriptionHandle\n self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n getFields: function () {\n var self = this;\n var ret = {};\n self.dataByKey.forEach(function (precedenceList, key) {\n ret[key] = precedenceList[0].value;\n });\n return ret;\n },\n\n clearField: function (subscriptionHandle, key, changeCollector) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n var precedenceList = self.dataByKey.get(key);\n\n // It's okay to clear fields that didn't exist. No need to throw\n // an error.\n if (!precedenceList)\n return;\n\n var removedValue = undefined;\n for (var i = 0; i < precedenceList.length; i++) {\n var precedence = precedenceList[i];\n if (precedence.subscriptionHandle === subscriptionHandle) {\n // The view's value can only change if this subscription is the one that\n // used to have precedence.\n if (i === 0)\n removedValue = precedence.value;\n precedenceList.splice(i, 1);\n break;\n }\n }\n if (precedenceList.length === 0) {\n self.dataByKey.delete(key);\n changeCollector[key] = undefined;\n } else if (removedValue !== undefined &&\n !EJSON.equals(removedValue, precedenceList[0].value)) {\n changeCollector[key] = precedenceList[0].value;\n }\n },\n\n changeField: function (subscriptionHandle, key, value,\n changeCollector, isAdd) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n\n // Don't share state with the data passed in by the user.\n value = EJSON.clone(value);\n\n if (!self.dataByKey.has(key)) {\n self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n value: value}]);\n changeCollector[key] = value;\n return;\n }\n var precedenceList = self.dataByKey.get(key);\n var elt;\n if (!isAdd) {\n elt = precedenceList.find(function (precedence) {\n return precedence.subscriptionHandle === subscriptionHandle;\n });\n }\n\n if (elt) {\n if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n // this subscription is changing the value of this field.\n changeCollector[key] = value;\n }\n elt.value = value;\n } else {\n // this subscription is newly caring about this field\n precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n }\n\n }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n var self = this;\n self.collectionName = collectionName;\n self.documents = new Map();\n self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n isEmpty: function () {\n var self = this;\n return self.documents.size === 0;\n },\n\n diff: function (previous) {\n var self = this;\n DiffSequence.diffMaps(previous.documents, self.documents, {\n both: _.bind(self.diffDocument, self),\n\n rightOnly: function (id, nowDV) {\n self.callbacks.added(self.collectionName, id, nowDV.getFields());\n },\n\n leftOnly: function (id, prevDV) {\n self.callbacks.removed(self.collectionName, id);\n }\n });\n },\n\n diffDocument: function (id, prevDV, nowDV) {\n var self = this;\n var fields = {};\n DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n both: function (key, prev, now) {\n if (!EJSON.equals(prev, now))\n fields[key] = now;\n },\n rightOnly: function (key, now) {\n fields[key] = now;\n },\n leftOnly: function(key, prev) {\n fields[key] = undefined;\n }\n });\n self.callbacks.changed(self.collectionName, id, fields);\n },\n\n added: function (subscriptionHandle, id, fields) {\n var self = this;\n var docView = self.documents.get(id);\n var added = false;\n if (!docView) {\n added = true;\n docView = new SessionDocumentView();\n self.documents.set(id, docView);\n }\n docView.existsIn.add(subscriptionHandle);\n var changeCollector = {};\n _.each(fields, function (value, key) {\n docView.changeField(\n subscriptionHandle, key, value, changeCollector, true);\n });\n if (added)\n self.callbacks.added(self.collectionName, id, changeCollector);\n else\n self.callbacks.changed(self.collectionName, id, changeCollector);\n },\n\n changed: function (subscriptionHandle, id, changed) {\n var self = this;\n var changedResult = {};\n var docView = self.documents.get(id);\n if (!docView)\n throw new Error(\"Could not find element with id \" + id + \" to change\");\n _.each(changed, function (value, key) {\n if (value === undefined)\n docView.clearField(subscriptionHandle, key, changedResult);\n else\n docView.changeField(subscriptionHandle, key, value, changedResult);\n });\n self.callbacks.changed(self.collectionName, id, changedResult);\n },\n\n removed: function (subscriptionHandle, id) {\n var self = this;\n var docView = self.documents.get(id);\n if (!docView) {\n var err = new Error(\"Removed nonexistent document \" + id);\n throw err;\n }\n docView.existsIn.delete(subscriptionHandle);\n if (docView.existsIn.size === 0) {\n // it is gone from everyone\n self.callbacks.removed(self.collectionName, id);\n self.documents.delete(id);\n } else {\n var changed = {};\n // remove this subscription from every precedence list\n // and record the changes\n docView.dataByKey.forEach(function (precedenceList, key) {\n docView.clearField(subscriptionHandle, key, changed);\n });\n\n self.callbacks.changed(self.collectionName, id, changed);\n }\n }\n});\n\n/******************************************************************************/\n/* Session */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n var self = this;\n self.id = Random.id();\n\n self.server = server;\n self.version = version;\n\n self.initialized = false;\n self.socket = socket;\n\n // set to null when the session is destroyed. multiple places below\n // use this to determine if the session is alive or not.\n self.inQueue = new Meteor._DoubleEndedQueue();\n\n self.blocked = false;\n self.workerRunning = false;\n\n // Sub objects for active subscriptions\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n self.userId = null;\n\n self.collectionViews = new Map();\n\n // Set this to false to not send messages when collectionViews are\n // modified. This is done when rerunning subs in _setUserId and those messages\n // are calculated via a diff instead.\n self._isSending = true;\n\n // If this is true, don't start a newly-created universal publisher on this\n // session. The session will take care of starting it when appropriate.\n self._dontStartNewUniversalSubs = false;\n\n // when we are rerunning subscriptions, any ready messages\n // we want to buffer up for when we are done rerunning subscriptions\n self._pendingReady = [];\n\n // List of callbacks to call when this connection is closed.\n self._closeCallbacks = [];\n\n\n // XXX HACK: If a sockjs connection, save off the URL. This is\n // temporary and will go away in the near future.\n self._socketUrl = socket.url;\n\n // Allow tests to disable responding to pings.\n self._respondToPings = options.respondToPings;\n\n // This object is the public interface to the session. In the public\n // API, it is called the `connection` object. Internally we call it\n // a `connectionHandle` to avoid ambiguity.\n self.connectionHandle = {\n id: self.id,\n close: function () {\n self.close();\n },\n onClose: function (fn) {\n var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n if (self.inQueue) {\n self._closeCallbacks.push(cb);\n } else {\n // if we're already closed, call the callback.\n Meteor.defer(cb);\n }\n },\n clientAddress: self._clientAddress(),\n httpHeaders: self.socket.headers\n };\n\n self.send({ msg: 'connected', session: self.id });\n\n // On initial connect, spin up all the universal publishers.\n Fiber(function () {\n self.startUniversalSubs();\n }).run();\n\n if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n // We no longer need the low level timeout because we have heartbeating.\n socket.setWebsocketTimeout(0);\n\n self.heartbeat = new DDPCommon.Heartbeat({\n heartbeatInterval: options.heartbeatInterval,\n heartbeatTimeout: options.heartbeatTimeout,\n onTimeout: function () {\n self.close();\n },\n sendPing: function () {\n self.send({msg: 'ping'});\n }\n });\n self.heartbeat.start();\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n sendReady: function (subscriptionIds) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"ready\", subs: subscriptionIds});\n else {\n _.each(subscriptionIds, function (subscriptionId) {\n self._pendingReady.push(subscriptionId);\n });\n }\n },\n\n sendAdded: function (collectionName, id, fields) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n },\n\n sendChanged: function (collectionName, id, fields) {\n var self = this;\n if (_.isEmpty(fields))\n return;\n\n if (self._isSending) {\n self.send({\n msg: \"changed\",\n collection: collectionName,\n id: id,\n fields: fields\n });\n }\n },\n\n sendRemoved: function (collectionName, id) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"removed\", collection: collectionName, id: id});\n },\n\n getSendCallbacks: function () {\n var self = this;\n return {\n added: _.bind(self.sendAdded, self),\n changed: _.bind(self.sendChanged, self),\n removed: _.bind(self.sendRemoved, self)\n };\n },\n\n getCollectionView: function (collectionName) {\n var self = this;\n var ret = self.collectionViews.get(collectionName);\n if (!ret) {\n ret = new SessionCollectionView(collectionName,\n self.getSendCallbacks());\n self.collectionViews.set(collectionName, ret);\n }\n return ret;\n },\n\n added: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.added(subscriptionHandle, id, fields);\n },\n\n removed: function (subscriptionHandle, collectionName, id) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.removed(subscriptionHandle, id);\n if (view.isEmpty()) {\n self.collectionViews.delete(collectionName);\n }\n },\n\n changed: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.changed(subscriptionHandle, id, fields);\n },\n\n startUniversalSubs: function () {\n var self = this;\n // Make a shallow copy of the set of universal handlers and start them. If\n // additional universal publishers start while we're running them (due to\n // yielding), they will run separately as part of Server.publish.\n var handlers = _.clone(self.server.universal_publish_handlers);\n _.each(handlers, function (handler) {\n self._startSubscription(handler);\n });\n },\n\n // Destroy this session and unregister it at the server.\n close: function () {\n var self = this;\n\n // Destroy this session, even if it's not registered at the\n // server. Stop all processing and tear everything down. If a socket\n // was attached, close it.\n\n // Already destroyed.\n if (! self.inQueue)\n return;\n\n // Drop the merge box data immediately.\n self.inQueue = null;\n self.collectionViews = new Map();\n\n if (self.heartbeat) {\n self.heartbeat.stop();\n self.heartbeat = null;\n }\n\n if (self.socket) {\n self.socket.close();\n self.socket._meteorSession = null;\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", -1);\n\n Meteor.defer(function () {\n // stop callbacks can yield, so we defer this on close.\n // sub._isDeactivated() detects that we set inQueue to null and\n // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n self._deactivateAllSubscriptions();\n\n // Defer calling the close callbacks, so that the caller closing\n // the session isn't waiting for all the callbacks to complete.\n _.each(self._closeCallbacks, function (callback) {\n callback();\n });\n });\n\n // Unregister the session.\n self.server._removeSession(self);\n },\n\n // Send a message (doing nothing if no socket is connected right now.)\n // It should be a JSON object (it will be stringified.)\n send: function (msg) {\n var self = this;\n if (self.socket) {\n if (Meteor._printSentDDP)\n Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n self.socket.send(DDPCommon.stringifyDDP(msg));\n }\n },\n\n // Send a connection error.\n sendError: function (reason, offendingMessage) {\n var self = this;\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n self.send(msg);\n },\n\n // Process 'msg' as an incoming message. (But as a guard against\n // race conditions during reconnection, ignore the message if\n // 'socket' is not the currently connected socket.)\n //\n // We run the messages from the client one at a time, in the order\n // given by the client. The message handler is passed an idempotent\n // function 'unblock' which it may call to allow other messages to\n // begin running in parallel in another fiber (for example, a method\n // that wants to yield.) Otherwise, it is automatically unblocked\n // when it returns.\n //\n // Actually, we don't have to 'totally order' the messages in this\n // way, but it's the easiest thing that's correct. (unsub needs to\n // be ordered against sub, methods need to be ordered against each\n // other.)\n processMessage: function (msg_in) {\n var self = this;\n if (!self.inQueue) // we have been destroyed.\n return;\n\n // Respond to ping and pong messages immediately without queuing.\n // If the negotiated DDP version is \"pre1\" which didn't support\n // pings, preserve the \"pre1\" behavior of responding with a \"bad\n // request\" for the unknown messages.\n //\n // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n // needs a Fiber. We could actually use regular setTimeout and avoid\n // these new fibers, but it is easier to just make everything use\n // Meteor.setTimeout and not think too hard.\n //\n // Any message counts as receiving a pong, as it demonstrates that\n // the client is still alive.\n if (self.heartbeat) {\n Fiber(function () {\n self.heartbeat.messageReceived();\n }).run();\n }\n\n if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n if (self._respondToPings)\n self.send({msg: \"pong\", id: msg_in.id});\n return;\n }\n if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n // Since everything is a pong, nothing to do\n return;\n }\n\n self.inQueue.push(msg_in);\n if (self.workerRunning)\n return;\n self.workerRunning = true;\n\n var processNext = function () {\n var msg = self.inQueue && self.inQueue.shift();\n if (!msg) {\n self.workerRunning = false;\n return;\n }\n\n Fiber(function () {\n var blocked = true;\n\n var unblock = function () {\n if (!blocked)\n return; // idempotent\n blocked = false;\n processNext();\n };\n\n self.server.onMessageHook.each(function (callback) {\n callback(msg, self);\n return true;\n });\n\n if (_.has(self.protocol_handlers, msg.msg))\n self.protocol_handlers[msg.msg].call(self, msg, unblock);\n else\n self.sendError('Bad request', msg);\n unblock(); // in case the handler didn't already do it\n }).run();\n };\n\n processNext();\n },\n\n protocol_handlers: {\n sub: function (msg) {\n var self = this;\n\n // reject malformed messages\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.name) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array))) {\n self.sendError(\"Malformed subscription\", msg);\n return;\n }\n\n if (!self.server.publish_handlers[msg.name]) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n return;\n }\n\n if (self._namedSubs.has(msg.id))\n // subs are idempotent, or rather, they are ignored if a sub\n // with that id already exists. this is important during\n // reconnect.\n return;\n\n // XXX It'd be much better if we had generic hooks where any package can\n // hook into subscription handling, but in the mean while we special case\n // ddp-rate-limiter package. This is also done for weak requirements to\n // add the ddp-rate-limiter package in case we don't have Accounts. A\n // user trying to use the ddp-rate-limiter must explicitly require it.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"subscription\",\n name: msg.name,\n connectionId: self.id\n };\n\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n if (!rateLimitResult.allowed) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(\n 'too-many-requests',\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset})\n });\n return;\n }\n }\n\n var handler = self.server.publish_handlers[msg.name];\n\n self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n },\n\n unsub: function (msg) {\n var self = this;\n\n self._stopSubscription(msg.id);\n },\n\n method: function (msg, unblock) {\n var self = this;\n\n // reject malformed messages\n // For now, we silently ignore unknown attributes,\n // for forwards compatibility.\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.method) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array)) ||\n (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n self.sendError(\"Malformed method invocation\", msg);\n return;\n }\n\n var randomSeed = msg.randomSeed || null;\n\n // set up to mark the method as satisfied once all observers\n // (and subscriptions) have reacted to any writes that were\n // done.\n var fence = new DDPServer._WriteFence;\n fence.onAllCommitted(function () {\n // Retire the fence so that future writes are allowed.\n // This means that callbacks like timers are free to use\n // the fence, and if they fire before it's armed (for\n // example, because the method waits for them) their\n // writes will be included in the fence.\n fence.retire();\n self.send({\n msg: 'updated', methods: [msg.id]});\n });\n\n // find the handler\n var handler = self.server.method_handlers[msg.method];\n if (!handler) {\n self.send({\n msg: 'result', id: msg.id,\n error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n fence.arm();\n return;\n }\n\n var setUserId = function(userId) {\n self._setUserId(userId);\n };\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId: self.userId,\n setUserId: setUserId,\n unblock: unblock,\n connection: self.connectionHandle,\n randomSeed: randomSeed\n });\n\n const promise = new Promise((resolve, reject) => {\n // XXX It'd be better if we could hook into method handlers better but\n // for now, we need to check if the ddp-rate-limiter exists since we\n // have a weak requirement for the ddp-rate-limiter package to be added\n // to our application.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"method\",\n name: msg.method,\n connectionId: self.id\n };\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n if (!rateLimitResult.allowed) {\n reject(new Meteor.Error(\n \"too-many-requests\",\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset}\n ));\n return;\n }\n }\n\n resolve(DDPServer._CurrentWriteFence.withValue(\n fence,\n () => DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, msg.params,\n \"call to '\" + msg.method + \"'\"\n )\n )\n ));\n });\n\n function finish() {\n fence.arm();\n unblock();\n }\n\n const payload = {\n msg: \"result\",\n id: msg.id\n };\n\n promise.then((result) => {\n finish();\n if (result !== undefined) {\n payload.result = result;\n }\n self.send(payload);\n }, (exception) => {\n finish();\n payload.error = wrapInternalException(\n exception,\n `while invoking method '${msg.method}'`\n );\n self.send(payload);\n });\n }\n },\n\n _eachSub: function (f) {\n var self = this;\n self._namedSubs.forEach(f);\n self._universalSubs.forEach(f);\n },\n\n _diffCollectionViews: function (beforeCVs) {\n var self = this;\n DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n both: function (collectionName, leftValue, rightValue) {\n rightValue.diff(leftValue);\n },\n rightOnly: function (collectionName, rightValue) {\n rightValue.documents.forEach(function (docView, id) {\n self.sendAdded(collectionName, id, docView.getFields());\n });\n },\n leftOnly: function (collectionName, leftValue) {\n leftValue.documents.forEach(function (doc, id) {\n self.sendRemoved(collectionName, id);\n });\n }\n });\n },\n\n // Sets the current user id in all appropriate contexts and reruns\n // all subscriptions\n _setUserId: function(userId) {\n var self = this;\n\n if (userId !== null && typeof userId !== \"string\")\n throw new Error(\"setUserId must be called on string or null, not \" +\n typeof userId);\n\n // Prevent newly-created universal subscriptions from being added to our\n // session; they will be found below when we call startUniversalSubs.\n //\n // (We don't have to worry about named subscriptions, because we only add\n // them when we process a 'sub' message. We are currently processing a\n // 'method' message, and the method did not unblock, because it is illegal\n // to call setUserId after unblock. Thus we cannot be concurrently adding a\n // new named subscription.)\n self._dontStartNewUniversalSubs = true;\n\n // Prevent current subs from updating our collectionViews and call their\n // stop callbacks. This may yield.\n self._eachSub(function (sub) {\n sub._deactivate();\n });\n\n // All subs should now be deactivated. Stop sending messages to the client,\n // save the state of the published collections, reset to an empty view, and\n // update the userId.\n self._isSending = false;\n var beforeCVs = self.collectionViews;\n self.collectionViews = new Map();\n self.userId = userId;\n\n // _setUserId is normally called from a Meteor method with\n // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n // expected to be set inside a publish function, so we temporary unset it.\n // Inside a publish function DDP._CurrentPublicationInvocation is set.\n DDP._CurrentMethodInvocation.withValue(undefined, function () {\n // Save the old named subs, and reset to having no subscriptions.\n var oldNamedSubs = self._namedSubs;\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n oldNamedSubs.forEach(function (sub, subscriptionId) {\n var newSub = sub._recreate();\n self._namedSubs.set(subscriptionId, newSub);\n // nb: if the handler throws or calls this.error(), it will in fact\n // immediately send its 'nosub'. This is OK, though.\n newSub._runHandler();\n });\n\n // Allow newly-created universal subs to be started on our connection in\n // parallel with the ones we're spinning up here, and spin up universal\n // subs.\n self._dontStartNewUniversalSubs = false;\n self.startUniversalSubs();\n });\n\n // Start sending messages again, beginning with the diff from the previous\n // state of the world to the current state. No yields are allowed during\n // this diff, so that other changes cannot interleave.\n Meteor._noYieldsAllowed(function () {\n self._isSending = true;\n self._diffCollectionViews(beforeCVs);\n if (!_.isEmpty(self._pendingReady)) {\n self.sendReady(self._pendingReady);\n self._pendingReady = [];\n }\n });\n },\n\n _startSubscription: function (handler, subId, params, name) {\n var self = this;\n\n var sub = new Subscription(\n self, handler, subId, params, name);\n if (subId)\n self._namedSubs.set(subId, sub);\n else\n self._universalSubs.push(sub);\n\n sub._runHandler();\n },\n\n // tear down specified subscription\n _stopSubscription: function (subId, error) {\n var self = this;\n\n var subName = null;\n if (subId) {\n var maybeSub = self._namedSubs.get(subId);\n if (maybeSub) {\n subName = maybeSub._name;\n maybeSub._removeAllDocuments();\n maybeSub._deactivate();\n self._namedSubs.delete(subId);\n }\n }\n\n var response = {msg: 'nosub', id: subId};\n\n if (error) {\n response.error = wrapInternalException(\n error,\n subName ? (\"from sub \" + subName + \" id \" + subId)\n : (\"from sub id \" + subId));\n }\n\n self.send(response);\n },\n\n // tear down all subscriptions. Note that this does NOT send removed or nosub\n // messages, since we assume the client is gone.\n _deactivateAllSubscriptions: function () {\n var self = this;\n\n self._namedSubs.forEach(function (sub, id) {\n sub._deactivate();\n });\n self._namedSubs = new Map();\n\n self._universalSubs.forEach(function (sub) {\n sub._deactivate();\n });\n self._universalSubs = [];\n },\n\n // Determine the remote client's IP address, based on the\n // HTTP_FORWARDED_COUNT environment variable representing how many\n // proxies the server is behind.\n _clientAddress: function () {\n var self = this;\n\n // For the reported client address for a connection to be correct,\n // the developer must set the HTTP_FORWARDED_COUNT environment\n // variable to an integer representing the number of hops they\n // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n // server is behind one proxy.\n //\n // This could be computed once at startup instead of every time.\n var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n if (httpForwardedCount === 0)\n return self.socket.remoteAddress;\n\n var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n if (! _.isString(forwardedFor))\n return null;\n forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n // Typically the first value in the `x-forwarded-for` header is\n // the original IP address of the client connecting to the first\n // proxy. However, the end user can easily spoof the header, in\n // which case the first value(s) will be the fake IP address from\n // the user pretending to be a proxy reporting the original IP\n // address value. By counting HTTP_FORWARDED_COUNT back from the\n // end of the list, we ensure that we get the IP address being\n // reported by *our* first proxy.\n\n if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n return null;\n\n return forwardedFor[forwardedFor.length - httpForwardedCount];\n }\n});\n\n/******************************************************************************/\n/* Subscription */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n session, handler, subscriptionId, params, name) {\n var self = this;\n self._session = session; // type is Session\n\n /**\n * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n * @locus Server\n * @name connection\n * @memberOf Subscription\n * @instance\n */\n self.connection = session.connectionHandle; // public API object\n\n self._handler = handler;\n\n // my subscription ID (generated by client, undefined for universal subs).\n self._subscriptionId = subscriptionId;\n // undefined for universal subs\n self._name = name;\n\n self._params = params || [];\n\n // Only named subscriptions have IDs, but we need some sort of string\n // internally to keep track of all subscriptions inside\n // SessionDocumentViews. We use this subscriptionHandle for that.\n if (self._subscriptionId) {\n self._subscriptionHandle = 'N' + self._subscriptionId;\n } else {\n self._subscriptionHandle = 'U' + Random.id();\n }\n\n // has _deactivate been called?\n self._deactivated = false;\n\n // stop callbacks to g/c this sub. called w/ zero arguments.\n self._stopCallbacks = [];\n\n // the set of (collection, documentid) that this subscription has\n // an opinion about\n self._documents = new Map();\n\n // remember if we are ready.\n self._ready = false;\n\n // Part of the public API: the user of this sub.\n\n /**\n * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n * @locus Server\n * @memberOf Subscription\n * @name userId\n * @instance\n */\n self.userId = session.userId;\n\n // For now, the id filter is going to default to\n // the to/from DDP methods on MongoID, to\n // specifically deal with mongo/minimongo ObjectIds.\n\n // Later, you will be able to make this be \"raw\"\n // if you want to publish a collection that you know\n // just has strings for keys and no funny business, to\n // a ddp consumer that isn't minimongo\n\n self._idFilter = {\n idStringify: MongoID.idStringify,\n idParse: MongoID.idParse\n };\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n _runHandler: function () {\n // XXX should we unblock() here? Either before running the publish\n // function, or before running _publishCursor.\n //\n // Right now, each publish function blocks all future publishes and\n // methods waiting on data from Mongo (or whatever else the function\n // blocks on). This probably slows page load in common cases.\n\n var self = this;\n try {\n var res = DDP._CurrentPublicationInvocation.withValue(\n self,\n () => maybeAuditArgumentChecks(\n self._handler, self, EJSON.clone(self._params),\n // It's OK that this would look weird for universal subscriptions,\n // because they have no arguments so there can never be an\n // audit-argument-checks failure.\n \"publisher '\" + self._name + \"'\"\n )\n );\n } catch (e) {\n self.error(e);\n return;\n }\n\n // Did the handler call this.error or this.stop?\n if (self._isDeactivated())\n return;\n\n self._publishHandlerResult(res);\n },\n\n _publishHandlerResult: function (res) {\n // SPECIAL CASE: Instead of writing their own callbacks that invoke\n // this.added/changed/ready/etc, the user can just return a collection\n // cursor or array of cursors from the publish function; we call their\n // _publishCursor method which starts observing the cursor and publishes the\n // results. Note that _publishCursor does NOT call ready().\n //\n // XXX This uses an undocumented interface which only the Mongo cursor\n // interface publishes. Should we make this interface public and encourage\n // users to implement it themselves? Arguably, it's unnecessary; users can\n // already write their own functions like\n // var publishMyReactiveThingy = function (name, handler) {\n // Meteor.publish(name, function () {\n // var reactiveThingy = handler();\n // reactiveThingy.publishMe();\n // });\n // };\n\n var self = this;\n var isCursor = function (c) {\n return c && c._publishCursor;\n };\n if (isCursor(res)) {\n try {\n res._publishCursor(self);\n } catch (e) {\n self.error(e);\n return;\n }\n // _publishCursor only returns after the initial added callbacks have run.\n // mark subscription as ready.\n self.ready();\n } else if (_.isArray(res)) {\n // check all the elements are cursors\n if (! _.all(res, isCursor)) {\n self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n return;\n }\n // find duplicate collection names\n // XXX we should support overlapping cursors, but that would require the\n // merge box to allow overlap within a subscription\n var collectionNames = {};\n for (var i = 0; i < res.length; ++i) {\n var collectionName = res[i]._getCollectionName();\n if (_.has(collectionNames, collectionName)) {\n self.error(new Error(\n \"Publish function returned multiple cursors for collection \" +\n collectionName));\n return;\n }\n collectionNames[collectionName] = true;\n };\n\n try {\n _.each(res, function (cur) {\n cur._publishCursor(self);\n });\n } catch (e) {\n self.error(e);\n return;\n }\n self.ready();\n } else if (res) {\n // truthy values other than cursors or arrays are probably a\n // user mistake (possible returning a Mongo document via, say,\n // `coll.findOne()`).\n self.error(new Error(\"Publish function can only return a Cursor or \"\n + \"an array of Cursors\"));\n }\n },\n\n // This calls all stop callbacks and prevents the handler from updating any\n // SessionCollectionViews further. It's used when the user unsubscribes or\n // disconnects, as well as during setUserId re-runs. It does *NOT* send\n // removed messages for the published objects; if that is necessary, call\n // _removeAllDocuments first.\n _deactivate: function() {\n var self = this;\n if (self._deactivated)\n return;\n self._deactivated = true;\n self._callStopCallbacks();\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", -1);\n },\n\n _callStopCallbacks: function () {\n var self = this;\n // tell listeners, so they can clean up\n var callbacks = self._stopCallbacks;\n self._stopCallbacks = [];\n _.each(callbacks, function (callback) {\n callback();\n });\n },\n\n // Send remove messages for every document.\n _removeAllDocuments: function () {\n var self = this;\n Meteor._noYieldsAllowed(function () {\n self._documents.forEach(function (collectionDocs, collectionName) {\n collectionDocs.forEach(function (strId) {\n self.removed(collectionName, self._idFilter.idParse(strId));\n });\n });\n });\n },\n\n // Returns a new Subscription for the same session with the same\n // initial creation parameters. This isn't a clone: it doesn't have\n // the same _documents cache, stopped state or callbacks; may have a\n // different _subscriptionHandle, and gets its userId from the\n // session, not from this object.\n _recreate: function () {\n var self = this;\n return new Subscription(\n self._session, self._handler, self._subscriptionId, self._params,\n self._name);\n },\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n * @locus Server\n * @param {Error} error The error to pass to the client.\n * @instance\n * @memberOf Subscription\n */\n error: function (error) {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId, error);\n },\n\n // Note that while our DDP client will notice that you've called stop() on the\n // server (and clean up its _subscriptions table) we don't actually provide a\n // mechanism for an app to notice this (the subscribe onError callback only\n // triggers if there is an error).\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error.\n * @locus Server\n * @instance\n * @memberOf Subscription\n */\n stop: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId);\n },\n\n /**\n * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {Function} func The callback function\n */\n onStop: function (callback) {\n var self = this;\n callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n if (self._isDeactivated())\n callback();\n else\n self._stopCallbacks.push(callback);\n },\n\n // This returns true if the sub has been deactivated, *OR* if the session was\n // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n // happened yet.\n _isDeactivated: function () {\n var self = this;\n return self._deactivated || self._session.inQueue === null;\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the new document.\n * @param {String} id The new document's ID.\n * @param {Object} fields The fields in the new document. If `_id` is present it is ignored.\n */\n added: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n let ids = self._documents.get(collectionName);\n if (ids == null) {\n ids = new Set();\n self._documents.set(collectionName, ids);\n }\n ids.add(id);\n self._session.added(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the changed document.\n * @param {String} id The changed document's ID.\n * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored.\n */\n changed: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that the document has been removed from.\n * @param {String} id The ID of the document that has been removed.\n */\n removed: function (collectionName, id) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n // We don't bother to delete sets of things in a collection if the\n // collection is empty. It could break _removeAllDocuments.\n self._documents.get(collectionName).delete(id);\n self._session.removed(self._subscriptionHandle, collectionName, id);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any.\n * @locus Server\n * @memberOf Subscription\n * @instance\n */\n ready: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n if (!self._subscriptionId)\n return; // unnecessary but ignored for universal sub\n if (!self._ready) {\n self._session.sendReady([self._subscriptionId]);\n self._ready = true;\n }\n }\n});\n\n/******************************************************************************/\n/* Server */\n/******************************************************************************/\n\nServer = function (options) {\n var self = this;\n\n // The default heartbeat interval is 30 seconds on the server and 35\n // seconds on the client. Since the client doesn't need to send a\n // ping as long as it is receiving pings, this means that pings\n // normally go from the server to the client.\n //\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n self.options = _.defaults(options || {}, {\n heartbeatInterval: 15000,\n heartbeatTimeout: 15000,\n // For testing, allow responding to pings to be disabled.\n respondToPings: true\n });\n\n // Map of callbacks to call when a new connection comes in to the\n // server and completes DDP version negotiation. Use an object instead\n // of an array so we can safely remove one from the list while\n // iterating over it.\n self.onConnectionHook = new Hook({\n debugPrintExceptions: \"onConnection callback\"\n });\n\n // Map of callbacks to call when a new message comes in.\n self.onMessageHook = new Hook({\n debugPrintExceptions: \"onMessage callback\"\n });\n\n self.publish_handlers = {};\n self.universal_publish_handlers = [];\n\n self.method_handlers = {};\n\n self.sessions = new Map(); // map from id to session\n\n self.stream_server = new StreamServer;\n\n self.stream_server.register(function (socket) {\n // socket implements the SockJSConnection interface\n socket._meteorSession = null;\n\n var sendError = function (reason, offendingMessage) {\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n socket.send(DDPCommon.stringifyDDP(msg));\n };\n\n socket.on('data', function (raw_msg) {\n if (Meteor._printReceivedDDP) {\n Meteor._debug(\"Received DDP\", raw_msg);\n }\n try {\n try {\n var msg = DDPCommon.parseDDP(raw_msg);\n } catch (err) {\n sendError('Parse error');\n return;\n }\n if (msg === null || !msg.msg) {\n sendError('Bad request', msg);\n return;\n }\n\n if (msg.msg === 'connect') {\n if (socket._meteorSession) {\n sendError(\"Already connected\", msg);\n return;\n }\n Fiber(function () {\n self._handleConnect(socket, msg);\n }).run();\n return;\n }\n\n if (!socket._meteorSession) {\n sendError('Must connect first', msg);\n return;\n }\n socket._meteorSession.processMessage(msg);\n } catch (e) {\n // XXX print stack nicely\n Meteor._debug(\"Internal exception while processing message\", msg, e);\n }\n });\n\n socket.on('close', function () {\n if (socket._meteorSession) {\n Fiber(function () {\n socket._meteorSession.close();\n }).run();\n }\n });\n });\n};\n\n_.extend(Server.prototype, {\n\n /**\n * @summary Register a callback to be called when a new DDP connection is made to the server.\n * @locus Server\n * @param {function} callback The function to call when a new DDP connection is established.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onConnection: function (fn) {\n var self = this;\n return self.onConnectionHook.register(fn);\n },\n\n /**\n * @summary Register a callback to be called when a new DDP message is received.\n * @locus Server\n * @param {function} callback The function to call when a new DDP message is received.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onMessage: function (fn) {\n var self = this;\n return self.onMessageHook.register(fn);\n },\n\n _handleConnect: function (socket, msg) {\n var self = this;\n\n // The connect message must specify a version and an array of supported\n // versions, and it must claim to support what it is proposing.\n if (!(typeof (msg.version) === 'string' &&\n _.isArray(msg.support) &&\n _.all(msg.support, _.isString) &&\n _.contains(msg.support, msg.version))) {\n socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n socket.close();\n return;\n }\n\n // In the future, handle session resumption: something like:\n // socket._meteorSession = self.sessions[msg.session]\n var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n if (msg.version !== version) {\n // The best version to use (according to the client's stated preferences)\n // is not the one the client is trying to use. Inform them about the best\n // version to use.\n socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n socket.close();\n return;\n }\n\n // Yay, version matches! Create a new session.\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n socket._meteorSession = new Session(self, version, socket, self.options);\n self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n self.onConnectionHook.each(function (callback) {\n if (socket._meteorSession)\n callback(socket._meteorSession.connectionHandle);\n return true;\n });\n },\n /**\n * Register a publish handler function.\n *\n * @param name {String} identifier for query\n * @param handler {Function} publish handler\n * @param options {Object}\n *\n * Server will call handler function on each new subscription,\n * either when receiving DDP sub message for a named subscription, or on\n * DDP connect for a universal subscription.\n *\n * If name is null, this will be a subscription that is\n * automatically established and permanently on for all connected\n * client, instead of a subscription that can be turned on and off\n * with subscribe().\n *\n * options to contain:\n * - (mostly internal) is_auto: true if generated automatically\n * from an autopublish hook. this is for cosmetic purposes only\n * (it lets us determine whether to print a warning suggesting\n * that you turn off autopublish.)\n */\n\n /**\n * @summary Publish a record set.\n * @memberOf Meteor\n * @importFromPackage meteor\n * @locus Server\n * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments.\n */\n publish: function (name, handler, options) {\n var self = this;\n\n if (! _.isObject(name)) {\n options = options || {};\n\n if (name && name in self.publish_handlers) {\n Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n return;\n }\n\n if (Package.autopublish && !options.is_auto) {\n // They have autopublish on, yet they're trying to manually\n // picking stuff to publish. They probably should turn off\n // autopublish. (This check isn't perfect -- if you create a\n // publish before you turn on autopublish, it won't catch\n // it. But this will definitely handle the simple case where\n // you've added the autopublish package to your app, and are\n // calling publish from your app code.)\n if (!self.warned_about_autopublish) {\n self.warned_about_autopublish = true;\n Meteor._debug(\n \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n \"** will still be sent to all clients.\\n\" +\n \"**\\n\" +\n \"** Turn off autopublish by removing the autopublish package:\\n\" +\n \"**\\n\" +\n \"** $ meteor remove autopublish\\n\" +\n \"**\\n\" +\n \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n \"** for each collection that you want clients to see.\\n\");\n }\n }\n\n if (name)\n self.publish_handlers[name] = handler;\n else {\n self.universal_publish_handlers.push(handler);\n // Spin up the new publisher on any existing session too. Run each\n // session's subscription in a new Fiber, so that there's no change for\n // self.sessions to change while we're running this loop.\n self.sessions.forEach(function (session) {\n if (!session._dontStartNewUniversalSubs) {\n Fiber(function() {\n session._startSubscription(handler);\n }).run();\n }\n });\n }\n }\n else{\n _.each(name, function(value, key) {\n self.publish(key, value, {});\n });\n }\n },\n\n _removeSession: function (session) {\n var self = this;\n self.sessions.delete(session.id);\n },\n\n /**\n * @summary Defines functions that can be invoked over the network by clients.\n * @locus Anywhere\n * @param {Object} methods Dictionary whose keys are method names and values are functions.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n methods: function (methods) {\n var self = this;\n _.each(methods, function (func, name) {\n if (typeof func !== 'function')\n throw new Error(\"Method '\" + name + \"' must be a function\");\n if (self.method_handlers[name])\n throw new Error(\"A method named '\" + name + \"' is already defined\");\n self.method_handlers[name] = func;\n });\n },\n\n call: function (name, ...args) {\n if (args.length && typeof args[args.length - 1] === \"function\") {\n // If it's a function, the last argument is the result callback, not\n // a parameter to the remote method.\n var callback = args.pop();\n }\n\n return this.apply(name, args, callback);\n },\n\n // A version of the call method that always returns a Promise.\n callAsync: function (name, ...args) {\n return this.applyAsync(name, args);\n },\n\n apply: function (name, args, options, callback) {\n // We were passed 3 arguments. They may be either (name, args, options)\n // or (name, args, callback)\n if (! callback && typeof options === 'function') {\n callback = options;\n options = {};\n } else {\n options = options || {};\n }\n\n const promise = this.applyAsync(name, args, options);\n\n // Return the result in whichever way the caller asked for it. Note that we\n // do NOT block on the write fence in an analogous way to how the client\n // blocks on the relevant data being visible, so you are NOT guaranteed that\n // cursor observe callbacks have fired when your callback is invoked. (We\n // can change this if there's a real use case.)\n if (callback) {\n promise.then(\n result => callback(undefined, result),\n exception => callback(exception)\n );\n } else {\n return promise.await();\n }\n },\n\n // @param options {Optional Object}\n applyAsync: function (name, args, options) {\n // Run the handler\n var handler = this.method_handlers[name];\n if (! handler) {\n return Promise.reject(\n new Meteor.Error(404, `Method '${name}' not found`)\n );\n }\n\n // If this is a method call from within another method or publish function,\n // get the user state from the outer method or publish function, otherwise\n // don't allow setUserId to be called\n var userId = null;\n var setUserId = function() {\n throw new Error(\"Can't call setUserId on a server initiated method call\");\n };\n var connection = null;\n var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n var randomSeed = null;\n if (currentMethodInvocation) {\n userId = currentMethodInvocation.userId;\n setUserId = function(userId) {\n currentMethodInvocation.setUserId(userId);\n };\n connection = currentMethodInvocation.connection;\n randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n } else if (currentPublicationInvocation) {\n userId = currentPublicationInvocation.userId;\n setUserId = function(userId) {\n currentPublicationInvocation._session._setUserId(userId);\n };\n connection = currentPublicationInvocation.connection;\n }\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId,\n setUserId,\n connection,\n randomSeed\n });\n\n return new Promise(resolve => resolve(\n DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, EJSON.clone(args),\n \"internal call to '\" + name + \"'\"\n )\n )\n )).then(EJSON.clone);\n },\n\n _urlForSession: function (sessionId) {\n var self = this;\n var session = self.sessions.get(sessionId);\n if (session)\n return session._socketUrl;\n else\n return null;\n }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n serverSupportedVersions) {\n var correctVersion = _.find(clientSupportedVersions, function (version) {\n return _.contains(serverSupportedVersions, version);\n });\n if (!correctVersion) {\n correctVersion = serverSupportedVersions[0];\n }\n return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n if (!exception) return exception;\n\n // To allow packages to throw errors intended for the client but not have to\n // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n // error before it is thrown.\n if (exception.isClientSafe) {\n if (!(exception instanceof Meteor.Error)) {\n const originalMessage = exception.message;\n exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n exception.message = originalMessage;\n }\n return exception;\n }\n\n // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n // the server log.\n if (!exception._expectedByTest) {\n Meteor._debug(\"Exception \" + context, exception.stack);\n if (exception.sanitizedError) {\n Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n Meteor._debug();\n }\n }\n\n // Did the error contain more details that could have been useful if caught in\n // server code (or if thrown from non-client-originated code), but also\n // provided a \"sanitized\" version with more context than 500 Internal server\n // error? Use that.\n if (exception.sanitizedError) {\n if (exception.sanitizedError.isClientSafe)\n return exception.sanitizedError;\n Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n \"does not have isClientSafe property set; ignoring\");\n }\n\n return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n args = args || [];\n if (Package['audit-argument-checks']) {\n return Match._failIfArgumentsAreNotAllChecked(\n f, context, args, description);\n }\n return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n var self = this;\n\n self.armed = false;\n self.fired = false;\n self.retired = false;\n self.outstanding_writes = 0;\n self.before_fire_callbacks = [];\n self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n // Start tracking a write, and return an object to represent it. The\n // object has a single method, committed(). This method should be\n // called when the write is fully committed and propagated. You can\n // continue to add writes to the WriteFence up until it is triggered\n // (calls its callbacks because all writes have committed.)\n beginWrite: function () {\n var self = this;\n\n if (self.retired)\n return { committed: function () {} };\n\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to add writes\");\n\n self.outstanding_writes++;\n var committed = false;\n return {\n committed: function () {\n if (committed)\n throw new Error(\"committed called twice on the same write\");\n committed = true;\n self.outstanding_writes--;\n self._maybeFire();\n }\n };\n },\n\n // Arm the fence. Once the fence is armed, and there are no more\n // uncommitted writes, it will activate.\n arm: function () {\n var self = this;\n if (self === DDPServer._CurrentWriteFence.get())\n throw Error(\"Can't arm the current fence\");\n self.armed = true;\n self._maybeFire();\n },\n\n // Register a function to be called once before firing the fence.\n // Callback function can add new writes to the fence, in which case\n // it won't fire until those writes are done as well.\n onBeforeFire: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.before_fire_callbacks.push(func);\n },\n\n // Register a function to be called when the fence fires.\n onAllCommitted: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.completion_callbacks.push(func);\n },\n\n // Convenience function. Arms the fence, then blocks until it fires.\n armAndWait: function () {\n var self = this;\n var future = new Future;\n self.onAllCommitted(function () {\n future['return']();\n });\n self.arm();\n future.wait();\n },\n\n _maybeFire: function () {\n var self = this;\n if (self.fired)\n throw new Error(\"write fence already activated?\");\n if (self.armed && !self.outstanding_writes) {\n function invokeCallback (func) {\n try {\n func(self);\n } catch (err) {\n Meteor._debug(\"exception in write fence callback\", err);\n }\n }\n\n self.outstanding_writes++;\n while (self.before_fire_callbacks.length > 0) {\n var callbacks = self.before_fire_callbacks;\n self.before_fire_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n self.outstanding_writes--;\n\n if (!self.outstanding_writes) {\n self.fired = true;\n var callbacks = self.completion_callbacks;\n self.completion_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n }\n },\n\n // Deactivate this fence so that adding more writes has no effect.\n // The fence must have already fired.\n retire: function () {\n var self = this;\n if (! self.fired)\n throw new Error(\"Can't retire a fence that hasn't fired.\");\n self.retired = true;\n }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n var self = this;\n options = options || {};\n\n self.nextId = 1;\n // map from collection name (string) -> listener id -> object. each object has\n // keys 'trigger', 'callback'. As a hack, the empty string means \"no\n // collection\".\n self.listenersByCollection = {};\n self.listenersByCollectionCount = {};\n self.factPackage = options.factPackage || \"livedata\";\n self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n // msg is a trigger or a notification\n _collectionForMessage: function (msg) {\n var self = this;\n if (! _.has(msg, 'collection')) {\n return '';\n } else if (typeof(msg.collection) === 'string') {\n if (msg.collection === '')\n throw Error(\"Message has empty collection!\");\n return msg.collection;\n } else {\n throw Error(\"Message has non-string collection!\");\n }\n },\n\n // Listen for notification that match 'trigger'. A notification\n // matches if it has the key-value pairs in trigger as a\n // subset. When a notification matches, call 'callback', passing\n // the actual notification.\n //\n // Returns a listen handle, which is an object with a method\n // stop(). Call stop() to stop listening.\n //\n // XXX It should be legal to call fire() from inside a listen()\n // callback?\n listen: function (trigger, callback) {\n var self = this;\n var id = self.nextId++;\n\n var collection = self._collectionForMessage(trigger);\n var record = {trigger: EJSON.clone(trigger), callback: callback};\n if (! _.has(self.listenersByCollection, collection)) {\n self.listenersByCollection[collection] = {};\n self.listenersByCollectionCount[collection] = 0;\n }\n self.listenersByCollection[collection][id] = record;\n self.listenersByCollectionCount[collection]++;\n\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, 1);\n }\n\n return {\n stop: function () {\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, -1);\n }\n delete self.listenersByCollection[collection][id];\n self.listenersByCollectionCount[collection]--;\n if (self.listenersByCollectionCount[collection] === 0) {\n delete self.listenersByCollection[collection];\n delete self.listenersByCollectionCount[collection];\n }\n }\n };\n },\n\n // Fire the provided 'notification' (an object whose attribute\n // values are all JSON-compatibile) -- inform all matching listeners\n // (registered with listen()).\n //\n // If fire() is called inside a write fence, then each of the\n // listener callbacks will be called inside the write fence as well.\n //\n // The listeners may be invoked in parallel, rather than serially.\n fire: function (notification) {\n var self = this;\n\n var collection = self._collectionForMessage(notification);\n\n if (! _.has(self.listenersByCollection, collection)) {\n return;\n }\n\n var listenersForCollection = self.listenersByCollection[collection];\n var callbackIds = [];\n _.each(listenersForCollection, function (l, id) {\n if (self._matches(notification, l.trigger)) {\n callbackIds.push(id);\n }\n });\n\n // Listener callbacks can yield, so we need to first find all the ones that\n // match in a single iteration over self.listenersByCollection (which can't\n // be mutated during this iteration), and then invoke the matching\n // callbacks, checking before each call to ensure they haven't stopped.\n // Note that we don't have to check that\n // self.listenersByCollection[collection] still === listenersForCollection,\n // because the only way that stops being true is if listenersForCollection\n // first gets reduced down to the empty object (and then never gets\n // increased again).\n _.each(callbackIds, function (id) {\n if (_.has(listenersForCollection, id)) {\n listenersForCollection[id].callback(notification);\n }\n });\n },\n\n // A notification matches a trigger if all keys that exist in both are equal.\n //\n // Examples:\n // N:{collection: \"C\"} matches T:{collection: \"C\"}\n // (a non-targeted write to a collection matches a\n // non-targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n // (a targeted write to a collection matches a non-targeted query)\n // N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n // (a non-targeted write to a collection matches a\n // targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n // (a targeted write to a collection matches a targeted query targeted\n // at the same document)\n // N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n // (a targeted write to a collection does not match a targeted query\n // targeted at a different document)\n _matches: function (notification, trigger) {\n // Most notifications that use the crossbar have a string `collection` and\n // maybe an `id` that is a string or ObjectID. We're already dividing up\n // triggers by collection, but let's fast-track \"nope, different ID\" (and\n // avoid the overly generic EJSON.equals). This makes a noticeable\n // performance difference; see https://github.com/meteor/meteor/pull/3697\n if (typeof(notification.id) === 'string' &&\n typeof(trigger.id) === 'string' &&\n notification.id !== trigger.id) {\n return false;\n }\n if (notification.id instanceof MongoID.ObjectID &&\n trigger.id instanceof MongoID.ObjectID &&\n ! notification.id.equals(trigger.id)) {\n return false;\n }\n\n return _.all(trigger, function (triggerValue, key) {\n return !_.has(notification, key) ||\n EJSON.equals(triggerValue, notification[key]);\n });\n }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n function (name) {\n Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} \ No newline at end of file +{"version":3,"sources":["meteor://💻app/packages/ddp-server/stream_server.js","meteor://💻app/packages/ddp-server/livedata_server.js","meteor://💻app/packages/ddp-server/writefence.js","meteor://💻app/packages/ddp-server/crossbar.js","meteor://💻app/packages/ddp-server/server_convenience.js"],"names":["url","Npm","require","websocketExtensions","_","once","extensions","websocketCompressionConfig","process","env","SERVER_WEBSOCKET_COMPRESSION","JSON","parse","push","configure","pathPrefix","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","StreamServer","self","registration_callbacks","open_sockets","prefix","RoutePolicy","declare","sockjs","serverOptions","log","heartbeat_delay","disconnect_delay","disable_cors","DISABLE_SOCKJS_CORS","jsessionid","USE_JSESSIONID","DISABLE_WEBSOCKETS","websocket","faye_server_options","server","createServer","WebApp","httpServer","removeListener","_timeoutAdjustmentRequestCallback","installHandlers","addListener","_redirectWebsocketEndpoint","on","socket","setWebsocketTimeout","timeout","protocol","_session","recv","connection","setTimeout","send","data","write","without","stringify","server_id","each","callback","extend","prototype","register","all_sockets","values","event","oldHttpServerListeners","listeners","slice","removeAllListeners","newListener","request","args","arguments","parsedUrl","pathname","format","oldListener","apply","DDPServer","Fiber","SessionDocumentView","existsIn","Set","dataByKey","Map","_SessionDocumentView","getFields","ret","forEach","precedenceList","key","value","clearField","subscriptionHandle","changeCollector","get","removedValue","undefined","i","length","precedence","splice","delete","EJSON","equals","changeField","isAdd","clone","has","set","elt","find","SessionCollectionView","collectionName","sessionCallbacks","documents","callbacks","_SessionCollectionView","isEmpty","size","diff","previous","DiffSequence","diffMaps","both","bind","diffDocument","rightOnly","id","nowDV","added","leftOnly","prevDV","removed","fields","diffObjects","prev","now","changed","docView","add","changedResult","Error","err","Session","version","options","Random","initialized","inQueue","Meteor","_DoubleEndedQueue","blocked","workerRunning","_namedSubs","_universalSubs","userId","collectionViews","_isSending","_dontStartNewUniversalSubs","_pendingReady","_closeCallbacks","_socketUrl","_respondToPings","respondToPings","connectionHandle","close","onClose","fn","cb","bindEnvironment","defer","clientAddress","_clientAddress","httpHeaders","headers","msg","session","startUniversalSubs","run","heartbeatInterval","heartbeat","DDPCommon","Heartbeat","heartbeatTimeout","onTimeout","sendPing","start","Package","Facts","incrementServerFact","sendReady","subscriptionIds","subs","subscriptionId","sendAdded","collection","sendChanged","sendRemoved","getSendCallbacks","getCollectionView","view","handlers","universal_publish_handlers","handler","_startSubscription","stop","_meteorSession","_deactivateAllSubscriptions","_removeSession","_printSentDDP","_debug","stringifyDDP","sendError","reason","offendingMessage","processMessage","msg_in","messageReceived","processNext","shift","unblock","onMessageHook","protocol_handlers","call","sub","name","params","Array","publish_handlers","error","DDPRateLimiter","rateLimiterInput","type","connectionId","_increment","rateLimitResult","_check","allowed","getErrorMessage","timeToReset","unsub","_stopSubscription","method","randomSeed","fence","_WriteFence","onAllCommitted","retire","methods","method_handlers","arm","setUserId","_setUserId","invocation","MethodInvocation","isSimulation","promise","Promise","resolve","reject","_CurrentWriteFence","withValue","DDP","_CurrentMethodInvocation","maybeAuditArgumentChecks","finish","payload","then","result","exception","wrapInternalException","_eachSub","f","_diffCollectionViews","beforeCVs","leftValue","rightValue","doc","_deactivate","oldNamedSubs","newSub","_recreate","_runHandler","_noYieldsAllowed","subId","Subscription","subName","maybeSub","_name","_removeAllDocuments","response","httpForwardedCount","parseInt","remoteAddress","forwardedFor","isString","trim","split","_handler","_subscriptionId","_params","_subscriptionHandle","_deactivated","_stopCallbacks","_documents","_ready","_idFilter","idStringify","MongoID","idParse","res","_CurrentPublicationInvocation","e","_isDeactivated","_publishHandlerResult","isCursor","c","_publishCursor","ready","isArray","all","collectionNames","_getCollectionName","cur","_callStopCallbacks","collectionDocs","strId","onStop","ids","Server","defaults","onConnectionHook","Hook","debugPrintExceptions","sessions","stream_server","raw_msg","_printReceivedDDP","parseDDP","_handleConnect","onConnection","onMessage","support","contains","SUPPORTED_DDP_VERSIONS","calculateVersion","publish","isObject","autopublish","is_auto","warned_about_autopublish","func","pop","callAsync","applyAsync","await","currentMethodInvocation","currentPublicationInvocation","makeRpcSeed","_urlForSession","sessionId","clientSupportedVersions","serverSupportedVersions","correctVersion","_calculateVersion","context","isClientSafe","originalMessage","message","details","_expectedByTest","stack","sanitizedError","description","Match","_failIfArgumentsAreNotAllChecked","Future","armed","fired","retired","outstanding_writes","before_fire_callbacks","completion_callbacks","EnvironmentVariable","beginWrite","committed","_maybeFire","onBeforeFire","armAndWait","future","wait","invokeCallback","_Crossbar","nextId","listenersByCollection","listenersByCollectionCount","factPackage","factName","_collectionForMessage","listen","trigger","record","fire","notification","listenersForCollection","callbackIds","l","_matches","ObjectID","triggerValue","_InvalidationCrossbar","DDP_DEFAULT_CONNECTION_URL","refresh","default_server"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAIA,GAAG,GAAGC,GAAG,CAACC,OAAJ,CAAY,KAAZ,CAAV,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACA,IAAIC,mBAAmB,GAAGC,CAAC,CAACC,IAAF,CAAO,YAAY;AAC3C,MAAIC,UAAU,GAAG,EAAjB;AAEA,MAAIC,0BAA0B,GAAGC,OAAO,CAACC,GAAR,CAAYC,4BAAZ,GAC7BC,IAAI,CAACC,KAAL,CAAWJ,OAAO,CAACC,GAAR,CAAYC,4BAAvB,CAD6B,GAC0B,EAD3D;;AAEA,MAAIH,0BAAJ,EAAgC;AAC9BD,cAAU,CAACO,IAAX,CAAgBZ,GAAG,CAACC,OAAJ,CAAY,oBAAZ,EAAkCY,SAAlC,CACdP,0BADc,CAAhB;AAGD;;AAED,SAAOD,UAAP;AACD,CAZyB,CAA1B;;AAcA,IAAIS,UAAU,GAAGC,yBAAyB,CAACC,oBAA1B,IAAkD,EAAnE;;AAEAC,YAAY,GAAG,YAAY;AACzB,MAAIC,IAAI,GAAG,IAAX;AACAA,MAAI,CAACC,sBAAL,GAA8B,EAA9B;AACAD,MAAI,CAACE,YAAL,GAAoB,EAApB,CAHyB,CAKzB;AACA;;AACAF,MAAI,CAACG,MAAL,GAAcP,UAAU,GAAG,SAA3B;AACAQ,aAAW,CAACC,OAAZ,CAAoBL,IAAI,CAACG,MAAL,GAAc,GAAlC,EAAuC,SAAvC,EARyB,CAUzB;;AACA,MAAIG,MAAM,GAAGxB,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAb;;AACA,MAAIwB,aAAa,GAAG;AAClBJ,UAAM,EAAEH,IAAI,CAACG,MADK;AAElBK,OAAG,EAAE,YAAY,CAAG,CAFF;AAGlB;AACA;AACAC,mBAAe,EAAE,KALC;AAMlB;AACA;AACA;AACA;AACA;AACA;AACAC,oBAAgB,EAAE,KAAK,IAZL;AAalB;AACA;AACAC,gBAAY,EAAE,CAAC,CAACtB,OAAO,CAACC,GAAR,CAAYsB,mBAfV;AAgBlB;AACA;AACA;AACAC,cAAU,EAAE,CAAC,CAACxB,OAAO,CAACC,GAAR,CAAYwB;AAnBR,GAApB,CAZyB,CAkCzB;AACA;AACA;AACA;;AACA,MAAIzB,OAAO,CAACC,GAAR,CAAYyB,kBAAhB,EAAoC;AAClCR,iBAAa,CAACS,SAAd,GAA0B,KAA1B;AACD,GAFD,MAEO;AACLT,iBAAa,CAACU,mBAAd,GAAoC;AAClC9B,gBAAU,EAAEH,mBAAmB;AADG,KAApC;AAGD;;AAEDgB,MAAI,CAACkB,MAAL,GAAcZ,MAAM,CAACa,YAAP,CAAoBZ,aAApB,CAAd,CA9CyB,CAgDzB;AACA;AACA;AACA;;AACAa,QAAM,CAACC,UAAP,CAAkBC,cAAlB,CACE,SADF,EACaF,MAAM,CAACG,iCADpB;AAEAvB,MAAI,CAACkB,MAAL,CAAYM,eAAZ,CAA4BJ,MAAM,CAACC,UAAnC;AACAD,QAAM,CAACC,UAAP,CAAkBI,WAAlB,CACE,SADF,EACaL,MAAM,CAACG,iCADpB,EAvDyB,CA0DzB;;AACAvB,MAAI,CAAC0B,0BAAL;;AAEA1B,MAAI,CAACkB,MAAL,CAAYS,EAAZ,CAAe,YAAf,EAA6B,UAAUC,MAAV,EAAkB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAA,UAAM,CAACC,mBAAP,GAA6B,UAAUC,OAAV,EAAmB;AAC9C,UAAI,CAACF,MAAM,CAACG,QAAP,KAAoB,WAApB,IACHH,MAAM,CAACG,QAAP,KAAoB,eADlB,KAECH,MAAM,CAACI,QAAP,CAAgBC,IAFrB,EAE2B;AACzBL,cAAM,CAACI,QAAP,CAAgBC,IAAhB,CAAqBC,UAArB,CAAgCC,UAAhC,CAA2CL,OAA3C;AACD;AACF,KAND;;AAOAF,UAAM,CAACC,mBAAP,CAA2B,KAAK,IAAhC;;AAEAD,UAAM,CAACQ,IAAP,GAAc,UAAUC,IAAV,EAAgB;AAC5BT,YAAM,CAACU,KAAP,CAAaD,IAAb;AACD,KAFD;;AAGAT,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7B3B,UAAI,CAACE,YAAL,GAAoBjB,CAAC,CAACsD,OAAF,CAAUvC,IAAI,CAACE,YAAf,EAA6B0B,MAA7B,CAApB;AACD,KAFD;AAGA5B,QAAI,CAACE,YAAL,CAAkBR,IAAlB,CAAuBkC,MAAvB,EA1B6C,CA4B7C;AACA;AACA;AACA;AACA;;AACAA,UAAM,CAACQ,IAAP,CAAY5C,IAAI,CAACgD,SAAL,CAAe;AAAEC,eAAS,EAAE;AAAb,KAAf,CAAZ,EAjC6C,CAmC7C;AACA;;AACAxD,KAAC,CAACyD,IAAF,CAAO1C,IAAI,CAACC,sBAAZ,EAAoC,UAAU0C,QAAV,EAAoB;AACtDA,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAxCD;AA0CD,CAvGD;;AAyGA3C,CAAC,CAAC2D,MAAF,CAAS7C,YAAY,CAAC8C,SAAtB,EAAiC;AAC/B;AACA;AACAC,UAAQ,EAAE,UAAUH,QAAV,EAAoB;AAC5B,QAAI3C,IAAI,GAAG,IAAX;AACAA,QAAI,CAACC,sBAAL,CAA4BP,IAA5B,CAAiCiD,QAAjC;;AACA1D,KAAC,CAACyD,IAAF,CAAO1C,IAAI,CAAC+C,WAAL,EAAP,EAA2B,UAAUnB,MAAV,EAAkB;AAC3Ce,cAAQ,CAACf,MAAD,CAAR;AACD,KAFD;AAGD,GAT8B;AAW/B;AACAmB,aAAW,EAAE,YAAY;AACvB,QAAI/C,IAAI,GAAG,IAAX;AACA,WAAOf,CAAC,CAAC+D,MAAF,CAAShD,IAAI,CAACE,YAAd,CAAP;AACD,GAf8B;AAiB/B;AACA;AACAwB,4BAA0B,EAAE,YAAY;AACtC,QAAI1B,IAAI,GAAG,IAAX,CADsC,CAEtC;AACA;AACA;AACA;AACA;;AACAf,KAAC,CAACyD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,CAAP,EAA+B,UAAUO,KAAV,EAAiB;AAC9C,UAAI5B,UAAU,GAAGD,MAAM,CAACC,UAAxB;AACA,UAAI6B,sBAAsB,GAAG7B,UAAU,CAAC8B,SAAX,CAAqBF,KAArB,EAA4BG,KAA5B,CAAkC,CAAlC,CAA7B;AACA/B,gBAAU,CAACgC,kBAAX,CAA8BJ,KAA9B,EAH8C,CAK9C;AACA;;AACA,UAAIK,WAAW,GAAG,UAAUC;AAAQ;AAAlB,QAAwC;AACxD;AACA,YAAIC,IAAI,GAAGC,SAAX,CAFwD,CAIxD;AACA;;AACA,YAAIC,SAAS,GAAG7E,GAAG,CAACY,KAAJ,CAAU8D,OAAO,CAAC1E,GAAlB,CAAhB;;AACA,YAAI6E,SAAS,CAACC,QAAV,KAAuB/D,UAAU,GAAG,YAApC,IACF8D,SAAS,CAACC,QAAV,KAAuB/D,UAAU,GAAG,aADtC,EACqD;AACnD8D,mBAAS,CAACC,QAAV,GAAqB3D,IAAI,CAACG,MAAL,GAAc,YAAnC;AACAoD,iBAAO,CAAC1E,GAAR,GAAcA,GAAG,CAAC+E,MAAJ,CAAWF,SAAX,CAAd;AACD;;AACDzE,SAAC,CAACyD,IAAF,CAAOQ,sBAAP,EAA+B,UAAUW,WAAV,EAAuB;AACpDA,qBAAW,CAACC,KAAZ,CAAkBzC,UAAlB,EAA8BmC,IAA9B;AACD,SAFD;AAGD,OAfD;;AAgBAnC,gBAAU,CAACI,WAAX,CAAuBwB,KAAvB,EAA8BK,WAA9B;AACD,KAxBD;AAyBD;AAnD8B,CAAjC,E;;;;;;;;;;;ACtIAS,SAAS,GAAG,EAAZ;;AAEA,IAAIC,KAAK,GAAGlF,GAAG,CAACC,OAAJ,CAAY,QAAZ,CAAZ,C,CAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;AACA,IAAIkF,mBAAmB,GAAG,YAAY;AACpC,MAAIjE,IAAI,GAAG,IAAX;AACAA,MAAI,CAACkE,QAAL,GAAgB,IAAIC,GAAJ,EAAhB,CAFoC,CAET;;AAC3BnE,MAAI,CAACoE,SAAL,GAAiB,IAAIC,GAAJ,EAAjB,CAHoC,CAGR;AAC7B,CAJD;;AAMAN,SAAS,CAACO,oBAAV,GAAiCL,mBAAjC;;AAGAhF,CAAC,CAAC2D,MAAF,CAASqB,mBAAmB,CAACpB,SAA7B,EAAwC;AAEtC0B,WAAS,EAAE,YAAY;AACrB,QAAIvE,IAAI,GAAG,IAAX;AACA,QAAIwE,GAAG,GAAG,EAAV;AACAxE,QAAI,CAACoE,SAAL,CAAeK,OAAf,CAAuB,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACpDH,SAAG,CAACG,GAAD,CAAH,GAAWD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7B;AACD,KAFD;AAGA,WAAOJ,GAAP;AACD,GATqC;AAWtCK,YAAU,EAAE,UAAUC,kBAAV,EAA8BH,GAA9B,EAAmCI,eAAnC,EAAoD;AAC9D,QAAI/E,IAAI,GAAG,IAAX,CAD8D,CAE9D;;AACA,QAAI2E,GAAG,KAAK,KAAZ,EACE;AACF,QAAID,cAAc,GAAG1E,IAAI,CAACoE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB,CAL8D,CAO9D;AACA;;AACA,QAAI,CAACD,cAAL,EACE;AAEF,QAAIO,YAAY,GAAGC,SAAnB;;AACA,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGT,cAAc,CAACU,MAAnC,EAA2CD,CAAC,EAA5C,EAAgD;AAC9C,UAAIE,UAAU,GAAGX,cAAc,CAACS,CAAD,CAA/B;;AACA,UAAIE,UAAU,CAACP,kBAAX,KAAkCA,kBAAtC,EAA0D;AACxD;AACA;AACA,YAAIK,CAAC,KAAK,CAAV,EACEF,YAAY,GAAGI,UAAU,CAACT,KAA1B;AACFF,sBAAc,CAACY,MAAf,CAAsBH,CAAtB,EAAyB,CAAzB;AACA;AACD;AACF;;AACD,QAAIT,cAAc,CAACU,MAAf,KAA0B,CAA9B,EAAiC;AAC/BpF,UAAI,CAACoE,SAAL,CAAemB,MAAf,CAAsBZ,GAAtB;AACAI,qBAAe,CAACJ,GAAD,CAAf,GAAuBO,SAAvB;AACD,KAHD,MAGO,IAAID,YAAY,KAAKC,SAAjB,IACA,CAACM,KAAK,CAACC,MAAN,CAAaR,YAAb,EAA2BP,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAA7C,CADL,EAC0D;AAC/DG,qBAAe,CAACJ,GAAD,CAAf,GAAuBD,cAAc,CAAC,CAAD,CAAd,CAAkBE,KAAzC;AACD;AACF,GA1CqC;AA4CtCc,aAAW,EAAE,UAAUZ,kBAAV,EAA8BH,GAA9B,EAAmCC,KAAnC,EACUG,eADV,EAC2BY,KAD3B,EACkC;AAC7C,QAAI3F,IAAI,GAAG,IAAX,CAD6C,CAE7C;;AACA,QAAI2E,GAAG,KAAK,KAAZ,EACE,OAJ2C,CAM7C;;AACAC,SAAK,GAAGY,KAAK,CAACI,KAAN,CAAYhB,KAAZ,CAAR;;AAEA,QAAI,CAAC5E,IAAI,CAACoE,SAAL,CAAeyB,GAAf,CAAmBlB,GAAnB,CAAL,EAA8B;AAC5B3E,UAAI,CAACoE,SAAL,CAAe0B,GAAf,CAAmBnB,GAAnB,EAAwB,CAAC;AAACG,0BAAkB,EAAEA,kBAArB;AACCF,aAAK,EAAEA;AADR,OAAD,CAAxB;AAEAG,qBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACA;AACD;;AACD,QAAIF,cAAc,GAAG1E,IAAI,CAACoE,SAAL,CAAeY,GAAf,CAAmBL,GAAnB,CAArB;AACA,QAAIoB,GAAJ;;AACA,QAAI,CAACJ,KAAL,EAAY;AACVI,SAAG,GAAGrB,cAAc,CAACsB,IAAf,CAAoB,UAAUX,UAAV,EAAsB;AAC5C,eAAOA,UAAU,CAACP,kBAAX,KAAkCA,kBAAzC;AACH,OAFK,CAAN;AAGD;;AAED,QAAIiB,GAAJ,EAAS;AACP,UAAIA,GAAG,KAAKrB,cAAc,CAAC,CAAD,CAAtB,IAA6B,CAACc,KAAK,CAACC,MAAN,CAAab,KAAb,EAAoBmB,GAAG,CAACnB,KAAxB,CAAlC,EAAkE;AAChE;AACAG,uBAAe,CAACJ,GAAD,CAAf,GAAuBC,KAAvB;AACD;;AACDmB,SAAG,CAACnB,KAAJ,GAAYA,KAAZ;AACD,KAND,MAMO;AACL;AACAF,oBAAc,CAAChF,IAAf,CAAoB;AAACoF,0BAAkB,EAAEA,kBAArB;AAAyCF,aAAK,EAAEA;AAAhD,OAApB;AACD;AAEF;AA/EqC,CAAxC;AAkFA;;;;;;;;AAMA,IAAIqB,qBAAqB,GAAG,UAAUC,cAAV,EAA0BC,gBAA1B,EAA4C;AACtE,MAAInG,IAAI,GAAG,IAAX;AACAA,MAAI,CAACkG,cAAL,GAAsBA,cAAtB;AACAlG,MAAI,CAACoG,SAAL,GAAiB,IAAI/B,GAAJ,EAAjB;AACArE,MAAI,CAACqG,SAAL,GAAiBF,gBAAjB;AACD,CALD;;AAOApC,SAAS,CAACuC,sBAAV,GAAmCL,qBAAnC;;AAGAhH,CAAC,CAAC2D,MAAF,CAASqD,qBAAqB,CAACpD,SAA/B,EAA0C;AAExC0D,SAAO,EAAE,YAAY;AACnB,QAAIvG,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAACoG,SAAL,CAAeI,IAAf,KAAwB,CAA/B;AACD,GALuC;AAOxCC,MAAI,EAAE,UAAUC,QAAV,EAAoB;AACxB,QAAI1G,IAAI,GAAG,IAAX;AACA2G,gBAAY,CAACC,QAAb,CAAsBF,QAAQ,CAACN,SAA/B,EAA0CpG,IAAI,CAACoG,SAA/C,EAA0D;AACxDS,UAAI,EAAE5H,CAAC,CAAC6H,IAAF,CAAO9G,IAAI,CAAC+G,YAAZ,EAA0B/G,IAA1B,CADkD;AAGxDgH,eAAS,EAAE,UAAUC,EAAV,EAAcC,KAAd,EAAqB;AAC9BlH,YAAI,CAACqG,SAAL,CAAec,KAAf,CAAqBnH,IAAI,CAACkG,cAA1B,EAA0Ce,EAA1C,EAA8CC,KAAK,CAAC3C,SAAN,EAA9C;AACD,OALuD;AAOxD6C,cAAQ,EAAE,UAAUH,EAAV,EAAcI,MAAd,EAAsB;AAC9BrH,YAAI,CAACqG,SAAL,CAAeiB,OAAf,CAAuBtH,IAAI,CAACkG,cAA5B,EAA4Ce,EAA5C;AACD;AATuD,KAA1D;AAWD,GApBuC;AAsBxCF,cAAY,EAAE,UAAUE,EAAV,EAAcI,MAAd,EAAsBH,KAAtB,EAA6B;AACzC,QAAIlH,IAAI,GAAG,IAAX;AACA,QAAIuH,MAAM,GAAG,EAAb;AACAZ,gBAAY,CAACa,WAAb,CAAyBH,MAAM,CAAC9C,SAAP,EAAzB,EAA6C2C,KAAK,CAAC3C,SAAN,EAA7C,EAAgE;AAC9DsC,UAAI,EAAE,UAAUlC,GAAV,EAAe8C,IAAf,EAAqBC,GAArB,EAA0B;AAC9B,YAAI,CAAClC,KAAK,CAACC,MAAN,CAAagC,IAAb,EAAmBC,GAAnB,CAAL,EACEH,MAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACH,OAJ6D;AAK9DV,eAAS,EAAE,UAAUrC,GAAV,EAAe+C,GAAf,EAAoB;AAC7BH,cAAM,CAAC5C,GAAD,CAAN,GAAc+C,GAAd;AACD,OAP6D;AAQ9DN,cAAQ,EAAE,UAASzC,GAAT,EAAc8C,IAAd,EAAoB;AAC5BF,cAAM,CAAC5C,GAAD,CAAN,GAAcO,SAAd;AACD;AAV6D,KAAhE;AAYAlF,QAAI,CAACqG,SAAL,CAAesB,OAAf,CAAuB3H,IAAI,CAACkG,cAA5B,EAA4Ce,EAA5C,EAAgDM,MAAhD;AACD,GAtCuC;AAwCxCJ,OAAK,EAAE,UAAUrC,kBAAV,EAA8BmC,EAA9B,EAAkCM,MAAlC,EAA0C;AAC/C,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAI4H,OAAO,GAAG5H,IAAI,CAACoG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAIE,KAAK,GAAG,KAAZ;;AACA,QAAI,CAACS,OAAL,EAAc;AACZT,WAAK,GAAG,IAAR;AACAS,aAAO,GAAG,IAAI3D,mBAAJ,EAAV;AACAjE,UAAI,CAACoG,SAAL,CAAeN,GAAf,CAAmBmB,EAAnB,EAAuBW,OAAvB;AACD;;AACDA,WAAO,CAAC1D,QAAR,CAAiB2D,GAAjB,CAAqB/C,kBAArB;AACA,QAAIC,eAAe,GAAG,EAAtB;;AACA9F,KAAC,CAACyD,IAAF,CAAO6E,MAAP,EAAe,UAAU3C,KAAV,EAAiBD,GAAjB,EAAsB;AACnCiD,aAAO,CAAClC,WAAR,CACEZ,kBADF,EACsBH,GADtB,EAC2BC,KAD3B,EACkCG,eADlC,EACmD,IADnD;AAED,KAHD;;AAIA,QAAIoC,KAAJ,EACEnH,IAAI,CAACqG,SAAL,CAAec,KAAf,CAAqBnH,IAAI,CAACkG,cAA1B,EAA0Ce,EAA1C,EAA8ClC,eAA9C,EADF,KAGE/E,IAAI,CAACqG,SAAL,CAAesB,OAAf,CAAuB3H,IAAI,CAACkG,cAA5B,EAA4Ce,EAA5C,EAAgDlC,eAAhD;AACH,GA3DuC;AA6DxC4C,SAAO,EAAE,UAAU7C,kBAAV,EAA8BmC,EAA9B,EAAkCU,OAAlC,EAA2C;AAClD,QAAI3H,IAAI,GAAG,IAAX;AACA,QAAI8H,aAAa,GAAG,EAApB;AACA,QAAIF,OAAO,GAAG5H,IAAI,CAACoG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;AACA,QAAI,CAACW,OAAL,EACE,MAAM,IAAIG,KAAJ,CAAU,oCAAoCd,EAApC,GAAyC,YAAnD,CAAN;;AACFhI,KAAC,CAACyD,IAAF,CAAOiF,OAAP,EAAgB,UAAU/C,KAAV,EAAiBD,GAAjB,EAAsB;AACpC,UAAIC,KAAK,KAAKM,SAAd,EACE0C,OAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CmD,aAA5C,EADF,KAGEF,OAAO,CAAClC,WAAR,CAAoBZ,kBAApB,EAAwCH,GAAxC,EAA6CC,KAA7C,EAAoDkD,aAApD;AACH,KALD;;AAMA9H,QAAI,CAACqG,SAAL,CAAesB,OAAf,CAAuB3H,IAAI,CAACkG,cAA5B,EAA4Ce,EAA5C,EAAgDa,aAAhD;AACD,GA1EuC;AA4ExCR,SAAO,EAAE,UAAUxC,kBAAV,EAA8BmC,EAA9B,EAAkC;AACzC,QAAIjH,IAAI,GAAG,IAAX;AACA,QAAI4H,OAAO,GAAG5H,IAAI,CAACoG,SAAL,CAAepB,GAAf,CAAmBiC,EAAnB,CAAd;;AACA,QAAI,CAACW,OAAL,EAAc;AACZ,UAAII,GAAG,GAAG,IAAID,KAAJ,CAAU,kCAAkCd,EAA5C,CAAV;AACA,YAAMe,GAAN;AACD;;AACDJ,WAAO,CAAC1D,QAAR,CAAiBqB,MAAjB,CAAwBT,kBAAxB;;AACA,QAAI8C,OAAO,CAAC1D,QAAR,CAAiBsC,IAAjB,KAA0B,CAA9B,EAAiC;AAC/B;AACAxG,UAAI,CAACqG,SAAL,CAAeiB,OAAf,CAAuBtH,IAAI,CAACkG,cAA5B,EAA4Ce,EAA5C;AACAjH,UAAI,CAACoG,SAAL,CAAeb,MAAf,CAAsB0B,EAAtB;AACD,KAJD,MAIO;AACL,UAAIU,OAAO,GAAG,EAAd,CADK,CAEL;AACA;;AACAC,aAAO,CAACxD,SAAR,CAAkBK,OAAlB,CAA0B,UAAUC,cAAV,EAA0BC,GAA1B,EAA+B;AACvDiD,eAAO,CAAC/C,UAAR,CAAmBC,kBAAnB,EAAuCH,GAAvC,EAA4CgD,OAA5C;AACD,OAFD;AAIA3H,UAAI,CAACqG,SAAL,CAAesB,OAAf,CAAuB3H,IAAI,CAACkG,cAA5B,EAA4Ce,EAA5C,EAAgDU,OAAhD;AACD;AACF;AAlGuC,CAA1C;AAqGA;;AACA;;AACA;;;AAEA,IAAIM,OAAO,GAAG,UAAU/G,MAAV,EAAkBgH,OAAlB,EAA2BtG,MAA3B,EAAmCuG,OAAnC,EAA4C;AACxD,MAAInI,IAAI,GAAG,IAAX;AACAA,MAAI,CAACiH,EAAL,GAAUmB,MAAM,CAACnB,EAAP,EAAV;AAEAjH,MAAI,CAACkB,MAAL,GAAcA,MAAd;AACAlB,MAAI,CAACkI,OAAL,GAAeA,OAAf;AAEAlI,MAAI,CAACqI,WAAL,GAAmB,KAAnB;AACArI,MAAI,CAAC4B,MAAL,GAAcA,MAAd,CARwD,CAUxD;AACA;;AACA5B,MAAI,CAACsI,OAAL,GAAe,IAAIC,MAAM,CAACC,iBAAX,EAAf;AAEAxI,MAAI,CAACyI,OAAL,GAAe,KAAf;AACAzI,MAAI,CAAC0I,aAAL,GAAqB,KAArB,CAfwD,CAiBxD;;AACA1I,MAAI,CAAC2I,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACArE,MAAI,CAAC4I,cAAL,GAAsB,EAAtB;AAEA5I,MAAI,CAAC6I,MAAL,GAAc,IAAd;AAEA7I,MAAI,CAAC8I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB,CAvBwD,CAyBxD;AACA;AACA;;AACArE,MAAI,CAAC+I,UAAL,GAAkB,IAAlB,CA5BwD,CA8BxD;AACA;;AACA/I,MAAI,CAACgJ,0BAAL,GAAkC,KAAlC,CAhCwD,CAkCxD;AACA;;AACAhJ,MAAI,CAACiJ,aAAL,GAAqB,EAArB,CApCwD,CAsCxD;;AACAjJ,MAAI,CAACkJ,eAAL,GAAuB,EAAvB,CAvCwD,CA0CxD;AACA;;AACAlJ,MAAI,CAACmJ,UAAL,GAAkBvH,MAAM,CAAC/C,GAAzB,CA5CwD,CA8CxD;;AACAmB,MAAI,CAACoJ,eAAL,GAAuBjB,OAAO,CAACkB,cAA/B,CA/CwD,CAiDxD;AACA;AACA;;AACArJ,MAAI,CAACsJ,gBAAL,GAAwB;AACtBrC,MAAE,EAAEjH,IAAI,CAACiH,EADa;AAEtBsC,SAAK,EAAE,YAAY;AACjBvJ,UAAI,CAACuJ,KAAL;AACD,KAJqB;AAKtBC,WAAO,EAAE,UAAUC,EAAV,EAAc;AACrB,UAAIC,EAAE,GAAGnB,MAAM,CAACoB,eAAP,CAAuBF,EAAvB,EAA2B,6BAA3B,CAAT;;AACA,UAAIzJ,IAAI,CAACsI,OAAT,EAAkB;AAChBtI,YAAI,CAACkJ,eAAL,CAAqBxJ,IAArB,CAA0BgK,EAA1B;AACD,OAFD,MAEO;AACL;AACAnB,cAAM,CAACqB,KAAP,CAAaF,EAAb;AACD;AACF,KAbqB;AActBG,iBAAa,EAAE7J,IAAI,CAAC8J,cAAL,EAdO;AAetBC,eAAW,EAAE/J,IAAI,CAAC4B,MAAL,CAAYoI;AAfH,GAAxB;AAkBAhK,MAAI,CAACoC,IAAL,CAAU;AAAE6H,OAAG,EAAE,WAAP;AAAoBC,WAAO,EAAElK,IAAI,CAACiH;AAAlC,GAAV,EAtEwD,CAwExD;;AACAjD,OAAK,CAAC,YAAY;AAChBhE,QAAI,CAACmK,kBAAL;AACD,GAFI,CAAL,CAEGC,GAFH;;AAIA,MAAIlC,OAAO,KAAK,MAAZ,IAAsBC,OAAO,CAACkC,iBAAR,KAA8B,CAAxD,EAA2D;AACzD;AACAzI,UAAM,CAACC,mBAAP,CAA2B,CAA3B;AAEA7B,QAAI,CAACsK,SAAL,GAAiB,IAAIC,SAAS,CAACC,SAAd,CAAwB;AACvCH,uBAAiB,EAAElC,OAAO,CAACkC,iBADY;AAEvCI,sBAAgB,EAAEtC,OAAO,CAACsC,gBAFa;AAGvCC,eAAS,EAAE,YAAY;AACrB1K,YAAI,CAACuJ,KAAL;AACD,OALsC;AAMvCoB,cAAQ,EAAE,YAAY;AACpB3K,YAAI,CAACoC,IAAL,CAAU;AAAC6H,aAAG,EAAE;AAAN,SAAV;AACD;AARsC,KAAxB,CAAjB;AAUAjK,QAAI,CAACsK,SAAL,CAAeM,KAAf;AACD;;AAEDC,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CADD,CAAzB;AAED,CAhGD;;AAkGA9L,CAAC,CAAC2D,MAAF,CAASqF,OAAO,CAACpF,SAAjB,EAA4B;AAE1BmI,WAAS,EAAE,UAAUC,eAAV,EAA2B;AACpC,QAAIjL,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC+I,UAAT,EACE/I,IAAI,CAACoC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeiB,UAAI,EAAED;AAArB,KAAV,EADF,KAEK;AACHhM,OAAC,CAACyD,IAAF,CAAOuI,eAAP,EAAwB,UAAUE,cAAV,EAA0B;AAChDnL,YAAI,CAACiJ,aAAL,CAAmBvJ,IAAnB,CAAwByL,cAAxB;AACD,OAFD;AAGD;AACF,GAXyB;AAa1BC,WAAS,EAAE,UAAUlF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC/C,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC+I,UAAT,EACE/I,IAAI,CAACoC,IAAL,CAAU;AAAC6H,SAAG,EAAE,OAAN;AAAeoB,gBAAU,EAAEnF,cAA3B;AAA2Ce,QAAE,EAAEA,EAA/C;AAAmDM,YAAM,EAAEA;AAA3D,KAAV;AACH,GAjByB;AAmB1B+D,aAAW,EAAE,UAAUpF,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AACjD,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAIf,CAAC,CAACsH,OAAF,CAAUgB,MAAV,CAAJ,EACE;;AAEF,QAAIvH,IAAI,CAAC+I,UAAT,EAAqB;AACnB/I,UAAI,CAACoC,IAAL,CAAU;AACR6H,WAAG,EAAE,SADG;AAERoB,kBAAU,EAAEnF,cAFJ;AAGRe,UAAE,EAAEA,EAHI;AAIRM,cAAM,EAAEA;AAJA,OAAV;AAMD;AACF,GAhCyB;AAkC1BgE,aAAW,EAAE,UAAUrF,cAAV,EAA0Be,EAA1B,EAA8B;AACzC,QAAIjH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC+I,UAAT,EACE/I,IAAI,CAACoC,IAAL,CAAU;AAAC6H,SAAG,EAAE,SAAN;AAAiBoB,gBAAU,EAAEnF,cAA7B;AAA6Ce,QAAE,EAAEA;AAAjD,KAAV;AACH,GAtCyB;AAwC1BuE,kBAAgB,EAAE,YAAY;AAC5B,QAAIxL,IAAI,GAAG,IAAX;AACA,WAAO;AACLmH,WAAK,EAAElI,CAAC,CAAC6H,IAAF,CAAO9G,IAAI,CAACoL,SAAZ,EAAuBpL,IAAvB,CADF;AAEL2H,aAAO,EAAE1I,CAAC,CAAC6H,IAAF,CAAO9G,IAAI,CAACsL,WAAZ,EAAyBtL,IAAzB,CAFJ;AAGLsH,aAAO,EAAErI,CAAC,CAAC6H,IAAF,CAAO9G,IAAI,CAACuL,WAAZ,EAAyBvL,IAAzB;AAHJ,KAAP;AAKD,GA/CyB;AAiD1ByL,mBAAiB,EAAE,UAAUvF,cAAV,EAA0B;AAC3C,QAAIlG,IAAI,GAAG,IAAX;AACA,QAAIwE,GAAG,GAAGxE,IAAI,CAAC8I,eAAL,CAAqB9D,GAArB,CAAyBkB,cAAzB,CAAV;;AACA,QAAI,CAAC1B,GAAL,EAAU;AACRA,SAAG,GAAG,IAAIyB,qBAAJ,CAA0BC,cAA1B,EAC4BlG,IAAI,CAACwL,gBAAL,EAD5B,CAAN;AAEAxL,UAAI,CAAC8I,eAAL,CAAqBhD,GAArB,CAAyBI,cAAzB,EAAyC1B,GAAzC;AACD;;AACD,WAAOA,GAAP;AACD,GA1DyB;AA4D1B2C,OAAK,EAAE,UAAUrC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AAC/D,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAI0L,IAAI,GAAG1L,IAAI,CAACyL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACvE,KAAL,CAAWrC,kBAAX,EAA+BmC,EAA/B,EAAmCM,MAAnC;AACD,GAhEyB;AAkE1BD,SAAO,EAAE,UAAUxC,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkD;AACzD,QAAIjH,IAAI,GAAG,IAAX;AACA,QAAI0L,IAAI,GAAG1L,IAAI,CAACyL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAACpE,OAAL,CAAaxC,kBAAb,EAAiCmC,EAAjC;;AACA,QAAIyE,IAAI,CAACnF,OAAL,EAAJ,EAAoB;AACjBvG,UAAI,CAAC8I,eAAL,CAAqBvD,MAArB,CAA4BW,cAA5B;AACF;AACF,GAzEyB;AA2E1ByB,SAAO,EAAE,UAAU7C,kBAAV,EAA8BoB,cAA9B,EAA8Ce,EAA9C,EAAkDM,MAAlD,EAA0D;AACjE,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAI0L,IAAI,GAAG1L,IAAI,CAACyL,iBAAL,CAAuBvF,cAAvB,CAAX;AACAwF,QAAI,CAAC/D,OAAL,CAAa7C,kBAAb,EAAiCmC,EAAjC,EAAqCM,MAArC;AACD,GA/EyB;AAiF1B4C,oBAAkB,EAAE,YAAY;AAC9B,QAAInK,IAAI,GAAG,IAAX,CAD8B,CAE9B;AACA;AACA;;AACA,QAAI2L,QAAQ,GAAG1M,CAAC,CAAC2G,KAAF,CAAQ5F,IAAI,CAACkB,MAAL,CAAY0K,0BAApB,CAAf;;AACA3M,KAAC,CAACyD,IAAF,CAAOiJ,QAAP,EAAiB,UAAUE,OAAV,EAAmB;AAClC7L,UAAI,CAAC8L,kBAAL,CAAwBD,OAAxB;AACD,KAFD;AAGD,GA1FyB;AA4F1B;AACAtC,OAAK,EAAE,YAAY;AACjB,QAAIvJ,IAAI,GAAG,IAAX,CADiB,CAGjB;AACA;AACA;AAEA;;AACA,QAAI,CAAEA,IAAI,CAACsI,OAAX,EACE,OATe,CAWjB;;AACAtI,QAAI,CAACsI,OAAL,GAAe,IAAf;AACAtI,QAAI,CAAC8I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;;AAEA,QAAIrE,IAAI,CAACsK,SAAT,EAAoB;AAClBtK,UAAI,CAACsK,SAAL,CAAeyB,IAAf;AACA/L,UAAI,CAACsK,SAAL,GAAiB,IAAjB;AACD;;AAED,QAAItK,IAAI,CAAC4B,MAAT,EAAiB;AACf5B,UAAI,CAAC4B,MAAL,CAAY2H,KAAZ;AACAvJ,UAAI,CAAC4B,MAAL,CAAYoK,cAAZ,GAA6B,IAA7B;AACD;;AAEDnB,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,UADW,EACC,CAAC,CADF,CAAzB;AAGAxC,UAAM,CAACqB,KAAP,CAAa,YAAY;AACvB;AACA;AACA;AACA5J,UAAI,CAACiM,2BAAL,GAJuB,CAMvB;AACA;;;AACAhN,OAAC,CAACyD,IAAF,CAAO1C,IAAI,CAACkJ,eAAZ,EAA6B,UAAUvG,QAAV,EAAoB;AAC/CA,gBAAQ;AACT,OAFD;AAGD,KAXD,EA5BiB,CAyCjB;;AACA3C,QAAI,CAACkB,MAAL,CAAYgL,cAAZ,CAA2BlM,IAA3B;AACD,GAxIyB;AA0I1B;AACA;AACAoC,MAAI,EAAE,UAAU6H,GAAV,EAAe;AACnB,QAAIjK,IAAI,GAAG,IAAX;;AACA,QAAIA,IAAI,CAAC4B,MAAT,EAAiB;AACf,UAAI2G,MAAM,CAAC4D,aAAX,EACE5D,MAAM,CAAC6D,MAAP,CAAc,UAAd,EAA0B7B,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAA1B;AACFjK,UAAI,CAAC4B,MAAL,CAAYQ,IAAZ,CAAiBmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAjB;AACD;AACF,GAnJyB;AAqJ1B;AACAqC,WAAS,EAAE,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAC7C,QAAIxM,IAAI,GAAG,IAAX;AACA,QAAIiK,GAAG,GAAG;AAACA,SAAG,EAAE,OAAN;AAAesC,YAAM,EAAEA;AAAvB,KAAV;AACA,QAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACFxM,QAAI,CAACoC,IAAL,CAAU6H,GAAV;AACD,GA5JyB;AA8J1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAwC,gBAAc,EAAE,UAAUC,MAAV,EAAkB;AAChC,QAAI1M,IAAI,GAAG,IAAX;AACA,QAAI,CAACA,IAAI,CAACsI,OAAV,EAAmB;AACjB,aAH8B,CAKhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAItI,IAAI,CAACsK,SAAT,EAAoB;AAClBtG,WAAK,CAAC,YAAY;AAChBhE,YAAI,CAACsK,SAAL,CAAeqC,eAAf;AACD,OAFI,CAAL,CAEGvC,GAFH;AAGD;;AAED,QAAIpK,IAAI,CAACkI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD,UAAIjK,IAAI,CAACoJ,eAAT,EACEpJ,IAAI,CAACoC,IAAL,CAAU;AAAC6H,WAAG,EAAE,MAAN;AAAchD,UAAE,EAAEyF,MAAM,CAACzF;AAAzB,OAAV;AACF;AACD;;AACD,QAAIjH,IAAI,CAACkI,OAAL,KAAiB,MAAjB,IAA2BwE,MAAM,CAACzC,GAAP,KAAe,MAA9C,EAAsD;AACpD;AACA;AACD;;AAEDjK,QAAI,CAACsI,OAAL,CAAa5I,IAAb,CAAkBgN,MAAlB;AACA,QAAI1M,IAAI,CAAC0I,aAAT,EACE;AACF1I,QAAI,CAAC0I,aAAL,GAAqB,IAArB;;AAEA,QAAIkE,WAAW,GAAG,YAAY;AAC5B,UAAI3C,GAAG,GAAGjK,IAAI,CAACsI,OAAL,IAAgBtI,IAAI,CAACsI,OAAL,CAAauE,KAAb,EAA1B;;AACA,UAAI,CAAC5C,GAAL,EAAU;AACRjK,YAAI,CAAC0I,aAAL,GAAqB,KAArB;AACA;AACD;;AAED1E,WAAK,CAAC,YAAY;AAChB,YAAIyE,OAAO,GAAG,IAAd;;AAEA,YAAIqE,OAAO,GAAG,YAAY;AACxB,cAAI,CAACrE,OAAL,EACE,OAFsB,CAEd;;AACVA,iBAAO,GAAG,KAAV;AACAmE,qBAAW;AACZ,SALD;;AAOA5M,YAAI,CAACkB,MAAL,CAAY6L,aAAZ,CAA0BrK,IAA1B,CAA+B,UAAUC,QAAV,EAAoB;AACjDA,kBAAQ,CAACsH,GAAD,EAAMjK,IAAN,CAAR;AACA,iBAAO,IAAP;AACD,SAHD;AAKA,YAAIf,CAAC,CAAC4G,GAAF,CAAM7F,IAAI,CAACgN,iBAAX,EAA8B/C,GAAG,CAACA,GAAlC,CAAJ,EACEjK,IAAI,CAACgN,iBAAL,CAAuB/C,GAAG,CAACA,GAA3B,EAAgCgD,IAAhC,CAAqCjN,IAArC,EAA2CiK,GAA3C,EAAgD6C,OAAhD,EADF,KAGE9M,IAAI,CAACsM,SAAL,CAAe,aAAf,EAA8BrC,GAA9B;AACF6C,eAAO,GAnBS,CAmBL;AACZ,OApBI,CAAL,CAoBG1C,GApBH;AAqBD,KA5BD;;AA8BAwC,eAAW;AACZ,GAlPyB;AAoP1BI,mBAAiB,EAAE;AACjBE,OAAG,EAAE,UAAUjD,GAAV,EAAe;AAClB,UAAIjK,IAAI,GAAG,IAAX,CADkB,CAGlB;;AACA,UAAI,OAAQiK,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACkD,IAAZ,KAAsB,QADtB,IAEE,YAAYlD,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAF1B,EAE2D;AACzDrN,YAAI,CAACsM,SAAL,CAAe,wBAAf,EAAyCrC,GAAzC;AACA;AACD;;AAED,UAAI,CAACjK,IAAI,CAACkB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAL,EAA6C;AAC3CnN,YAAI,CAACoC,IAAL,CAAU;AACR6H,aAAG,EAAE,OADG;AACMhD,YAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,0BAAuCkC,GAAG,CAACkD,IAA3C;AAFC,SAAV;AAGA;AACD;;AAED,UAAInN,IAAI,CAAC2I,UAAL,CAAgB9C,GAAhB,CAAoBoE,GAAG,CAAChD,EAAxB,CAAJ,EACE;AACA;AACA;AACA,eAtBgB,CAwBlB;AACA;AACA;AACA;AACA;;AACA,UAAI4D,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,YAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,YAAIC,gBAAgB,GAAG;AACrB5E,gBAAM,EAAE7I,IAAI,CAAC6I,MADQ;AAErBgB,uBAAa,EAAE7J,IAAI,CAACsJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,cAAI,EAAE,cAHe;AAIrBP,cAAI,EAAElD,GAAG,CAACkD,IAJW;AAKrBQ,sBAAY,EAAE3N,IAAI,CAACiH;AALE,SAAvB;;AAQAuG,sBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,YAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,YAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5B/N,cAAI,CAACoC,IAAL,CAAU;AACR6H,eAAG,EAAE,OADG;AACMhD,cAAE,EAAEgD,GAAG,CAAChD,EADd;AAERsG,iBAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK;AAFC,WAAV;AAOA;AACD;AACF;;AAED,UAAIpC,OAAO,GAAG7L,IAAI,CAACkB,MAAL,CAAYoM,gBAAZ,CAA6BrD,GAAG,CAACkD,IAAjC,CAAd;;AAEAnN,UAAI,CAAC8L,kBAAL,CAAwBD,OAAxB,EAAiC5B,GAAG,CAAChD,EAArC,EAAyCgD,GAAG,CAACmD,MAA7C,EAAqDnD,GAAG,CAACkD,IAAzD;AAED,KA1DgB;AA4DjBe,SAAK,EAAE,UAAUjE,GAAV,EAAe;AACpB,UAAIjK,IAAI,GAAG,IAAX;;AAEAA,UAAI,CAACmO,iBAAL,CAAuBlE,GAAG,CAAChD,EAA3B;AACD,KAhEgB;AAkEjBmH,UAAM,EAAE,UAAUnE,GAAV,EAAe6C,OAAf,EAAwB;AAC9B,UAAI9M,IAAI,GAAG,IAAX,CAD8B,CAG9B;AACA;AACA;;AACA,UAAI,OAAQiK,GAAG,CAAChD,EAAZ,KAAoB,QAApB,IACA,OAAQgD,GAAG,CAACmE,MAAZ,KAAwB,QADxB,IAEE,YAAYnE,GAAb,IAAqB,EAAEA,GAAG,CAACmD,MAAJ,YAAsBC,KAAxB,CAFtB,IAGE,gBAAgBpD,GAAjB,IAA0B,OAAOA,GAAG,CAACoE,UAAX,KAA0B,QAHzD,EAGqE;AACnErO,YAAI,CAACsM,SAAL,CAAe,6BAAf,EAA8CrC,GAA9C;AACA;AACD;;AAED,UAAIoE,UAAU,GAAGpE,GAAG,CAACoE,UAAJ,IAAkB,IAAnC,CAd8B,CAgB9B;AACA;AACA;;AACA,UAAIC,KAAK,GAAG,IAAIvK,SAAS,CAACwK,WAAd,EAAZ;AACAD,WAAK,CAACE,cAAN,CAAqB,YAAY;AAC/B;AACA;AACA;AACA;AACA;AACAF,aAAK,CAACG,MAAN;AACAzO,YAAI,CAACoC,IAAL,CAAU;AACR6H,aAAG,EAAE,SADG;AACQyE,iBAAO,EAAE,CAACzE,GAAG,CAAChD,EAAL;AADjB,SAAV;AAED,OATD,EApB8B,CA+B9B;;AACA,UAAI4E,OAAO,GAAG7L,IAAI,CAACkB,MAAL,CAAYyN,eAAZ,CAA4B1E,GAAG,CAACmE,MAAhC,CAAd;;AACA,UAAI,CAACvC,OAAL,EAAc;AACZ7L,YAAI,CAACoC,IAAL,CAAU;AACR6H,aAAG,EAAE,QADG;AACOhD,YAAE,EAAEgD,GAAG,CAAChD,EADf;AAERsG,eAAK,EAAE,IAAIhF,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCkC,GAAG,CAACmE,MAArC;AAFC,SAAV;AAGAE,aAAK,CAACM,GAAN;AACA;AACD;;AAED,UAAIC,SAAS,GAAG,UAAShG,MAAT,EAAiB;AAC/B7I,YAAI,CAAC8O,UAAL,CAAgBjG,MAAhB;AACD,OAFD;;AAIA,UAAIkG,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,oBAAY,EAAE,KADgC;AAE9CpG,cAAM,EAAE7I,IAAI,CAAC6I,MAFiC;AAG9CgG,iBAAS,EAAEA,SAHmC;AAI9C/B,eAAO,EAAEA,OAJqC;AAK9C5K,kBAAU,EAAElC,IAAI,CAACsJ,gBAL6B;AAM9C+E,kBAAU,EAAEA;AANkC,OAA/B,CAAjB;AASA,YAAMa,OAAO,GAAG,IAAIC,OAAJ,CAAY,CAACC,OAAD,EAAUC,MAAV,KAAqB;AAC/C;AACA;AACA;AACA;AACA,YAAIxE,OAAO,CAAC,kBAAD,CAAX,EAAiC;AAC/B,cAAI2C,cAAc,GAAG3C,OAAO,CAAC,kBAAD,CAAP,CAA4B2C,cAAjD;AACA,cAAIC,gBAAgB,GAAG;AACrB5E,kBAAM,EAAE7I,IAAI,CAAC6I,MADQ;AAErBgB,yBAAa,EAAE7J,IAAI,CAACsJ,gBAAL,CAAsBO,aAFhB;AAGrB6D,gBAAI,EAAE,QAHe;AAIrBP,gBAAI,EAAElD,GAAG,CAACmE,MAJW;AAKrBT,wBAAY,EAAE3N,IAAI,CAACiH;AALE,WAAvB;;AAOAuG,wBAAc,CAACI,UAAf,CAA0BH,gBAA1B;;AACA,cAAII,eAAe,GAAGL,cAAc,CAACM,MAAf,CAAsBL,gBAAtB,CAAtB;;AACA,cAAI,CAACI,eAAe,CAACE,OAArB,EAA8B;AAC5BsB,kBAAM,CAAC,IAAI9G,MAAM,CAACR,KAAX,CACL,mBADK,EAELyF,cAAc,CAACQ,eAAf,CAA+BH,eAA/B,CAFK,EAGL;AAACI,yBAAW,EAAEJ,eAAe,CAACI;AAA9B,aAHK,CAAD,CAAN;AAKA;AACD;AACF;;AAEDmB,eAAO,CAACrL,SAAS,CAACuL,kBAAV,CAA6BC,SAA7B,CACNjB,KADM,EAEN,MAAMkB,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACJR,UADI,EAEJ,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACP9E,GAAG,CAACmD,MADG,EAE5B,cAAcnD,GAAG,CAACmE,MAAlB,GAA2B,GAFC,CAF1B,CAFA,CAAD,CAAP;AAUD,OApCe,CAAhB;;AAsCA,eAASuB,MAAT,GAAkB;AAChBrB,aAAK,CAACM,GAAN;AACA9B,eAAO;AACR;;AAED,YAAM8C,OAAO,GAAG;AACd3F,WAAG,EAAE,QADS;AAEdhD,UAAE,EAAEgD,GAAG,CAAChD;AAFM,OAAhB;AAKAiI,aAAO,CAACW,IAAR,CAAcC,MAAD,IAAY;AACvBH,cAAM;;AACN,YAAIG,MAAM,KAAK5K,SAAf,EAA0B;AACxB0K,iBAAO,CAACE,MAAR,GAAiBA,MAAjB;AACD;;AACD9P,YAAI,CAACoC,IAAL,CAAUwN,OAAV;AACD,OAND,EAMIG,SAAD,IAAe;AAChBJ,cAAM;AACNC,eAAO,CAACrC,KAAR,GAAgByC,qBAAqB,CACnCD,SADmC,mCAET9F,GAAG,CAACmE,MAFK,OAArC;AAIApO,YAAI,CAACoC,IAAL,CAAUwN,OAAV;AACD,OAbD;AAcD;AAtLgB,GApPO;AA6a1BK,UAAQ,EAAE,UAAUC,CAAV,EAAa;AACrB,QAAIlQ,IAAI,GAAG,IAAX;;AACAA,QAAI,CAAC2I,UAAL,CAAgBlE,OAAhB,CAAwByL,CAAxB;;AACAlQ,QAAI,CAAC4I,cAAL,CAAoBnE,OAApB,CAA4ByL,CAA5B;AACD,GAjbyB;AAmb1BC,sBAAoB,EAAE,UAAUC,SAAV,EAAqB;AACzC,QAAIpQ,IAAI,GAAG,IAAX;AACA2G,gBAAY,CAACC,QAAb,CAAsBwJ,SAAtB,EAAiCpQ,IAAI,CAAC8I,eAAtC,EAAuD;AACrDjC,UAAI,EAAE,UAAUX,cAAV,EAA0BmK,SAA1B,EAAqCC,UAArC,EAAiD;AACrDA,kBAAU,CAAC7J,IAAX,CAAgB4J,SAAhB;AACD,OAHoD;AAIrDrJ,eAAS,EAAE,UAAUd,cAAV,EAA0BoK,UAA1B,EAAsC;AAC/CA,kBAAU,CAAClK,SAAX,CAAqB3B,OAArB,CAA6B,UAAUmD,OAAV,EAAmBX,EAAnB,EAAuB;AAClDjH,cAAI,CAACoL,SAAL,CAAelF,cAAf,EAA+Be,EAA/B,EAAmCW,OAAO,CAACrD,SAAR,EAAnC;AACD,SAFD;AAGD,OARoD;AASrD6C,cAAQ,EAAE,UAAUlB,cAAV,EAA0BmK,SAA1B,EAAqC;AAC7CA,iBAAS,CAACjK,SAAV,CAAoB3B,OAApB,CAA4B,UAAU8L,GAAV,EAAetJ,EAAf,EAAmB;AAC7CjH,cAAI,CAACuL,WAAL,CAAiBrF,cAAjB,EAAiCe,EAAjC;AACD,SAFD;AAGD;AAboD,KAAvD;AAeD,GApcyB;AAsc1B;AACA;AACA6H,YAAU,EAAE,UAASjG,MAAT,EAAiB;AAC3B,QAAI7I,IAAI,GAAG,IAAX;AAEA,QAAI6I,MAAM,KAAK,IAAX,IAAmB,OAAOA,MAAP,KAAkB,QAAzC,EACE,MAAM,IAAId,KAAJ,CAAU,qDACA,OAAOc,MADjB,CAAN,CAJyB,CAO3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AACA7I,QAAI,CAACgJ,0BAAL,GAAkC,IAAlC,CAf2B,CAiB3B;AACA;;AACAhJ,QAAI,CAACiQ,QAAL,CAAc,UAAU/C,GAAV,EAAe;AAC3BA,SAAG,CAACsD,WAAJ;AACD,KAFD,EAnB2B,CAuB3B;AACA;AACA;;;AACAxQ,QAAI,CAAC+I,UAAL,GAAkB,KAAlB;AACA,QAAIqH,SAAS,GAAGpQ,IAAI,CAAC8I,eAArB;AACA9I,QAAI,CAAC8I,eAAL,GAAuB,IAAIzE,GAAJ,EAAvB;AACArE,QAAI,CAAC6I,MAAL,GAAcA,MAAd,CA7B2B,CA+B3B;AACA;AACA;AACA;;AACA2G,OAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CAAuCrK,SAAvC,EAAkD,YAAY;AAC5D;AACA,UAAIuL,YAAY,GAAGzQ,IAAI,CAAC2I,UAAxB;AACA3I,UAAI,CAAC2I,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;AACArE,UAAI,CAAC4I,cAAL,GAAsB,EAAtB;AAEA6H,kBAAY,CAAChM,OAAb,CAAqB,UAAUyI,GAAV,EAAe/B,cAAf,EAA+B;AAClD,YAAIuF,MAAM,GAAGxD,GAAG,CAACyD,SAAJ,EAAb;;AACA3Q,YAAI,CAAC2I,UAAL,CAAgB7C,GAAhB,CAAoBqF,cAApB,EAAoCuF,MAApC,EAFkD,CAGlD;AACA;;;AACAA,cAAM,CAACE,WAAP;AACD,OAND,EAN4D,CAc5D;AACA;AACA;;AACA5Q,UAAI,CAACgJ,0BAAL,GAAkC,KAAlC;AACAhJ,UAAI,CAACmK,kBAAL;AACD,KAnBD,EAnC2B,CAwD3B;AACA;AACA;;;AACA5B,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC7Q,UAAI,CAAC+I,UAAL,GAAkB,IAAlB;;AACA/I,UAAI,CAACmQ,oBAAL,CAA0BC,SAA1B;;AACA,UAAI,CAACnR,CAAC,CAACsH,OAAF,CAAUvG,IAAI,CAACiJ,aAAf,CAAL,EAAoC;AAClCjJ,YAAI,CAACgL,SAAL,CAAehL,IAAI,CAACiJ,aAApB;AACAjJ,YAAI,CAACiJ,aAAL,GAAqB,EAArB;AACD;AACF,KAPD;AAQD,GA3gByB;AA6gB1B6C,oBAAkB,EAAE,UAAUD,OAAV,EAAmBiF,KAAnB,EAA0B1D,MAA1B,EAAkCD,IAAlC,EAAwC;AAC1D,QAAInN,IAAI,GAAG,IAAX;AAEA,QAAIkN,GAAG,GAAG,IAAI6D,YAAJ,CACR/Q,IADQ,EACF6L,OADE,EACOiF,KADP,EACc1D,MADd,EACsBD,IADtB,CAAV;AAEA,QAAI2D,KAAJ,EACE9Q,IAAI,CAAC2I,UAAL,CAAgB7C,GAAhB,CAAoBgL,KAApB,EAA2B5D,GAA3B,EADF,KAGElN,IAAI,CAAC4I,cAAL,CAAoBlJ,IAApB,CAAyBwN,GAAzB;;AAEFA,OAAG,CAAC0D,WAAJ;AACD,GAxhByB;AA0hB1B;AACAzC,mBAAiB,EAAE,UAAU2C,KAAV,EAAiBvD,KAAjB,EAAwB;AACzC,QAAIvN,IAAI,GAAG,IAAX;AAEA,QAAIgR,OAAO,GAAG,IAAd;;AACA,QAAIF,KAAJ,EAAW;AACT,UAAIG,QAAQ,GAAGjR,IAAI,CAAC2I,UAAL,CAAgB3D,GAAhB,CAAoB8L,KAApB,CAAf;;AACA,UAAIG,QAAJ,EAAc;AACZD,eAAO,GAAGC,QAAQ,CAACC,KAAnB;;AACAD,gBAAQ,CAACE,mBAAT;;AACAF,gBAAQ,CAACT,WAAT;;AACAxQ,YAAI,CAAC2I,UAAL,CAAgBpD,MAAhB,CAAuBuL,KAAvB;AACD;AACF;;AAED,QAAIM,QAAQ,GAAG;AAACnH,SAAG,EAAE,OAAN;AAAehD,QAAE,EAAE6J;AAAnB,KAAf;;AAEA,QAAIvD,KAAJ,EAAW;AACT6D,cAAQ,CAAC7D,KAAT,GAAiByC,qBAAqB,CACpCzC,KADoC,EAEpCyD,OAAO,GAAI,cAAcA,OAAd,GAAwB,MAAxB,GAAiCF,KAArC,GACF,iBAAiBA,KAHc,CAAtC;AAID;;AAED9Q,QAAI,CAACoC,IAAL,CAAUgP,QAAV;AACD,GAnjByB;AAqjB1B;AACA;AACAnF,6BAA2B,EAAE,YAAY;AACvC,QAAIjM,IAAI,GAAG,IAAX;;AAEAA,QAAI,CAAC2I,UAAL,CAAgBlE,OAAhB,CAAwB,UAAUyI,GAAV,EAAejG,EAAf,EAAmB;AACzCiG,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAxQ,QAAI,CAAC2I,UAAL,GAAkB,IAAItE,GAAJ,EAAlB;;AAEArE,QAAI,CAAC4I,cAAL,CAAoBnE,OAApB,CAA4B,UAAUyI,GAAV,EAAe;AACzCA,SAAG,CAACsD,WAAJ;AACD,KAFD;;AAGAxQ,QAAI,CAAC4I,cAAL,GAAsB,EAAtB;AACD,GAnkByB;AAqkB1B;AACA;AACA;AACAkB,gBAAc,EAAE,YAAY;AAC1B,QAAI9J,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACA,QAAIqR,kBAAkB,GAAGC,QAAQ,CAACjS,OAAO,CAACC,GAAR,CAAY,sBAAZ,CAAD,CAAR,IAAiD,CAA1E;AAEA,QAAI+R,kBAAkB,KAAK,CAA3B,EACE,OAAOrR,IAAI,CAAC4B,MAAL,CAAY2P,aAAnB;AAEF,QAAIC,YAAY,GAAGxR,IAAI,CAAC4B,MAAL,CAAYoI,OAAZ,CAAoB,iBAApB,CAAnB;AACA,QAAI,CAAE/K,CAAC,CAACwS,QAAF,CAAWD,YAAX,CAAN,EACE,OAAO,IAAP;AACFA,gBAAY,GAAGA,YAAY,CAACE,IAAb,GAAoBC,KAApB,CAA0B,SAA1B,CAAf,CAlB0B,CAoB1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,QAAIN,kBAAkB,GAAG,CAArB,IAA0BA,kBAAkB,GAAGG,YAAY,CAACpM,MAAhE,EACE,OAAO,IAAP;AAEF,WAAOoM,YAAY,CAACA,YAAY,CAACpM,MAAb,GAAsBiM,kBAAvB,CAAnB;AACD;AAzmByB,CAA5B;AA4mBA;;AACA;;AACA;AAEA;AAEA;AACA;;AACA;;;;;;;;AAMA,IAAIN,YAAY,GAAG,UACf7G,OADe,EACN2B,OADM,EACGV,cADH,EACmBiC,MADnB,EAC2BD,IAD3B,EACiC;AAClD,MAAInN,IAAI,GAAG,IAAX;AACAA,MAAI,CAACgC,QAAL,GAAgBkI,OAAhB,CAFkD,CAEzB;;AAEzB;;;;;;;;AAOAlK,MAAI,CAACkC,UAAL,GAAkBgI,OAAO,CAACZ,gBAA1B,CAXkD,CAWN;;AAE5CtJ,MAAI,CAAC4R,QAAL,GAAgB/F,OAAhB,CAbkD,CAelD;;AACA7L,MAAI,CAAC6R,eAAL,GAAuB1G,cAAvB,CAhBkD,CAiBlD;;AACAnL,MAAI,CAACkR,KAAL,GAAa/D,IAAb;AAEAnN,MAAI,CAAC8R,OAAL,GAAe1E,MAAM,IAAI,EAAzB,CApBkD,CAsBlD;AACA;AACA;;AACA,MAAIpN,IAAI,CAAC6R,eAAT,EAA0B;AACxB7R,QAAI,CAAC+R,mBAAL,GAA2B,MAAM/R,IAAI,CAAC6R,eAAtC;AACD,GAFD,MAEO;AACL7R,QAAI,CAAC+R,mBAAL,GAA2B,MAAM3J,MAAM,CAACnB,EAAP,EAAjC;AACD,GA7BiD,CA+BlD;;;AACAjH,MAAI,CAACgS,YAAL,GAAoB,KAApB,CAhCkD,CAkClD;;AACAhS,MAAI,CAACiS,cAAL,GAAsB,EAAtB,CAnCkD,CAqClD;AACA;;AACAjS,MAAI,CAACkS,UAAL,GAAkB,IAAI7N,GAAJ,EAAlB,CAvCkD,CAyClD;;AACArE,MAAI,CAACmS,MAAL,GAAc,KAAd,CA1CkD,CA4ClD;;AAEA;;;;;;;;AAOAnS,MAAI,CAAC6I,MAAL,GAAcqB,OAAO,CAACrB,MAAtB,CArDkD,CAuDlD;AACA;AACA;AAEA;AACA;AACA;AACA;;AAEA7I,MAAI,CAACoS,SAAL,GAAiB;AACfC,eAAW,EAAEC,OAAO,CAACD,WADN;AAEfE,WAAO,EAAED,OAAO,CAACC;AAFF,GAAjB;AAKA1H,SAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CADN,CAAzB;AAED,CAxED;;AA0EA9L,CAAC,CAAC2D,MAAF,CAASmO,YAAY,CAAClO,SAAtB,EAAiC;AAC/B+N,aAAW,EAAE,YAAY;AACvB;AACA;AACA;AACA;AACA;AACA;AAEA,QAAI5Q,IAAI,GAAG,IAAX;;AACA,QAAI;AACF,UAAIwS,GAAG,GAAGhD,GAAG,CAACiD,6BAAJ,CAAkClD,SAAlC,CACRvP,IADQ,EAER,MAAM0P,wBAAwB,CAC5B1P,IAAI,CAAC4R,QADuB,EACb5R,IADa,EACPwF,KAAK,CAACI,KAAN,CAAY5F,IAAI,CAAC8R,OAAjB,CADO,EAE5B;AACA;AACA;AACA,sBAAgB9R,IAAI,CAACkR,KAArB,GAA6B,GALD,CAFtB,CAAV;AAUD,KAXD,CAWE,OAAOwB,CAAP,EAAU;AACV1S,UAAI,CAACuN,KAAL,CAAWmF,CAAX;AACA;AACD,KAvBsB,CAyBvB;;;AACA,QAAI1S,IAAI,CAAC2S,cAAL,EAAJ,EACE;;AAEF3S,QAAI,CAAC4S,qBAAL,CAA2BJ,GAA3B;AACD,GA/B8B;AAiC/BI,uBAAqB,EAAE,UAAUJ,GAAV,EAAe;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,QAAIxS,IAAI,GAAG,IAAX;;AACA,QAAI6S,QAAQ,GAAG,UAAUC,CAAV,EAAa;AAC1B,aAAOA,CAAC,IAAIA,CAAC,CAACC,cAAd;AACD,KAFD;;AAGA,QAAIF,QAAQ,CAACL,GAAD,CAAZ,EAAmB;AACjB,UAAI;AACFA,WAAG,CAACO,cAAJ,CAAmB/S,IAAnB;AACD,OAFD,CAEE,OAAO0S,CAAP,EAAU;AACV1S,YAAI,CAACuN,KAAL,CAAWmF,CAAX;AACA;AACD,OANgB,CAOjB;AACA;;;AACA1S,UAAI,CAACgT,KAAL;AACD,KAVD,MAUO,IAAI/T,CAAC,CAACgU,OAAF,CAAUT,GAAV,CAAJ,EAAoB;AACzB;AACA,UAAI,CAAEvT,CAAC,CAACiU,GAAF,CAAMV,GAAN,EAAWK,QAAX,CAAN,EAA4B;AAC1B7S,YAAI,CAACuN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,mDAAV,CAAX;AACA;AACD,OALwB,CAMzB;AACA;AACA;;;AACA,UAAIoL,eAAe,GAAG,EAAtB;;AACA,WAAK,IAAIhO,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGqN,GAAG,CAACpN,MAAxB,EAAgC,EAAED,CAAlC,EAAqC;AACnC,YAAIe,cAAc,GAAGsM,GAAG,CAACrN,CAAD,CAAH,CAAOiO,kBAAP,EAArB;;AACA,YAAInU,CAAC,CAAC4G,GAAF,CAAMsN,eAAN,EAAuBjN,cAAvB,CAAJ,EAA4C;AAC1ClG,cAAI,CAACuN,KAAL,CAAW,IAAIxF,KAAJ,CACT,+DACE7B,cAFO,CAAX;AAGA;AACD;;AACDiN,uBAAe,CAACjN,cAAD,CAAf,GAAkC,IAAlC;AACD;;AAAA;;AAED,UAAI;AACFjH,SAAC,CAACyD,IAAF,CAAO8P,GAAP,EAAY,UAAUa,GAAV,EAAe;AACzBA,aAAG,CAACN,cAAJ,CAAmB/S,IAAnB;AACD,SAFD;AAGD,OAJD,CAIE,OAAO0S,CAAP,EAAU;AACV1S,YAAI,CAACuN,KAAL,CAAWmF,CAAX;AACA;AACD;;AACD1S,UAAI,CAACgT,KAAL;AACD,KA9BM,MA8BA,IAAIR,GAAJ,EAAS;AACd;AACA;AACA;AACAxS,UAAI,CAACuN,KAAL,CAAW,IAAIxF,KAAJ,CAAU,kDACE,qBADZ,CAAX;AAED;AACF,GAtG8B;AAwG/B;AACA;AACA;AACA;AACA;AACAyI,aAAW,EAAE,YAAW;AACtB,QAAIxQ,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAACgS,YAAT,EACE;AACFhS,QAAI,CAACgS,YAAL,GAAoB,IAApB;;AACAhS,QAAI,CAACsT,kBAAL;;AACAzI,WAAO,CAAC,YAAD,CAAP,IAAyBA,OAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACvB,UADuB,EACX,eADW,EACM,CAAC,CADP,CAAzB;AAED,GArH8B;AAuH/BuI,oBAAkB,EAAE,YAAY;AAC9B,QAAItT,IAAI,GAAG,IAAX,CAD8B,CAE9B;;AACA,QAAIqG,SAAS,GAAGrG,IAAI,CAACiS,cAArB;AACAjS,QAAI,CAACiS,cAAL,GAAsB,EAAtB;;AACAhT,KAAC,CAACyD,IAAF,CAAO2D,SAAP,EAAkB,UAAU1D,QAAV,EAAoB;AACpCA,cAAQ;AACT,KAFD;AAGD,GA/H8B;AAiI/B;AACAwO,qBAAmB,EAAE,YAAY;AAC/B,QAAInR,IAAI,GAAG,IAAX;;AACAuI,UAAM,CAACsI,gBAAP,CAAwB,YAAY;AAClC7Q,UAAI,CAACkS,UAAL,CAAgBzN,OAAhB,CAAwB,UAAU8O,cAAV,EAA0BrN,cAA1B,EAA0C;AAChEqN,sBAAc,CAAC9O,OAAf,CAAuB,UAAU+O,KAAV,EAAiB;AACtCxT,cAAI,CAACsH,OAAL,CAAapB,cAAb,EAA6BlG,IAAI,CAACoS,SAAL,CAAeG,OAAf,CAAuBiB,KAAvB,CAA7B;AACD,SAFD;AAGD,OAJD;AAKD,KAND;AAOD,GA3I8B;AA6I/B;AACA;AACA;AACA;AACA;AACA7C,WAAS,EAAE,YAAY;AACrB,QAAI3Q,IAAI,GAAG,IAAX;AACA,WAAO,IAAI+Q,YAAJ,CACL/Q,IAAI,CAACgC,QADA,EACUhC,IAAI,CAAC4R,QADf,EACyB5R,IAAI,CAAC6R,eAD9B,EAC+C7R,IAAI,CAAC8R,OADpD,EAEL9R,IAAI,CAACkR,KAFA,CAAP;AAGD,GAvJ8B;;AAyJ/B;;;;;;;AAOA3D,OAAK,EAAE,UAAUA,KAAV,EAAiB;AACtB,QAAIvN,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACE;;AACF3S,QAAI,CAACgC,QAAL,CAAcmM,iBAAd,CAAgCnO,IAAI,CAAC6R,eAArC,EAAsDtE,KAAtD;AACD,GArK8B;AAuK/B;AACA;AACA;AACA;;AAEA;;;;;;AAMAxB,MAAI,EAAE,YAAY;AAChB,QAAI/L,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACE;;AACF3S,QAAI,CAACgC,QAAL,CAAcmM,iBAAd,CAAgCnO,IAAI,CAAC6R,eAArC;AACD,GAvL8B;;AAyL/B;;;;;;;AAOA4B,QAAM,EAAE,UAAU9Q,QAAV,EAAoB;AAC1B,QAAI3C,IAAI,GAAG,IAAX;AACA2C,YAAQ,GAAG4F,MAAM,CAACoB,eAAP,CAAuBhH,QAAvB,EAAiC,iBAAjC,EAAoD3C,IAApD,CAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACEhQ,QAAQ,GADV,KAGE3C,IAAI,CAACiS,cAAL,CAAoBvS,IAApB,CAAyBiD,QAAzB;AACH,GAvM8B;AAyM/B;AACA;AACA;AACAgQ,gBAAc,EAAE,YAAY;AAC1B,QAAI3S,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAACgS,YAAL,IAAqBhS,IAAI,CAACgC,QAAL,CAAcsG,OAAd,KAA0B,IAAtD;AACD,GA/M8B;;AAiN/B;;;;;;;;;AASAnB,OAAK,EAAE,UAAUjB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC3C,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAGjH,IAAI,CAACoS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACA,QAAIyM,GAAG,GAAG1T,IAAI,CAACkS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,CAAV;;AACA,QAAIwN,GAAG,IAAI,IAAX,EAAiB;AACfA,SAAG,GAAG,IAAIvP,GAAJ,EAAN;;AACAnE,UAAI,CAACkS,UAAL,CAAgBpM,GAAhB,CAAoBI,cAApB,EAAoCwN,GAApC;AACD;;AACDA,OAAG,CAAC7L,GAAJ,CAAQZ,EAAR;;AACAjH,QAAI,CAACgC,QAAL,CAAcmF,KAAd,CAAoBnH,IAAI,CAAC+R,mBAAzB,EAA8C7L,cAA9C,EAA8De,EAA9D,EAAkEM,MAAlE;AACD,GAtO8B;;AAwO/B;;;;;;;;;AASAI,SAAO,EAAE,UAAUzB,cAAV,EAA0Be,EAA1B,EAA8BM,MAA9B,EAAsC;AAC7C,QAAIvH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAGjH,IAAI,CAACoS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL;;AACAjH,QAAI,CAACgC,QAAL,CAAc2F,OAAd,CAAsB3H,IAAI,CAAC+R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE,EAAoEM,MAApE;AACD,GAvP8B;;AAyP/B;;;;;;;;AAQAD,SAAO,EAAE,UAAUpB,cAAV,EAA0Be,EAA1B,EAA8B;AACrC,QAAIjH,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACE;AACF1L,MAAE,GAAGjH,IAAI,CAACoS,SAAL,CAAeC,WAAf,CAA2BpL,EAA3B,CAAL,CAJqC,CAKrC;AACA;;AACAjH,QAAI,CAACkS,UAAL,CAAgBlN,GAAhB,CAAoBkB,cAApB,EAAoCX,MAApC,CAA2C0B,EAA3C;;AACAjH,QAAI,CAACgC,QAAL,CAAcsF,OAAd,CAAsBtH,IAAI,CAAC+R,mBAA3B,EAAgD7L,cAAhD,EAAgEe,EAAhE;AACD,GA1Q8B;;AA4Q/B;;;;;;AAMA+L,OAAK,EAAE,YAAY;AACjB,QAAIhT,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC2S,cAAL,EAAJ,EACE;AACF,QAAI,CAAC3S,IAAI,CAAC6R,eAAV,EACE,OALe,CAKN;;AACX,QAAI,CAAC7R,IAAI,CAACmS,MAAV,EAAkB;AAChBnS,UAAI,CAACgC,QAAL,CAAcgJ,SAAd,CAAwB,CAAChL,IAAI,CAAC6R,eAAN,CAAxB;;AACA7R,UAAI,CAACmS,MAAL,GAAc,IAAd;AACD;AACF;AA5R8B,CAAjC;AA+RA;;AACA;;AACA;;;AAEAwB,MAAM,GAAG,UAAUxL,OAAV,EAAmB;AAC1B,MAAInI,IAAI,GAAG,IAAX,CAD0B,CAG1B;AACA;AACA;AACA;AACA;AACA;AACA;;AACAA,MAAI,CAACmI,OAAL,GAAelJ,CAAC,CAAC2U,QAAF,CAAWzL,OAAO,IAAI,EAAtB,EAA0B;AACvCkC,qBAAiB,EAAE,KADoB;AAEvCI,oBAAgB,EAAE,KAFqB;AAGvC;AACApB,kBAAc,EAAE;AAJuB,GAA1B,CAAf,CAV0B,CAiB1B;AACA;AACA;AACA;;AACArJ,MAAI,CAAC6T,gBAAL,GAAwB,IAAIC,IAAJ,CAAS;AAC/BC,wBAAoB,EAAE;AADS,GAAT,CAAxB,CArB0B,CAyB1B;;AACA/T,MAAI,CAAC+M,aAAL,GAAqB,IAAI+G,IAAJ,CAAS;AAC5BC,wBAAoB,EAAE;AADM,GAAT,CAArB;AAIA/T,MAAI,CAACsN,gBAAL,GAAwB,EAAxB;AACAtN,MAAI,CAAC4L,0BAAL,GAAkC,EAAlC;AAEA5L,MAAI,CAAC2O,eAAL,GAAuB,EAAvB;AAEA3O,MAAI,CAACgU,QAAL,GAAgB,IAAI3P,GAAJ,EAAhB,CAnC0B,CAmCC;;AAE3BrE,MAAI,CAACiU,aAAL,GAAqB,IAAIlU,YAAJ,EAArB;AAEAC,MAAI,CAACiU,aAAL,CAAmBnR,QAAnB,CAA4B,UAAUlB,MAAV,EAAkB;AAC5C;AACAA,UAAM,CAACoK,cAAP,GAAwB,IAAxB;;AAEA,QAAIM,SAAS,GAAG,UAAUC,MAAV,EAAkBC,gBAAlB,EAAoC;AAClD,UAAIvC,GAAG,GAAG;AAACA,WAAG,EAAE,OAAN;AAAesC,cAAM,EAAEA;AAAvB,OAAV;AACA,UAAIC,gBAAJ,EACEvC,GAAG,CAACuC,gBAAJ,GAAuBA,gBAAvB;AACF5K,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuBpC,GAAvB,CAAZ;AACD,KALD;;AAOArI,UAAM,CAACD,EAAP,CAAU,MAAV,EAAkB,UAAUuS,OAAV,EAAmB;AACnC,UAAI3L,MAAM,CAAC4L,iBAAX,EAA8B;AAC5B5L,cAAM,CAAC6D,MAAP,CAAc,cAAd,EAA8B8H,OAA9B;AACD;;AACD,UAAI;AACF,YAAI;AACF,cAAIjK,GAAG,GAAGM,SAAS,CAAC6J,QAAV,CAAmBF,OAAnB,CAAV;AACD,SAFD,CAEE,OAAOlM,GAAP,EAAY;AACZsE,mBAAS,CAAC,aAAD,CAAT;AACA;AACD;;AACD,YAAIrC,GAAG,KAAK,IAAR,IAAgB,CAACA,GAAG,CAACA,GAAzB,EAA8B;AAC5BqC,mBAAS,CAAC,aAAD,EAAgBrC,GAAhB,CAAT;AACA;AACD;;AAED,YAAIA,GAAG,CAACA,GAAJ,KAAY,SAAhB,EAA2B;AACzB,cAAIrI,MAAM,CAACoK,cAAX,EAA2B;AACzBM,qBAAS,CAAC,mBAAD,EAAsBrC,GAAtB,CAAT;AACA;AACD;;AACDjG,eAAK,CAAC,YAAY;AAChBhE,gBAAI,CAACqU,cAAL,CAAoBzS,MAApB,EAA4BqI,GAA5B;AACD,WAFI,CAAL,CAEGG,GAFH;AAGA;AACD;;AAED,YAAI,CAACxI,MAAM,CAACoK,cAAZ,EAA4B;AAC1BM,mBAAS,CAAC,oBAAD,EAAuBrC,GAAvB,CAAT;AACA;AACD;;AACDrI,cAAM,CAACoK,cAAP,CAAsBS,cAAtB,CAAqCxC,GAArC;AACD,OA5BD,CA4BE,OAAOyI,CAAP,EAAU;AACV;AACAnK,cAAM,CAAC6D,MAAP,CAAc,6CAAd,EAA6DnC,GAA7D,EAAkEyI,CAAlE;AACD;AACF,KApCD;AAsCA9Q,UAAM,CAACD,EAAP,CAAU,OAAV,EAAmB,YAAY;AAC7B,UAAIC,MAAM,CAACoK,cAAX,EAA2B;AACzBhI,aAAK,CAAC,YAAY;AAChBpC,gBAAM,CAACoK,cAAP,CAAsBzC,KAAtB;AACD,SAFI,CAAL,CAEGa,GAFH;AAGD;AACF,KAND;AAOD,GAxDD;AAyDD,CAhGD;;AAkGAnL,CAAC,CAAC2D,MAAF,CAAS+Q,MAAM,CAAC9Q,SAAhB,EAA2B;AAEzB;;;;;;;AAOAyR,cAAY,EAAE,UAAU7K,EAAV,EAAc;AAC1B,QAAIzJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC6T,gBAAL,CAAsB/Q,QAAtB,CAA+B2G,EAA/B,CAAP;AACD,GAZwB;;AAczB;;;;;;;AAOA8K,WAAS,EAAE,UAAU9K,EAAV,EAAc;AACvB,QAAIzJ,IAAI,GAAG,IAAX;AACA,WAAOA,IAAI,CAAC+M,aAAL,CAAmBjK,QAAnB,CAA4B2G,EAA5B,CAAP;AACD,GAxBwB;AA0BzB4K,gBAAc,EAAE,UAAUzS,MAAV,EAAkBqI,GAAlB,EAAuB;AACrC,QAAIjK,IAAI,GAAG,IAAX,CADqC,CAGrC;AACA;;AACA,QAAI,EAAE,OAAQiK,GAAG,CAAC/B,OAAZ,KAAyB,QAAzB,IACAjJ,CAAC,CAACgU,OAAF,CAAUhJ,GAAG,CAACuK,OAAd,CADA,IAEAvV,CAAC,CAACiU,GAAF,CAAMjJ,GAAG,CAACuK,OAAV,EAAmBvV,CAAC,CAACwS,QAArB,CAFA,IAGAxS,CAAC,CAACwV,QAAF,CAAWxK,GAAG,CAACuK,OAAf,EAAwBvK,GAAG,CAAC/B,OAA5B,CAHF,CAAJ,EAG6C;AAC3CtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AACT/B,eAAO,EAAEqC,SAAS,CAACmK,sBAAV,CAAiC,CAAjC;AADA,OAAvB,CAAZ;AAEA9S,YAAM,CAAC2H,KAAP;AACA;AACD,KAboC,CAerC;AACA;;;AACA,QAAIrB,OAAO,GAAGyM,gBAAgB,CAAC1K,GAAG,CAACuK,OAAL,EAAcjK,SAAS,CAACmK,sBAAxB,CAA9B;;AAEA,QAAIzK,GAAG,CAAC/B,OAAJ,KAAgBA,OAApB,EAA6B;AAC3B;AACA;AACA;AACAtG,YAAM,CAACQ,IAAP,CAAYmI,SAAS,CAAC8B,YAAV,CAAuB;AAACpC,WAAG,EAAE,QAAN;AAAgB/B,eAAO,EAAEA;AAAzB,OAAvB,CAAZ;AACAtG,YAAM,CAAC2H,KAAP;AACA;AACD,KA1BoC,CA4BrC;AACA;AACA;;;AACA3H,UAAM,CAACoK,cAAP,GAAwB,IAAI/D,OAAJ,CAAYjI,IAAZ,EAAkBkI,OAAlB,EAA2BtG,MAA3B,EAAmC5B,IAAI,CAACmI,OAAxC,CAAxB;AACAnI,QAAI,CAACgU,QAAL,CAAclO,GAAd,CAAkBlE,MAAM,CAACoK,cAAP,CAAsB/E,EAAxC,EAA4CrF,MAAM,CAACoK,cAAnD;AACAhM,QAAI,CAAC6T,gBAAL,CAAsBnR,IAAtB,CAA2B,UAAUC,QAAV,EAAoB;AAC7C,UAAIf,MAAM,CAACoK,cAAX,EACErJ,QAAQ,CAACf,MAAM,CAACoK,cAAP,CAAsB1C,gBAAvB,CAAR;AACF,aAAO,IAAP;AACD,KAJD;AAKD,GAhEwB;;AAiEzB;;;;;;;;;;;;;;;;;;;;;;;AAuBA;;;;;;;;AAQAsL,SAAO,EAAE,UAAUzH,IAAV,EAAgBtB,OAAhB,EAAyB1D,OAAzB,EAAkC;AACzC,QAAInI,IAAI,GAAG,IAAX;;AAEA,QAAI,CAAEf,CAAC,CAAC4V,QAAF,CAAW1H,IAAX,CAAN,EAAwB;AACtBhF,aAAO,GAAGA,OAAO,IAAI,EAArB;;AAEA,UAAIgF,IAAI,IAAIA,IAAI,IAAInN,IAAI,CAACsN,gBAAzB,EAA2C;AACzC/E,cAAM,CAAC6D,MAAP,CAAc,uCAAuCe,IAAvC,GAA8C,GAA5D;;AACA;AACD;;AAED,UAAItC,OAAO,CAACiK,WAAR,IAAuB,CAAC3M,OAAO,CAAC4M,OAApC,EAA6C;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAI,CAAC/U,IAAI,CAACgV,wBAAV,EAAoC;AAClChV,cAAI,CAACgV,wBAAL,GAAgC,IAAhC;;AACAzM,gBAAM,CAAC6D,MAAP,CACN,0EACA,yEADA,GAEA,uEAFA,GAGA,yCAHA,GAIA,MAJA,GAKA,gEALA,GAMA,MANA,GAOA,oCAPA,GAQA,MARA,GASA,8EATA,GAUA,wDAXM;AAYD;AACF;;AAED,UAAIe,IAAJ,EACEnN,IAAI,CAACsN,gBAAL,CAAsBH,IAAtB,IAA8BtB,OAA9B,CADF,KAEK;AACH7L,YAAI,CAAC4L,0BAAL,CAAgClM,IAAhC,CAAqCmM,OAArC,EADG,CAEH;AACA;AACA;;AACA7L,YAAI,CAACgU,QAAL,CAAcvP,OAAd,CAAsB,UAAUyF,OAAV,EAAmB;AACvC,cAAI,CAACA,OAAO,CAAClB,0BAAb,EAAyC;AACvChF,iBAAK,CAAC,YAAW;AACfkG,qBAAO,CAAC4B,kBAAR,CAA2BD,OAA3B;AACD,aAFI,CAAL,CAEGzB,GAFH;AAGD;AACF,SAND;AAOD;AACF,KAhDD,MAiDI;AACFnL,OAAC,CAACyD,IAAF,CAAOyK,IAAP,EAAa,UAASvI,KAAT,EAAgBD,GAAhB,EAAqB;AAChC3E,YAAI,CAAC4U,OAAL,CAAajQ,GAAb,EAAkBC,KAAlB,EAAyB,EAAzB;AACD,OAFD;AAGD;AACF,GAzJwB;AA2JzBsH,gBAAc,EAAE,UAAUhC,OAAV,EAAmB;AACjC,QAAIlK,IAAI,GAAG,IAAX;AACAA,QAAI,CAACgU,QAAL,CAAczO,MAAd,CAAqB2E,OAAO,CAACjD,EAA7B;AACD,GA9JwB;;AAgKzB;;;;;;;AAOAyH,SAAO,EAAE,UAAUA,OAAV,EAAmB;AAC1B,QAAI1O,IAAI,GAAG,IAAX;;AACAf,KAAC,CAACyD,IAAF,CAAOgM,OAAP,EAAgB,UAAUuG,IAAV,EAAgB9H,IAAhB,EAAsB;AACpC,UAAI,OAAO8H,IAAP,KAAgB,UAApB,EACE,MAAM,IAAIlN,KAAJ,CAAU,aAAaoF,IAAb,GAAoB,sBAA9B,CAAN;AACF,UAAInN,IAAI,CAAC2O,eAAL,CAAqBxB,IAArB,CAAJ,EACE,MAAM,IAAIpF,KAAJ,CAAU,qBAAqBoF,IAArB,GAA4B,sBAAtC,CAAN;AACFnN,UAAI,CAAC2O,eAAL,CAAqBxB,IAArB,IAA6B8H,IAA7B;AACD,KAND;AAOD,GAhLwB;AAkLzBhI,MAAI,EAAE,UAAUE,IAAV,EAAyB;AAAA,sCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAC7B,QAAIA,IAAI,CAAC4B,MAAL,IAAe,OAAO5B,IAAI,CAACA,IAAI,CAAC4B,MAAL,GAAc,CAAf,CAAX,KAAiC,UAApD,EAAgE;AAC9D;AACA;AACA,UAAIzC,QAAQ,GAAGa,IAAI,CAAC0R,GAAL,EAAf;AACD;;AAED,WAAO,KAAKpR,KAAL,CAAWqJ,IAAX,EAAiB3J,IAAjB,EAAuBb,QAAvB,CAAP;AACD,GA1LwB;AA4LzB;AACAwS,WAAS,EAAE,UAAUhI,IAAV,EAAyB;AAAA,uCAAN3J,IAAM;AAANA,UAAM;AAAA;;AAClC,WAAO,KAAK4R,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,CAAP;AACD,GA/LwB;AAiMzBM,OAAK,EAAE,UAAUqJ,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+BxF,QAA/B,EAAyC;AAC9C;AACA;AACA,QAAI,CAAEA,QAAF,IAAc,OAAOwF,OAAP,KAAmB,UAArC,EAAiD;AAC/CxF,cAAQ,GAAGwF,OAAX;AACAA,aAAO,GAAG,EAAV;AACD,KAHD,MAGO;AACLA,aAAO,GAAGA,OAAO,IAAI,EAArB;AACD;;AAED,UAAM+G,OAAO,GAAG,KAAKkG,UAAL,CAAgBjI,IAAhB,EAAsB3J,IAAtB,EAA4B2E,OAA5B,CAAhB,CAV8C,CAY9C;AACA;AACA;AACA;AACA;;AACA,QAAIxF,QAAJ,EAAc;AACZuM,aAAO,CAACW,IAAR,CACEC,MAAM,IAAInN,QAAQ,CAACuC,SAAD,EAAY4K,MAAZ,CADpB,EAEEC,SAAS,IAAIpN,QAAQ,CAACoN,SAAD,CAFvB;AAID,KALD,MAKO;AACL,aAAOb,OAAO,CAACmG,KAAR,EAAP;AACD;AACF,GA1NwB;AA4NzB;AACAD,YAAU,EAAE,UAAUjI,IAAV,EAAgB3J,IAAhB,EAAsB2E,OAAtB,EAA+B;AACzC;AACA,QAAI0D,OAAO,GAAG,KAAK8C,eAAL,CAAqBxB,IAArB,CAAd;;AACA,QAAI,CAAEtB,OAAN,EAAe;AACb,aAAOsD,OAAO,CAACE,MAAR,CACL,IAAI9G,MAAM,CAACR,KAAX,CAAiB,GAAjB,oBAAiCoF,IAAjC,iBADK,CAAP;AAGD,KAPwC,CASzC;AACA;AACA;;;AACA,QAAItE,MAAM,GAAG,IAAb;;AACA,QAAIgG,SAAS,GAAG,YAAW;AACzB,YAAM,IAAI9G,KAAJ,CAAU,wDAAV,CAAN;AACD,KAFD;;AAGA,QAAI7F,UAAU,GAAG,IAAjB;;AACA,QAAIoT,uBAAuB,GAAG9F,GAAG,CAACC,wBAAJ,CAA6BzK,GAA7B,EAA9B;;AACA,QAAIuQ,4BAA4B,GAAG/F,GAAG,CAACiD,6BAAJ,CAAkCzN,GAAlC,EAAnC;;AACA,QAAIqJ,UAAU,GAAG,IAAjB;;AACA,QAAIiH,uBAAJ,EAA6B;AAC3BzM,YAAM,GAAGyM,uBAAuB,CAACzM,MAAjC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3ByM,+BAAuB,CAACzG,SAAxB,CAAkChG,MAAlC;AACD,OAFD;;AAGA3G,gBAAU,GAAGoT,uBAAuB,CAACpT,UAArC;AACAmM,gBAAU,GAAG9D,SAAS,CAACiL,WAAV,CAAsBF,uBAAtB,EAA+CnI,IAA/C,CAAb;AACD,KAPD,MAOO,IAAIoI,4BAAJ,EAAkC;AACvC1M,YAAM,GAAG0M,4BAA4B,CAAC1M,MAAtC;;AACAgG,eAAS,GAAG,UAAShG,MAAT,EAAiB;AAC3B0M,oCAA4B,CAACvT,QAA7B,CAAsC8M,UAAtC,CAAiDjG,MAAjD;AACD,OAFD;;AAGA3G,gBAAU,GAAGqT,4BAA4B,CAACrT,UAA1C;AACD;;AAED,QAAI6M,UAAU,GAAG,IAAIxE,SAAS,CAACyE,gBAAd,CAA+B;AAC9CC,kBAAY,EAAE,KADgC;AAE9CpG,YAF8C;AAG9CgG,eAH8C;AAI9C3M,gBAJ8C;AAK9CmM;AAL8C,KAA/B,CAAjB;AAQA,WAAO,IAAIc,OAAJ,CAAYC,OAAO,IAAIA,OAAO,CACnCI,GAAG,CAACC,wBAAJ,CAA6BF,SAA7B,CACER,UADF,EAEE,MAAMW,wBAAwB,CAC5B7D,OAD4B,EACnBkD,UADmB,EACPvJ,KAAK,CAACI,KAAN,CAAYpC,IAAZ,CADO,EAE5B,uBAAuB2J,IAAvB,GAA8B,GAFF,CAFhC,CADmC,CAA9B,EAQJ0C,IARI,CAQCrK,KAAK,CAACI,KARP,CAAP;AASD,GAjRwB;AAmRzB6P,gBAAc,EAAE,UAAUC,SAAV,EAAqB;AACnC,QAAI1V,IAAI,GAAG,IAAX;AACA,QAAIkK,OAAO,GAAGlK,IAAI,CAACgU,QAAL,CAAchP,GAAd,CAAkB0Q,SAAlB,CAAd;AACA,QAAIxL,OAAJ,EACE,OAAOA,OAAO,CAACf,UAAf,CADF,KAGE,OAAO,IAAP;AACH;AA1RwB,CAA3B;;AA6RA,IAAIwL,gBAAgB,GAAG,UAAUgB,uBAAV,EACUC,uBADV,EACmC;AACxD,MAAIC,cAAc,GAAG5W,CAAC,CAAC+G,IAAF,CAAO2P,uBAAP,EAAgC,UAAUzN,OAAV,EAAmB;AACtE,WAAOjJ,CAAC,CAACwV,QAAF,CAAWmB,uBAAX,EAAoC1N,OAApC,CAAP;AACD,GAFoB,CAArB;;AAGA,MAAI,CAAC2N,cAAL,EAAqB;AACnBA,kBAAc,GAAGD,uBAAuB,CAAC,CAAD,CAAxC;AACD;;AACD,SAAOC,cAAP;AACD,CATD;;AAWA9R,SAAS,CAAC+R,iBAAV,GAA8BnB,gBAA9B,C,CAGA;AACA;;AACA,IAAI3E,qBAAqB,GAAG,UAAUD,SAAV,EAAqBgG,OAArB,EAA8B;AACxD,MAAI,CAAChG,SAAL,EAAgB,OAAOA,SAAP,CADwC,CAGxD;AACA;AACA;;AACA,MAAIA,SAAS,CAACiG,YAAd,EAA4B;AAC1B,QAAI,EAAEjG,SAAS,YAAYxH,MAAM,CAACR,KAA9B,CAAJ,EAA0C;AACxC,YAAMkO,eAAe,GAAGlG,SAAS,CAACmG,OAAlC;AACAnG,eAAS,GAAG,IAAIxH,MAAM,CAACR,KAAX,CAAiBgI,SAAS,CAACxC,KAA3B,EAAkCwC,SAAS,CAACxD,MAA5C,EAAoDwD,SAAS,CAACoG,OAA9D,CAAZ;AACApG,eAAS,CAACmG,OAAV,GAAoBD,eAApB;AACD;;AACD,WAAOlG,SAAP;AACD,GAbuD,CAexD;AACA;;;AACA,MAAI,CAACA,SAAS,CAACqG,eAAf,EAAgC;AAC9B7N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAA7B,EAAsChG,SAAS,CAACsG,KAAhD;;AACA,QAAItG,SAAS,CAACuG,cAAd,EAA8B;AAC5B/N,YAAM,CAAC6D,MAAP,CAAc,0CAAd,EAA0D2D,SAAS,CAACuG,cAApE;;AACA/N,YAAM,CAAC6D,MAAP;AACD;AACF,GAvBuD,CAyBxD;AACA;AACA;AACA;;;AACA,MAAI2D,SAAS,CAACuG,cAAd,EAA8B;AAC5B,QAAIvG,SAAS,CAACuG,cAAV,CAAyBN,YAA7B,EACE,OAAOjG,SAAS,CAACuG,cAAjB;;AACF/N,UAAM,CAAC6D,MAAP,CAAc,eAAe2J,OAAf,GAAyB,kCAAzB,GACA,mDADd;AAED;;AAED,SAAO,IAAIxN,MAAM,CAACR,KAAX,CAAiB,GAAjB,EAAsB,uBAAtB,CAAP;AACD,CArCD,C,CAwCA;AACA;;;AACA,IAAI2H,wBAAwB,GAAG,UAAUQ,CAAV,EAAa6F,OAAb,EAAsBvS,IAAtB,EAA4B+S,WAA5B,EAAyC;AACtE/S,MAAI,GAAGA,IAAI,IAAI,EAAf;;AACA,MAAIqH,OAAO,CAAC,uBAAD,CAAX,EAAsC;AACpC,WAAO2L,KAAK,CAACC,gCAAN,CACLvG,CADK,EACF6F,OADE,EACOvS,IADP,EACa+S,WADb,CAAP;AAED;;AACD,SAAOrG,CAAC,CAACpM,KAAF,CAAQiS,OAAR,EAAiBvS,IAAjB,CAAP;AACD,CAPD,C;;;;;;;;;;;ACpuDA,IAAIkT,MAAM,GAAG5X,GAAG,CAACC,OAAJ,CAAY,eAAZ,CAAb,C,CAEA;AACA;AACA;AACA;;;AACAgF,SAAS,CAACwK,WAAV,GAAwB,YAAY;AAClC,MAAIvO,IAAI,GAAG,IAAX;AAEAA,MAAI,CAAC2W,KAAL,GAAa,KAAb;AACA3W,MAAI,CAAC4W,KAAL,GAAa,KAAb;AACA5W,MAAI,CAAC6W,OAAL,GAAe,KAAf;AACA7W,MAAI,CAAC8W,kBAAL,GAA0B,CAA1B;AACA9W,MAAI,CAAC+W,qBAAL,GAA6B,EAA7B;AACA/W,MAAI,CAACgX,oBAAL,GAA4B,EAA5B;AACD,CATD,C,CAWA;AACA;AACA;AACA;;;AACAjT,SAAS,CAACuL,kBAAV,GAA+B,IAAI/G,MAAM,CAAC0O,mBAAX,EAA/B;;AAEAhY,CAAC,CAAC2D,MAAF,CAASmB,SAAS,CAACwK,WAAV,CAAsB1L,SAA/B,EAA0C;AACxC;AACA;AACA;AACA;AACA;AACAqU,YAAU,EAAE,YAAY;AACtB,QAAIlX,IAAI,GAAG,IAAX;AAEA,QAAIA,IAAI,CAAC6W,OAAT,EACE,OAAO;AAAEM,eAAS,EAAE,YAAY,CAAE;AAA3B,KAAP;AAEF,QAAInX,IAAI,CAAC4W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,uDAAV,CAAN;AAEF/H,QAAI,CAAC8W,kBAAL;AACA,QAAIK,SAAS,GAAG,KAAhB;AACA,WAAO;AACLA,eAAS,EAAE,YAAY;AACrB,YAAIA,SAAJ,EACE,MAAM,IAAIpP,KAAJ,CAAU,0CAAV,CAAN;AACFoP,iBAAS,GAAG,IAAZ;AACAnX,YAAI,CAAC8W,kBAAL;;AACA9W,YAAI,CAACoX,UAAL;AACD;AAPI,KAAP;AASD,GA1BuC;AA4BxC;AACA;AACAxI,KAAG,EAAE,YAAY;AACf,QAAI5O,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,KAAK+D,SAAS,CAACuL,kBAAV,CAA6BtK,GAA7B,EAAb,EACE,MAAM+C,KAAK,CAAC,6BAAD,CAAX;AACF/H,QAAI,CAAC2W,KAAL,GAAa,IAAb;;AACA3W,QAAI,CAACoX,UAAL;AACD,GApCuC;AAsCxC;AACA;AACA;AACAC,cAAY,EAAE,UAAUpC,IAAV,EAAgB;AAC5B,QAAIjV,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC4W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF/H,QAAI,CAAC+W,qBAAL,CAA2BrX,IAA3B,CAAgCuV,IAAhC;AACD,GA/CuC;AAiDxC;AACAzG,gBAAc,EAAE,UAAUyG,IAAV,EAAgB;AAC9B,QAAIjV,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC4W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gDACA,gBADV,CAAN;AAEF/H,QAAI,CAACgX,oBAAL,CAA0BtX,IAA1B,CAA+BuV,IAA/B;AACD,GAxDuC;AA0DxC;AACAqC,YAAU,EAAE,YAAY;AACtB,QAAItX,IAAI,GAAG,IAAX;AACA,QAAIuX,MAAM,GAAG,IAAIb,MAAJ,EAAb;AACA1W,QAAI,CAACwO,cAAL,CAAoB,YAAY;AAC9B+I,YAAM,CAAC,QAAD,CAAN;AACD,KAFD;AAGAvX,QAAI,CAAC4O,GAAL;AACA2I,UAAM,CAACC,IAAP;AACD,GAnEuC;AAqExCJ,YAAU,EAAE,YAAY;AACtB,QAAIpX,IAAI,GAAG,IAAX;AACA,QAAIA,IAAI,CAAC4W,KAAT,EACE,MAAM,IAAI7O,KAAJ,CAAU,gCAAV,CAAN;;AACF,QAAI/H,IAAI,CAAC2W,KAAL,IAAc,CAAC3W,IAAI,CAAC8W,kBAAxB,EAA4C;AAC1C,eAASW,cAAT,CAAyBxC,IAAzB,EAA+B;AAC7B,YAAI;AACFA,cAAI,CAACjV,IAAD,CAAJ;AACD,SAFD,CAEE,OAAOgI,GAAP,EAAY;AACZO,gBAAM,CAAC6D,MAAP,CAAc,mCAAd,EAAmDpE,GAAnD;AACD;AACF;;AAEDhI,UAAI,CAAC8W,kBAAL;;AACA,aAAO9W,IAAI,CAAC+W,qBAAL,CAA2B3R,MAA3B,GAAoC,CAA3C,EAA8C;AAC5C,YAAIiB,SAAS,GAAGrG,IAAI,CAAC+W,qBAArB;AACA/W,YAAI,CAAC+W,qBAAL,GAA6B,EAA7B;;AACA9X,SAAC,CAACyD,IAAF,CAAO2D,SAAP,EAAkBoR,cAAlB;AACD;;AACDzX,UAAI,CAAC8W,kBAAL;;AAEA,UAAI,CAAC9W,IAAI,CAAC8W,kBAAV,EAA8B;AAC5B9W,YAAI,CAAC4W,KAAL,GAAa,IAAb;AACA,YAAIvQ,SAAS,GAAGrG,IAAI,CAACgX,oBAArB;AACAhX,YAAI,CAACgX,oBAAL,GAA4B,EAA5B;;AACA/X,SAAC,CAACyD,IAAF,CAAO2D,SAAP,EAAkBoR,cAAlB;AACD;AACF;AACF,GAjGuC;AAmGxC;AACA;AACAhJ,QAAM,EAAE,YAAY;AAClB,QAAIzO,IAAI,GAAG,IAAX;AACA,QAAI,CAAEA,IAAI,CAAC4W,KAAX,EACE,MAAM,IAAI7O,KAAJ,CAAU,yCAAV,CAAN;AACF/H,QAAI,CAAC6W,OAAL,GAAe,IAAf;AACD;AA1GuC,CAA1C,E;;;;;;;;;;;ACvBA;AACA;AACA;AAEA9S,SAAS,CAAC2T,SAAV,GAAsB,UAAUvP,OAAV,EAAmB;AACvC,MAAInI,IAAI,GAAG,IAAX;AACAmI,SAAO,GAAGA,OAAO,IAAI,EAArB;AAEAnI,MAAI,CAAC2X,MAAL,GAAc,CAAd,CAJuC,CAKvC;AACA;AACA;;AACA3X,MAAI,CAAC4X,qBAAL,GAA6B,EAA7B;AACA5X,MAAI,CAAC6X,0BAAL,GAAkC,EAAlC;AACA7X,MAAI,CAAC8X,WAAL,GAAmB3P,OAAO,CAAC2P,WAAR,IAAuB,UAA1C;AACA9X,MAAI,CAAC+X,QAAL,GAAgB5P,OAAO,CAAC4P,QAAR,IAAoB,IAApC;AACD,CAZD;;AAcA9Y,CAAC,CAAC2D,MAAF,CAASmB,SAAS,CAAC2T,SAAV,CAAoB7U,SAA7B,EAAwC;AACtC;AACAmV,uBAAqB,EAAE,UAAU/N,GAAV,EAAe;AACpC,QAAIjK,IAAI,GAAG,IAAX;;AACA,QAAI,CAAEf,CAAC,CAAC4G,GAAF,CAAMoE,GAAN,EAAW,YAAX,CAAN,EAAgC;AAC9B,aAAO,EAAP;AACD,KAFD,MAEO,IAAI,OAAOA,GAAG,CAACoB,UAAX,KAA2B,QAA/B,EAAyC;AAC9C,UAAIpB,GAAG,CAACoB,UAAJ,KAAmB,EAAvB,EACE,MAAMtD,KAAK,CAAC,+BAAD,CAAX;AACF,aAAOkC,GAAG,CAACoB,UAAX;AACD,KAJM,MAIA;AACL,YAAMtD,KAAK,CAAC,oCAAD,CAAX;AACD;AACF,GAbqC;AAetC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAkQ,QAAM,EAAE,UAAUC,OAAV,EAAmBvV,QAAnB,EAA6B;AACnC,QAAI3C,IAAI,GAAG,IAAX;AACA,QAAIiH,EAAE,GAAGjH,IAAI,CAAC2X,MAAL,EAAT;;AAEA,QAAItM,UAAU,GAAGrL,IAAI,CAACgY,qBAAL,CAA2BE,OAA3B,CAAjB;;AACA,QAAIC,MAAM,GAAG;AAACD,aAAO,EAAE1S,KAAK,CAACI,KAAN,CAAYsS,OAAZ,CAAV;AAAgCvV,cAAQ,EAAEA;AAA1C,KAAb;;AACA,QAAI,CAAE1D,CAAC,CAAC4G,GAAF,CAAM7F,IAAI,CAAC4X,qBAAX,EAAkCvM,UAAlC,CAAN,EAAqD;AACnDrL,UAAI,CAAC4X,qBAAL,CAA2BvM,UAA3B,IAAyC,EAAzC;AACArL,UAAI,CAAC6X,0BAAL,CAAgCxM,UAAhC,IAA8C,CAA9C;AACD;;AACDrL,QAAI,CAAC4X,qBAAL,CAA2BvM,UAA3B,EAAuCpE,EAAvC,IAA6CkR,MAA7C;AACAnY,QAAI,CAAC6X,0BAAL,CAAgCxM,UAAhC;;AAEA,QAAIrL,IAAI,CAAC+X,QAAL,IAAiBlN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,aAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE/K,IAAI,CAAC8X,WADP,EACoB9X,IAAI,CAAC+X,QADzB,EACmC,CADnC;AAED;;AAED,WAAO;AACLhM,UAAI,EAAE,YAAY;AAChB,YAAI/L,IAAI,CAAC+X,QAAL,IAAiBlN,OAAO,CAAC,YAAD,CAA5B,EAA4C;AAC1CA,iBAAO,CAAC,YAAD,CAAP,CAAsBC,KAAtB,CAA4BC,mBAA5B,CACE/K,IAAI,CAAC8X,WADP,EACoB9X,IAAI,CAAC+X,QADzB,EACmC,CAAC,CADpC;AAED;;AACD,eAAO/X,IAAI,CAAC4X,qBAAL,CAA2BvM,UAA3B,EAAuCpE,EAAvC,CAAP;AACAjH,YAAI,CAAC6X,0BAAL,CAAgCxM,UAAhC;;AACA,YAAIrL,IAAI,CAAC6X,0BAAL,CAAgCxM,UAAhC,MAAgD,CAApD,EAAuD;AACrD,iBAAOrL,IAAI,CAAC4X,qBAAL,CAA2BvM,UAA3B,CAAP;AACA,iBAAOrL,IAAI,CAAC6X,0BAAL,CAAgCxM,UAAhC,CAAP;AACD;AACF;AAZI,KAAP;AAcD,GAzDqC;AA2DtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA+M,MAAI,EAAE,UAAUC,YAAV,EAAwB;AAC5B,QAAIrY,IAAI,GAAG,IAAX;;AAEA,QAAIqL,UAAU,GAAGrL,IAAI,CAACgY,qBAAL,CAA2BK,YAA3B,CAAjB;;AAEA,QAAI,CAAEpZ,CAAC,CAAC4G,GAAF,CAAM7F,IAAI,CAAC4X,qBAAX,EAAkCvM,UAAlC,CAAN,EAAqD;AACnD;AACD;;AAED,QAAIiN,sBAAsB,GAAGtY,IAAI,CAAC4X,qBAAL,CAA2BvM,UAA3B,CAA7B;AACA,QAAIkN,WAAW,GAAG,EAAlB;;AACAtZ,KAAC,CAACyD,IAAF,CAAO4V,sBAAP,EAA+B,UAAUE,CAAV,EAAavR,EAAb,EAAiB;AAC9C,UAAIjH,IAAI,CAACyY,QAAL,CAAcJ,YAAd,EAA4BG,CAAC,CAACN,OAA9B,CAAJ,EAA4C;AAC1CK,mBAAW,CAAC7Y,IAAZ,CAAiBuH,EAAjB;AACD;AACF,KAJD,EAX4B,CAiB5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACAhI,KAAC,CAACyD,IAAF,CAAO6V,WAAP,EAAoB,UAAUtR,EAAV,EAAc;AAChC,UAAIhI,CAAC,CAAC4G,GAAF,CAAMyS,sBAAN,EAA8BrR,EAA9B,CAAJ,EAAuC;AACrCqR,8BAAsB,CAACrR,EAAD,CAAtB,CAA2BtE,QAA3B,CAAoC0V,YAApC;AACD;AACF,KAJD;AAKD,GAlGqC;AAoGtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACAI,UAAQ,EAAE,UAAUJ,YAAV,EAAwBH,OAAxB,EAAiC;AACzC;AACA;AACA;AACA;AACA;AACA,QAAI,OAAOG,YAAY,CAACpR,EAApB,KAA4B,QAA5B,IACA,OAAOiR,OAAO,CAACjR,EAAf,KAAuB,QADvB,IAEAoR,YAAY,CAACpR,EAAb,KAAoBiR,OAAO,CAACjR,EAFhC,EAEoC;AAClC,aAAO,KAAP;AACD;;AACD,QAAIoR,YAAY,CAACpR,EAAb,YAA2BqL,OAAO,CAACoG,QAAnC,IACAR,OAAO,CAACjR,EAAR,YAAsBqL,OAAO,CAACoG,QAD9B,IAEA,CAAEL,YAAY,CAACpR,EAAb,CAAgBxB,MAAhB,CAAuByS,OAAO,CAACjR,EAA/B,CAFN,EAE0C;AACxC,aAAO,KAAP;AACD;;AAED,WAAOhI,CAAC,CAACiU,GAAF,CAAMgF,OAAN,EAAe,UAAUS,YAAV,EAAwBhU,GAAxB,EAA6B;AACjD,aAAO,CAAC1F,CAAC,CAAC4G,GAAF,CAAMwS,YAAN,EAAoB1T,GAApB,CAAD,IACLa,KAAK,CAACC,MAAN,CAAakT,YAAb,EAA2BN,YAAY,CAAC1T,GAAD,CAAvC,CADF;AAED,KAHM,CAAP;AAID;AA1IqC,CAAxC,E,CA6IA;AACA;AACA;AACA;AACA;;;AACAZ,SAAS,CAAC6U,qBAAV,GAAkC,IAAI7U,SAAS,CAAC2T,SAAd,CAAwB;AACxDK,UAAQ,EAAE;AAD8C,CAAxB,CAAlC,C;;;;;;;;;;;ACpKA,IAAI1Y,OAAO,CAACC,GAAR,CAAYuZ,0BAAhB,EAA4C;AAC1ChZ,2BAAyB,CAACgZ,0BAA1B,GACExZ,OAAO,CAACC,GAAR,CAAYuZ,0BADd;AAED;;AAEDtQ,MAAM,CAACrH,MAAP,GAAgB,IAAIyS,MAAJ,EAAhB;;AAEApL,MAAM,CAACuQ,OAAP,GAAiB,UAAUT,YAAV,EAAwB;AACvCtU,WAAS,CAAC6U,qBAAV,CAAgCR,IAAhC,CAAqCC,YAArC;AACD,CAFD,C,CAIA;AACA;;;AACApZ,CAAC,CAACyD,IAAF,CAAO,CAAC,SAAD,EAAY,SAAZ,EAAuB,MAAvB,EAA+B,OAA/B,EAAwC,cAAxC,EAAwD,WAAxD,CAAP,EACO,UAAUyK,IAAV,EAAgB;AACd5E,QAAM,CAAC4E,IAAD,CAAN,GAAelO,CAAC,CAAC6H,IAAF,CAAOyB,MAAM,CAACrH,MAAP,CAAciM,IAAd,CAAP,EAA4B5E,MAAM,CAACrH,MAAnC,CAAf;AACD,CAHR,E,CAKA;AACA;AACA;;;AACAqH,MAAM,CAACwQ,cAAP,GAAwBxQ,MAAM,CAACrH,MAA/B,C","file":"/packages/ddp-server.js","sourcesContent":["var url = Npm.require('url');\n\n// By default, we use the permessage-deflate extension with default\n// configuration. If $SERVER_WEBSOCKET_COMPRESSION is set, then it must be valid\n// JSON. If it represents a falsey value, then we do not use permessage-deflate\n// at all; otherwise, the JSON value is used as an argument to deflate's\n// configure method; see\n// https://github.com/faye/permessage-deflate-node/blob/master/README.md\n//\n// (We do this in an _.once instead of at startup, because we don't want to\n// crash the tool during isopacket load if your JSON doesn't parse. This is only\n// a problem because the tool has to load the DDP server code just in order to\n// be a DDP client; see https://github.com/meteor/meteor/issues/3452 .)\nvar websocketExtensions = _.once(function () {\n var extensions = [];\n\n var websocketCompressionConfig = process.env.SERVER_WEBSOCKET_COMPRESSION\n ? JSON.parse(process.env.SERVER_WEBSOCKET_COMPRESSION) : {};\n if (websocketCompressionConfig) {\n extensions.push(Npm.require('permessage-deflate').configure(\n websocketCompressionConfig\n ));\n }\n\n return extensions;\n});\n\nvar pathPrefix = __meteor_runtime_config__.ROOT_URL_PATH_PREFIX || \"\";\n\nStreamServer = function () {\n var self = this;\n self.registration_callbacks = [];\n self.open_sockets = [];\n\n // Because we are installing directly onto WebApp.httpServer instead of using\n // WebApp.app, we have to process the path prefix ourselves.\n self.prefix = pathPrefix + '/sockjs';\n RoutePolicy.declare(self.prefix + '/', 'network');\n\n // set up sockjs\n var sockjs = Npm.require('sockjs');\n var serverOptions = {\n prefix: self.prefix,\n log: function () { },\n // this is the default, but we code it explicitly because we depend\n // on it in stream_client:HEARTBEAT_TIMEOUT\n heartbeat_delay: 45000,\n // The default disconnect_delay is 5 seconds, but if the server ends up CPU\n // bound for that much time, SockJS might not notice that the user has\n // reconnected because the timer (of disconnect_delay ms) can fire before\n // SockJS processes the new connection. Eventually we'll fix this by not\n // combining CPU-heavy processing with SockJS termination (eg a proxy which\n // converts to Unix sockets) but for now, raise the delay.\n disconnect_delay: 60 * 1000,\n // Allow disabling of CORS requests to address\n // https://github.com/meteor/meteor/issues/8317.\n disable_cors: !!process.env.DISABLE_SOCKJS_CORS,\n // Set the USE_JSESSIONID environment variable to enable setting the\n // JSESSIONID cookie. This is useful for setting up proxies with\n // session affinity.\n jsessionid: !!process.env.USE_JSESSIONID\n };\n\n // If you know your server environment (eg, proxies) will prevent websockets\n // from ever working, set $DISABLE_WEBSOCKETS and SockJS clients (ie,\n // browsers) will not waste time attempting to use them.\n // (Your server will still have a /websocket endpoint.)\n if (process.env.DISABLE_WEBSOCKETS) {\n serverOptions.websocket = false;\n } else {\n serverOptions.faye_server_options = {\n extensions: websocketExtensions()\n };\n }\n\n self.server = sockjs.createServer(serverOptions);\n\n // Install the sockjs handlers, but we want to keep around our own particular\n // request handler that adjusts idle timeouts while we have an outstanding\n // request. This compensates for the fact that sockjs removes all listeners\n // for \"request\" to add its own.\n WebApp.httpServer.removeListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n self.server.installHandlers(WebApp.httpServer);\n WebApp.httpServer.addListener(\n 'request', WebApp._timeoutAdjustmentRequestCallback);\n\n // Support the /websocket endpoint\n self._redirectWebsocketEndpoint();\n\n self.server.on('connection', function (socket) {\n // We want to make sure that if a client connects to us and does the initial\n // Websocket handshake but never gets to the DDP handshake, that we\n // eventually kill the socket. Once the DDP handshake happens, DDP\n // heartbeating will work. And before the Websocket handshake, the timeouts\n // we set at the server level in webapp_server.js will work. But\n // faye-websocket calls setTimeout(0) on any socket it takes over, so there\n // is an \"in between\" state where this doesn't happen. We work around this\n // by explicitly setting the socket timeout to a relatively large time here,\n // and setting it back to zero when we set up the heartbeat in\n // livedata_server.js.\n socket.setWebsocketTimeout = function (timeout) {\n if ((socket.protocol === 'websocket' ||\n socket.protocol === 'websocket-raw')\n && socket._session.recv) {\n socket._session.recv.connection.setTimeout(timeout);\n }\n };\n socket.setWebsocketTimeout(45 * 1000);\n\n socket.send = function (data) {\n socket.write(data);\n };\n socket.on('close', function () {\n self.open_sockets = _.without(self.open_sockets, socket);\n });\n self.open_sockets.push(socket);\n\n // XXX COMPAT WITH 0.6.6. Send the old style welcome message, which\n // will force old clients to reload. Remove this once we're not\n // concerned about people upgrading from a pre-0.7.0 release. Also,\n // remove the clause in the client that ignores the welcome message\n // (livedata_connection.js)\n socket.send(JSON.stringify({ server_id: \"0\" }));\n\n // call all our callbacks when we get a new socket. they will do the\n // work of setting up handlers and such for specific messages.\n _.each(self.registration_callbacks, function (callback) {\n callback(socket);\n });\n });\n\n};\n\n_.extend(StreamServer.prototype, {\n // call my callback when a new socket connects.\n // also call it for all current connections.\n register: function (callback) {\n var self = this;\n self.registration_callbacks.push(callback);\n _.each(self.all_sockets(), function (socket) {\n callback(socket);\n });\n },\n\n // get a list of all sockets\n all_sockets: function () {\n var self = this;\n return _.values(self.open_sockets);\n },\n\n // Redirect /websocket to /sockjs/websocket in order to not expose\n // sockjs to clients that want to use raw websockets\n _redirectWebsocketEndpoint: function () {\n var self = this;\n // Unfortunately we can't use a connect middleware here since\n // sockjs installs itself prior to all existing listeners\n // (meaning prior to any connect middlewares) so we need to take\n // an approach similar to overshadowListeners in\n // https://github.com/sockjs/sockjs-node/blob/cf820c55af6a9953e16558555a31decea554f70e/src/utils.coffee\n _.each(['request', 'upgrade'], function (event) {\n var httpServer = WebApp.httpServer;\n var oldHttpServerListeners = httpServer.listeners(event).slice(0);\n httpServer.removeAllListeners(event);\n\n // request and upgrade have different arguments passed but\n // we only care about the first one which is always request\n var newListener = function (request /*, moreArguments */) {\n // Store arguments for use within the closure below\n var args = arguments;\n\n // Rewrite /websocket and /websocket/ urls to /sockjs/websocket while\n // preserving query string.\n var parsedUrl = url.parse(request.url);\n if (parsedUrl.pathname === pathPrefix + '/websocket' ||\n parsedUrl.pathname === pathPrefix + '/websocket/') {\n parsedUrl.pathname = self.prefix + '/websocket';\n request.url = url.format(parsedUrl);\n }\n _.each(oldHttpServerListeners, function (oldListener) {\n oldListener.apply(httpServer, args);\n });\n };\n httpServer.addListener(event, newListener);\n });\n }\n});\n","DDPServer = {};\n\nvar Fiber = Npm.require('fibers');\n\n// This file contains classes:\n// * Session - The server's connection to a single DDP client\n// * Subscription - A single subscription for a single client\n// * Server - An entire server that may talk to > 1 client. A DDP endpoint.\n//\n// Session and Subscription are file scope. For now, until we freeze\n// the interface, Server is package scope (in the future it should be\n// exported.)\n\n// Represents a single document in a SessionCollectionView\nvar SessionDocumentView = function () {\n var self = this;\n self.existsIn = new Set(); // set of subscriptionHandle\n self.dataByKey = new Map(); // key-> [ {subscriptionHandle, value} by precedence]\n};\n\nDDPServer._SessionDocumentView = SessionDocumentView;\n\n\n_.extend(SessionDocumentView.prototype, {\n\n getFields: function () {\n var self = this;\n var ret = {};\n self.dataByKey.forEach(function (precedenceList, key) {\n ret[key] = precedenceList[0].value;\n });\n return ret;\n },\n\n clearField: function (subscriptionHandle, key, changeCollector) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n var precedenceList = self.dataByKey.get(key);\n\n // It's okay to clear fields that didn't exist. No need to throw\n // an error.\n if (!precedenceList)\n return;\n\n var removedValue = undefined;\n for (var i = 0; i < precedenceList.length; i++) {\n var precedence = precedenceList[i];\n if (precedence.subscriptionHandle === subscriptionHandle) {\n // The view's value can only change if this subscription is the one that\n // used to have precedence.\n if (i === 0)\n removedValue = precedence.value;\n precedenceList.splice(i, 1);\n break;\n }\n }\n if (precedenceList.length === 0) {\n self.dataByKey.delete(key);\n changeCollector[key] = undefined;\n } else if (removedValue !== undefined &&\n !EJSON.equals(removedValue, precedenceList[0].value)) {\n changeCollector[key] = precedenceList[0].value;\n }\n },\n\n changeField: function (subscriptionHandle, key, value,\n changeCollector, isAdd) {\n var self = this;\n // Publish API ignores _id if present in fields\n if (key === \"_id\")\n return;\n\n // Don't share state with the data passed in by the user.\n value = EJSON.clone(value);\n\n if (!self.dataByKey.has(key)) {\n self.dataByKey.set(key, [{subscriptionHandle: subscriptionHandle,\n value: value}]);\n changeCollector[key] = value;\n return;\n }\n var precedenceList = self.dataByKey.get(key);\n var elt;\n if (!isAdd) {\n elt = precedenceList.find(function (precedence) {\n return precedence.subscriptionHandle === subscriptionHandle;\n });\n }\n\n if (elt) {\n if (elt === precedenceList[0] && !EJSON.equals(value, elt.value)) {\n // this subscription is changing the value of this field.\n changeCollector[key] = value;\n }\n elt.value = value;\n } else {\n // this subscription is newly caring about this field\n precedenceList.push({subscriptionHandle: subscriptionHandle, value: value});\n }\n\n }\n});\n\n/**\n * Represents a client's view of a single collection\n * @param {String} collectionName Name of the collection it represents\n * @param {Object.} sessionCallbacks The callbacks for added, changed, removed\n * @class SessionCollectionView\n */\nvar SessionCollectionView = function (collectionName, sessionCallbacks) {\n var self = this;\n self.collectionName = collectionName;\n self.documents = new Map();\n self.callbacks = sessionCallbacks;\n};\n\nDDPServer._SessionCollectionView = SessionCollectionView;\n\n\n_.extend(SessionCollectionView.prototype, {\n\n isEmpty: function () {\n var self = this;\n return self.documents.size === 0;\n },\n\n diff: function (previous) {\n var self = this;\n DiffSequence.diffMaps(previous.documents, self.documents, {\n both: _.bind(self.diffDocument, self),\n\n rightOnly: function (id, nowDV) {\n self.callbacks.added(self.collectionName, id, nowDV.getFields());\n },\n\n leftOnly: function (id, prevDV) {\n self.callbacks.removed(self.collectionName, id);\n }\n });\n },\n\n diffDocument: function (id, prevDV, nowDV) {\n var self = this;\n var fields = {};\n DiffSequence.diffObjects(prevDV.getFields(), nowDV.getFields(), {\n both: function (key, prev, now) {\n if (!EJSON.equals(prev, now))\n fields[key] = now;\n },\n rightOnly: function (key, now) {\n fields[key] = now;\n },\n leftOnly: function(key, prev) {\n fields[key] = undefined;\n }\n });\n self.callbacks.changed(self.collectionName, id, fields);\n },\n\n added: function (subscriptionHandle, id, fields) {\n var self = this;\n var docView = self.documents.get(id);\n var added = false;\n if (!docView) {\n added = true;\n docView = new SessionDocumentView();\n self.documents.set(id, docView);\n }\n docView.existsIn.add(subscriptionHandle);\n var changeCollector = {};\n _.each(fields, function (value, key) {\n docView.changeField(\n subscriptionHandle, key, value, changeCollector, true);\n });\n if (added)\n self.callbacks.added(self.collectionName, id, changeCollector);\n else\n self.callbacks.changed(self.collectionName, id, changeCollector);\n },\n\n changed: function (subscriptionHandle, id, changed) {\n var self = this;\n var changedResult = {};\n var docView = self.documents.get(id);\n if (!docView)\n throw new Error(\"Could not find element with id \" + id + \" to change\");\n _.each(changed, function (value, key) {\n if (value === undefined)\n docView.clearField(subscriptionHandle, key, changedResult);\n else\n docView.changeField(subscriptionHandle, key, value, changedResult);\n });\n self.callbacks.changed(self.collectionName, id, changedResult);\n },\n\n removed: function (subscriptionHandle, id) {\n var self = this;\n var docView = self.documents.get(id);\n if (!docView) {\n var err = new Error(\"Removed nonexistent document \" + id);\n throw err;\n }\n docView.existsIn.delete(subscriptionHandle);\n if (docView.existsIn.size === 0) {\n // it is gone from everyone\n self.callbacks.removed(self.collectionName, id);\n self.documents.delete(id);\n } else {\n var changed = {};\n // remove this subscription from every precedence list\n // and record the changes\n docView.dataByKey.forEach(function (precedenceList, key) {\n docView.clearField(subscriptionHandle, key, changed);\n });\n\n self.callbacks.changed(self.collectionName, id, changed);\n }\n }\n});\n\n/******************************************************************************/\n/* Session */\n/******************************************************************************/\n\nvar Session = function (server, version, socket, options) {\n var self = this;\n self.id = Random.id();\n\n self.server = server;\n self.version = version;\n\n self.initialized = false;\n self.socket = socket;\n\n // set to null when the session is destroyed. multiple places below\n // use this to determine if the session is alive or not.\n self.inQueue = new Meteor._DoubleEndedQueue();\n\n self.blocked = false;\n self.workerRunning = false;\n\n // Sub objects for active subscriptions\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n self.userId = null;\n\n self.collectionViews = new Map();\n\n // Set this to false to not send messages when collectionViews are\n // modified. This is done when rerunning subs in _setUserId and those messages\n // are calculated via a diff instead.\n self._isSending = true;\n\n // If this is true, don't start a newly-created universal publisher on this\n // session. The session will take care of starting it when appropriate.\n self._dontStartNewUniversalSubs = false;\n\n // when we are rerunning subscriptions, any ready messages\n // we want to buffer up for when we are done rerunning subscriptions\n self._pendingReady = [];\n\n // List of callbacks to call when this connection is closed.\n self._closeCallbacks = [];\n\n\n // XXX HACK: If a sockjs connection, save off the URL. This is\n // temporary and will go away in the near future.\n self._socketUrl = socket.url;\n\n // Allow tests to disable responding to pings.\n self._respondToPings = options.respondToPings;\n\n // This object is the public interface to the session. In the public\n // API, it is called the `connection` object. Internally we call it\n // a `connectionHandle` to avoid ambiguity.\n self.connectionHandle = {\n id: self.id,\n close: function () {\n self.close();\n },\n onClose: function (fn) {\n var cb = Meteor.bindEnvironment(fn, \"connection onClose callback\");\n if (self.inQueue) {\n self._closeCallbacks.push(cb);\n } else {\n // if we're already closed, call the callback.\n Meteor.defer(cb);\n }\n },\n clientAddress: self._clientAddress(),\n httpHeaders: self.socket.headers\n };\n\n self.send({ msg: 'connected', session: self.id });\n\n // On initial connect, spin up all the universal publishers.\n Fiber(function () {\n self.startUniversalSubs();\n }).run();\n\n if (version !== 'pre1' && options.heartbeatInterval !== 0) {\n // We no longer need the low level timeout because we have heartbeating.\n socket.setWebsocketTimeout(0);\n\n self.heartbeat = new DDPCommon.Heartbeat({\n heartbeatInterval: options.heartbeatInterval,\n heartbeatTimeout: options.heartbeatTimeout,\n onTimeout: function () {\n self.close();\n },\n sendPing: function () {\n self.send({msg: 'ping'});\n }\n });\n self.heartbeat.start();\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", 1);\n};\n\n_.extend(Session.prototype, {\n\n sendReady: function (subscriptionIds) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"ready\", subs: subscriptionIds});\n else {\n _.each(subscriptionIds, function (subscriptionId) {\n self._pendingReady.push(subscriptionId);\n });\n }\n },\n\n sendAdded: function (collectionName, id, fields) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"added\", collection: collectionName, id: id, fields: fields});\n },\n\n sendChanged: function (collectionName, id, fields) {\n var self = this;\n if (_.isEmpty(fields))\n return;\n\n if (self._isSending) {\n self.send({\n msg: \"changed\",\n collection: collectionName,\n id: id,\n fields: fields\n });\n }\n },\n\n sendRemoved: function (collectionName, id) {\n var self = this;\n if (self._isSending)\n self.send({msg: \"removed\", collection: collectionName, id: id});\n },\n\n getSendCallbacks: function () {\n var self = this;\n return {\n added: _.bind(self.sendAdded, self),\n changed: _.bind(self.sendChanged, self),\n removed: _.bind(self.sendRemoved, self)\n };\n },\n\n getCollectionView: function (collectionName) {\n var self = this;\n var ret = self.collectionViews.get(collectionName);\n if (!ret) {\n ret = new SessionCollectionView(collectionName,\n self.getSendCallbacks());\n self.collectionViews.set(collectionName, ret);\n }\n return ret;\n },\n\n added: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.added(subscriptionHandle, id, fields);\n },\n\n removed: function (subscriptionHandle, collectionName, id) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.removed(subscriptionHandle, id);\n if (view.isEmpty()) {\n self.collectionViews.delete(collectionName);\n }\n },\n\n changed: function (subscriptionHandle, collectionName, id, fields) {\n var self = this;\n var view = self.getCollectionView(collectionName);\n view.changed(subscriptionHandle, id, fields);\n },\n\n startUniversalSubs: function () {\n var self = this;\n // Make a shallow copy of the set of universal handlers and start them. If\n // additional universal publishers start while we're running them (due to\n // yielding), they will run separately as part of Server.publish.\n var handlers = _.clone(self.server.universal_publish_handlers);\n _.each(handlers, function (handler) {\n self._startSubscription(handler);\n });\n },\n\n // Destroy this session and unregister it at the server.\n close: function () {\n var self = this;\n\n // Destroy this session, even if it's not registered at the\n // server. Stop all processing and tear everything down. If a socket\n // was attached, close it.\n\n // Already destroyed.\n if (! self.inQueue)\n return;\n\n // Drop the merge box data immediately.\n self.inQueue = null;\n self.collectionViews = new Map();\n\n if (self.heartbeat) {\n self.heartbeat.stop();\n self.heartbeat = null;\n }\n\n if (self.socket) {\n self.socket.close();\n self.socket._meteorSession = null;\n }\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"sessions\", -1);\n\n Meteor.defer(function () {\n // stop callbacks can yield, so we defer this on close.\n // sub._isDeactivated() detects that we set inQueue to null and\n // treats it as semi-deactivated (it will ignore incoming callbacks, etc).\n self._deactivateAllSubscriptions();\n\n // Defer calling the close callbacks, so that the caller closing\n // the session isn't waiting for all the callbacks to complete.\n _.each(self._closeCallbacks, function (callback) {\n callback();\n });\n });\n\n // Unregister the session.\n self.server._removeSession(self);\n },\n\n // Send a message (doing nothing if no socket is connected right now.)\n // It should be a JSON object (it will be stringified.)\n send: function (msg) {\n var self = this;\n if (self.socket) {\n if (Meteor._printSentDDP)\n Meteor._debug(\"Sent DDP\", DDPCommon.stringifyDDP(msg));\n self.socket.send(DDPCommon.stringifyDDP(msg));\n }\n },\n\n // Send a connection error.\n sendError: function (reason, offendingMessage) {\n var self = this;\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n self.send(msg);\n },\n\n // Process 'msg' as an incoming message. (But as a guard against\n // race conditions during reconnection, ignore the message if\n // 'socket' is not the currently connected socket.)\n //\n // We run the messages from the client one at a time, in the order\n // given by the client. The message handler is passed an idempotent\n // function 'unblock' which it may call to allow other messages to\n // begin running in parallel in another fiber (for example, a method\n // that wants to yield.) Otherwise, it is automatically unblocked\n // when it returns.\n //\n // Actually, we don't have to 'totally order' the messages in this\n // way, but it's the easiest thing that's correct. (unsub needs to\n // be ordered against sub, methods need to be ordered against each\n // other.)\n processMessage: function (msg_in) {\n var self = this;\n if (!self.inQueue) // we have been destroyed.\n return;\n\n // Respond to ping and pong messages immediately without queuing.\n // If the negotiated DDP version is \"pre1\" which didn't support\n // pings, preserve the \"pre1\" behavior of responding with a \"bad\n // request\" for the unknown messages.\n //\n // Fibers are needed because heartbeat uses Meteor.setTimeout, which\n // needs a Fiber. We could actually use regular setTimeout and avoid\n // these new fibers, but it is easier to just make everything use\n // Meteor.setTimeout and not think too hard.\n //\n // Any message counts as receiving a pong, as it demonstrates that\n // the client is still alive.\n if (self.heartbeat) {\n Fiber(function () {\n self.heartbeat.messageReceived();\n }).run();\n }\n\n if (self.version !== 'pre1' && msg_in.msg === 'ping') {\n if (self._respondToPings)\n self.send({msg: \"pong\", id: msg_in.id});\n return;\n }\n if (self.version !== 'pre1' && msg_in.msg === 'pong') {\n // Since everything is a pong, nothing to do\n return;\n }\n\n self.inQueue.push(msg_in);\n if (self.workerRunning)\n return;\n self.workerRunning = true;\n\n var processNext = function () {\n var msg = self.inQueue && self.inQueue.shift();\n if (!msg) {\n self.workerRunning = false;\n return;\n }\n\n Fiber(function () {\n var blocked = true;\n\n var unblock = function () {\n if (!blocked)\n return; // idempotent\n blocked = false;\n processNext();\n };\n\n self.server.onMessageHook.each(function (callback) {\n callback(msg, self);\n return true;\n });\n\n if (_.has(self.protocol_handlers, msg.msg))\n self.protocol_handlers[msg.msg].call(self, msg, unblock);\n else\n self.sendError('Bad request', msg);\n unblock(); // in case the handler didn't already do it\n }).run();\n };\n\n processNext();\n },\n\n protocol_handlers: {\n sub: function (msg) {\n var self = this;\n\n // reject malformed messages\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.name) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array))) {\n self.sendError(\"Malformed subscription\", msg);\n return;\n }\n\n if (!self.server.publish_handlers[msg.name]) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(404, `Subscription '${msg.name}' not found`)});\n return;\n }\n\n if (self._namedSubs.has(msg.id))\n // subs are idempotent, or rather, they are ignored if a sub\n // with that id already exists. this is important during\n // reconnect.\n return;\n\n // XXX It'd be much better if we had generic hooks where any package can\n // hook into subscription handling, but in the mean while we special case\n // ddp-rate-limiter package. This is also done for weak requirements to\n // add the ddp-rate-limiter package in case we don't have Accounts. A\n // user trying to use the ddp-rate-limiter must explicitly require it.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"subscription\",\n name: msg.name,\n connectionId: self.id\n };\n\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput);\n if (!rateLimitResult.allowed) {\n self.send({\n msg: 'nosub', id: msg.id,\n error: new Meteor.Error(\n 'too-many-requests',\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset})\n });\n return;\n }\n }\n\n var handler = self.server.publish_handlers[msg.name];\n\n self._startSubscription(handler, msg.id, msg.params, msg.name);\n\n },\n\n unsub: function (msg) {\n var self = this;\n\n self._stopSubscription(msg.id);\n },\n\n method: function (msg, unblock) {\n var self = this;\n\n // reject malformed messages\n // For now, we silently ignore unknown attributes,\n // for forwards compatibility.\n if (typeof (msg.id) !== \"string\" ||\n typeof (msg.method) !== \"string\" ||\n (('params' in msg) && !(msg.params instanceof Array)) ||\n (('randomSeed' in msg) && (typeof msg.randomSeed !== \"string\"))) {\n self.sendError(\"Malformed method invocation\", msg);\n return;\n }\n\n var randomSeed = msg.randomSeed || null;\n\n // set up to mark the method as satisfied once all observers\n // (and subscriptions) have reacted to any writes that were\n // done.\n var fence = new DDPServer._WriteFence;\n fence.onAllCommitted(function () {\n // Retire the fence so that future writes are allowed.\n // This means that callbacks like timers are free to use\n // the fence, and if they fire before it's armed (for\n // example, because the method waits for them) their\n // writes will be included in the fence.\n fence.retire();\n self.send({\n msg: 'updated', methods: [msg.id]});\n });\n\n // find the handler\n var handler = self.server.method_handlers[msg.method];\n if (!handler) {\n self.send({\n msg: 'result', id: msg.id,\n error: new Meteor.Error(404, `Method '${msg.method}' not found`)});\n fence.arm();\n return;\n }\n\n var setUserId = function(userId) {\n self._setUserId(userId);\n };\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId: self.userId,\n setUserId: setUserId,\n unblock: unblock,\n connection: self.connectionHandle,\n randomSeed: randomSeed\n });\n\n const promise = new Promise((resolve, reject) => {\n // XXX It'd be better if we could hook into method handlers better but\n // for now, we need to check if the ddp-rate-limiter exists since we\n // have a weak requirement for the ddp-rate-limiter package to be added\n // to our application.\n if (Package['ddp-rate-limiter']) {\n var DDPRateLimiter = Package['ddp-rate-limiter'].DDPRateLimiter;\n var rateLimiterInput = {\n userId: self.userId,\n clientAddress: self.connectionHandle.clientAddress,\n type: \"method\",\n name: msg.method,\n connectionId: self.id\n };\n DDPRateLimiter._increment(rateLimiterInput);\n var rateLimitResult = DDPRateLimiter._check(rateLimiterInput)\n if (!rateLimitResult.allowed) {\n reject(new Meteor.Error(\n \"too-many-requests\",\n DDPRateLimiter.getErrorMessage(rateLimitResult),\n {timeToReset: rateLimitResult.timeToReset}\n ));\n return;\n }\n }\n\n resolve(DDPServer._CurrentWriteFence.withValue(\n fence,\n () => DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, msg.params,\n \"call to '\" + msg.method + \"'\"\n )\n )\n ));\n });\n\n function finish() {\n fence.arm();\n unblock();\n }\n\n const payload = {\n msg: \"result\",\n id: msg.id\n };\n\n promise.then((result) => {\n finish();\n if (result !== undefined) {\n payload.result = result;\n }\n self.send(payload);\n }, (exception) => {\n finish();\n payload.error = wrapInternalException(\n exception,\n `while invoking method '${msg.method}'`\n );\n self.send(payload);\n });\n }\n },\n\n _eachSub: function (f) {\n var self = this;\n self._namedSubs.forEach(f);\n self._universalSubs.forEach(f);\n },\n\n _diffCollectionViews: function (beforeCVs) {\n var self = this;\n DiffSequence.diffMaps(beforeCVs, self.collectionViews, {\n both: function (collectionName, leftValue, rightValue) {\n rightValue.diff(leftValue);\n },\n rightOnly: function (collectionName, rightValue) {\n rightValue.documents.forEach(function (docView, id) {\n self.sendAdded(collectionName, id, docView.getFields());\n });\n },\n leftOnly: function (collectionName, leftValue) {\n leftValue.documents.forEach(function (doc, id) {\n self.sendRemoved(collectionName, id);\n });\n }\n });\n },\n\n // Sets the current user id in all appropriate contexts and reruns\n // all subscriptions\n _setUserId: function(userId) {\n var self = this;\n\n if (userId !== null && typeof userId !== \"string\")\n throw new Error(\"setUserId must be called on string or null, not \" +\n typeof userId);\n\n // Prevent newly-created universal subscriptions from being added to our\n // session; they will be found below when we call startUniversalSubs.\n //\n // (We don't have to worry about named subscriptions, because we only add\n // them when we process a 'sub' message. We are currently processing a\n // 'method' message, and the method did not unblock, because it is illegal\n // to call setUserId after unblock. Thus we cannot be concurrently adding a\n // new named subscription.)\n self._dontStartNewUniversalSubs = true;\n\n // Prevent current subs from updating our collectionViews and call their\n // stop callbacks. This may yield.\n self._eachSub(function (sub) {\n sub._deactivate();\n });\n\n // All subs should now be deactivated. Stop sending messages to the client,\n // save the state of the published collections, reset to an empty view, and\n // update the userId.\n self._isSending = false;\n var beforeCVs = self.collectionViews;\n self.collectionViews = new Map();\n self.userId = userId;\n\n // _setUserId is normally called from a Meteor method with\n // DDP._CurrentMethodInvocation set. But DDP._CurrentMethodInvocation is not\n // expected to be set inside a publish function, so we temporary unset it.\n // Inside a publish function DDP._CurrentPublicationInvocation is set.\n DDP._CurrentMethodInvocation.withValue(undefined, function () {\n // Save the old named subs, and reset to having no subscriptions.\n var oldNamedSubs = self._namedSubs;\n self._namedSubs = new Map();\n self._universalSubs = [];\n\n oldNamedSubs.forEach(function (sub, subscriptionId) {\n var newSub = sub._recreate();\n self._namedSubs.set(subscriptionId, newSub);\n // nb: if the handler throws or calls this.error(), it will in fact\n // immediately send its 'nosub'. This is OK, though.\n newSub._runHandler();\n });\n\n // Allow newly-created universal subs to be started on our connection in\n // parallel with the ones we're spinning up here, and spin up universal\n // subs.\n self._dontStartNewUniversalSubs = false;\n self.startUniversalSubs();\n });\n\n // Start sending messages again, beginning with the diff from the previous\n // state of the world to the current state. No yields are allowed during\n // this diff, so that other changes cannot interleave.\n Meteor._noYieldsAllowed(function () {\n self._isSending = true;\n self._diffCollectionViews(beforeCVs);\n if (!_.isEmpty(self._pendingReady)) {\n self.sendReady(self._pendingReady);\n self._pendingReady = [];\n }\n });\n },\n\n _startSubscription: function (handler, subId, params, name) {\n var self = this;\n\n var sub = new Subscription(\n self, handler, subId, params, name);\n if (subId)\n self._namedSubs.set(subId, sub);\n else\n self._universalSubs.push(sub);\n\n sub._runHandler();\n },\n\n // tear down specified subscription\n _stopSubscription: function (subId, error) {\n var self = this;\n\n var subName = null;\n if (subId) {\n var maybeSub = self._namedSubs.get(subId);\n if (maybeSub) {\n subName = maybeSub._name;\n maybeSub._removeAllDocuments();\n maybeSub._deactivate();\n self._namedSubs.delete(subId);\n }\n }\n\n var response = {msg: 'nosub', id: subId};\n\n if (error) {\n response.error = wrapInternalException(\n error,\n subName ? (\"from sub \" + subName + \" id \" + subId)\n : (\"from sub id \" + subId));\n }\n\n self.send(response);\n },\n\n // tear down all subscriptions. Note that this does NOT send removed or nosub\n // messages, since we assume the client is gone.\n _deactivateAllSubscriptions: function () {\n var self = this;\n\n self._namedSubs.forEach(function (sub, id) {\n sub._deactivate();\n });\n self._namedSubs = new Map();\n\n self._universalSubs.forEach(function (sub) {\n sub._deactivate();\n });\n self._universalSubs = [];\n },\n\n // Determine the remote client's IP address, based on the\n // HTTP_FORWARDED_COUNT environment variable representing how many\n // proxies the server is behind.\n _clientAddress: function () {\n var self = this;\n\n // For the reported client address for a connection to be correct,\n // the developer must set the HTTP_FORWARDED_COUNT environment\n // variable to an integer representing the number of hops they\n // expect in the `x-forwarded-for` header. E.g., set to \"1\" if the\n // server is behind one proxy.\n //\n // This could be computed once at startup instead of every time.\n var httpForwardedCount = parseInt(process.env['HTTP_FORWARDED_COUNT']) || 0;\n\n if (httpForwardedCount === 0)\n return self.socket.remoteAddress;\n\n var forwardedFor = self.socket.headers[\"x-forwarded-for\"];\n if (! _.isString(forwardedFor))\n return null;\n forwardedFor = forwardedFor.trim().split(/\\s*,\\s*/);\n\n // Typically the first value in the `x-forwarded-for` header is\n // the original IP address of the client connecting to the first\n // proxy. However, the end user can easily spoof the header, in\n // which case the first value(s) will be the fake IP address from\n // the user pretending to be a proxy reporting the original IP\n // address value. By counting HTTP_FORWARDED_COUNT back from the\n // end of the list, we ensure that we get the IP address being\n // reported by *our* first proxy.\n\n if (httpForwardedCount < 0 || httpForwardedCount > forwardedFor.length)\n return null;\n\n return forwardedFor[forwardedFor.length - httpForwardedCount];\n }\n});\n\n/******************************************************************************/\n/* Subscription */\n/******************************************************************************/\n\n// ctor for a sub handle: the input to each publish function\n\n// Instance name is this because it's usually referred to as this inside a\n// publish\n/**\n * @summary The server's side of a subscription\n * @class Subscription\n * @instanceName this\n * @showInstanceName true\n */\nvar Subscription = function (\n session, handler, subscriptionId, params, name) {\n var self = this;\n self._session = session; // type is Session\n\n /**\n * @summary Access inside the publish function. The incoming [connection](#meteor_onconnection) for this subscription.\n * @locus Server\n * @name connection\n * @memberOf Subscription\n * @instance\n */\n self.connection = session.connectionHandle; // public API object\n\n self._handler = handler;\n\n // my subscription ID (generated by client, undefined for universal subs).\n self._subscriptionId = subscriptionId;\n // undefined for universal subs\n self._name = name;\n\n self._params = params || [];\n\n // Only named subscriptions have IDs, but we need some sort of string\n // internally to keep track of all subscriptions inside\n // SessionDocumentViews. We use this subscriptionHandle for that.\n if (self._subscriptionId) {\n self._subscriptionHandle = 'N' + self._subscriptionId;\n } else {\n self._subscriptionHandle = 'U' + Random.id();\n }\n\n // has _deactivate been called?\n self._deactivated = false;\n\n // stop callbacks to g/c this sub. called w/ zero arguments.\n self._stopCallbacks = [];\n\n // the set of (collection, documentid) that this subscription has\n // an opinion about\n self._documents = new Map();\n\n // remember if we are ready.\n self._ready = false;\n\n // Part of the public API: the user of this sub.\n\n /**\n * @summary Access inside the publish function. The id of the logged-in user, or `null` if no user is logged in.\n * @locus Server\n * @memberOf Subscription\n * @name userId\n * @instance\n */\n self.userId = session.userId;\n\n // For now, the id filter is going to default to\n // the to/from DDP methods on MongoID, to\n // specifically deal with mongo/minimongo ObjectIds.\n\n // Later, you will be able to make this be \"raw\"\n // if you want to publish a collection that you know\n // just has strings for keys and no funny business, to\n // a ddp consumer that isn't minimongo\n\n self._idFilter = {\n idStringify: MongoID.idStringify,\n idParse: MongoID.idParse\n };\n\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", 1);\n};\n\n_.extend(Subscription.prototype, {\n _runHandler: function () {\n // XXX should we unblock() here? Either before running the publish\n // function, or before running _publishCursor.\n //\n // Right now, each publish function blocks all future publishes and\n // methods waiting on data from Mongo (or whatever else the function\n // blocks on). This probably slows page load in common cases.\n\n var self = this;\n try {\n var res = DDP._CurrentPublicationInvocation.withValue(\n self,\n () => maybeAuditArgumentChecks(\n self._handler, self, EJSON.clone(self._params),\n // It's OK that this would look weird for universal subscriptions,\n // because they have no arguments so there can never be an\n // audit-argument-checks failure.\n \"publisher '\" + self._name + \"'\"\n )\n );\n } catch (e) {\n self.error(e);\n return;\n }\n\n // Did the handler call this.error or this.stop?\n if (self._isDeactivated())\n return;\n\n self._publishHandlerResult(res);\n },\n\n _publishHandlerResult: function (res) {\n // SPECIAL CASE: Instead of writing their own callbacks that invoke\n // this.added/changed/ready/etc, the user can just return a collection\n // cursor or array of cursors from the publish function; we call their\n // _publishCursor method which starts observing the cursor and publishes the\n // results. Note that _publishCursor does NOT call ready().\n //\n // XXX This uses an undocumented interface which only the Mongo cursor\n // interface publishes. Should we make this interface public and encourage\n // users to implement it themselves? Arguably, it's unnecessary; users can\n // already write their own functions like\n // var publishMyReactiveThingy = function (name, handler) {\n // Meteor.publish(name, function () {\n // var reactiveThingy = handler();\n // reactiveThingy.publishMe();\n // });\n // };\n\n var self = this;\n var isCursor = function (c) {\n return c && c._publishCursor;\n };\n if (isCursor(res)) {\n try {\n res._publishCursor(self);\n } catch (e) {\n self.error(e);\n return;\n }\n // _publishCursor only returns after the initial added callbacks have run.\n // mark subscription as ready.\n self.ready();\n } else if (_.isArray(res)) {\n // check all the elements are cursors\n if (! _.all(res, isCursor)) {\n self.error(new Error(\"Publish function returned an array of non-Cursors\"));\n return;\n }\n // find duplicate collection names\n // XXX we should support overlapping cursors, but that would require the\n // merge box to allow overlap within a subscription\n var collectionNames = {};\n for (var i = 0; i < res.length; ++i) {\n var collectionName = res[i]._getCollectionName();\n if (_.has(collectionNames, collectionName)) {\n self.error(new Error(\n \"Publish function returned multiple cursors for collection \" +\n collectionName));\n return;\n }\n collectionNames[collectionName] = true;\n };\n\n try {\n _.each(res, function (cur) {\n cur._publishCursor(self);\n });\n } catch (e) {\n self.error(e);\n return;\n }\n self.ready();\n } else if (res) {\n // truthy values other than cursors or arrays are probably a\n // user mistake (possible returning a Mongo document via, say,\n // `coll.findOne()`).\n self.error(new Error(\"Publish function can only return a Cursor or \"\n + \"an array of Cursors\"));\n }\n },\n\n // This calls all stop callbacks and prevents the handler from updating any\n // SessionCollectionViews further. It's used when the user unsubscribes or\n // disconnects, as well as during setUserId re-runs. It does *NOT* send\n // removed messages for the published objects; if that is necessary, call\n // _removeAllDocuments first.\n _deactivate: function() {\n var self = this;\n if (self._deactivated)\n return;\n self._deactivated = true;\n self._callStopCallbacks();\n Package['facts-base'] && Package['facts-base'].Facts.incrementServerFact(\n \"livedata\", \"subscriptions\", -1);\n },\n\n _callStopCallbacks: function () {\n var self = this;\n // tell listeners, so they can clean up\n var callbacks = self._stopCallbacks;\n self._stopCallbacks = [];\n _.each(callbacks, function (callback) {\n callback();\n });\n },\n\n // Send remove messages for every document.\n _removeAllDocuments: function () {\n var self = this;\n Meteor._noYieldsAllowed(function () {\n self._documents.forEach(function (collectionDocs, collectionName) {\n collectionDocs.forEach(function (strId) {\n self.removed(collectionName, self._idFilter.idParse(strId));\n });\n });\n });\n },\n\n // Returns a new Subscription for the same session with the same\n // initial creation parameters. This isn't a clone: it doesn't have\n // the same _documents cache, stopped state or callbacks; may have a\n // different _subscriptionHandle, and gets its userId from the\n // session, not from this object.\n _recreate: function () {\n var self = this;\n return new Subscription(\n self._session, self._handler, self._subscriptionId, self._params,\n self._name);\n },\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription, triggering a call on the client to the `onStop` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any. If `error` is not a [`Meteor.Error`](#meteor_error), it will be [sanitized](#meteor_error).\n * @locus Server\n * @param {Error} error The error to pass to the client.\n * @instance\n * @memberOf Subscription\n */\n error: function (error) {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId, error);\n },\n\n // Note that while our DDP client will notice that you've called stop() on the\n // server (and clean up its _subscriptions table) we don't actually provide a\n // mechanism for an app to notice this (the subscribe onError callback only\n // triggers if there is an error).\n\n /**\n * @summary Call inside the publish function. Stops this client's subscription and invokes the client's `onStop` callback with no error.\n * @locus Server\n * @instance\n * @memberOf Subscription\n */\n stop: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n self._session._stopSubscription(self._subscriptionId);\n },\n\n /**\n * @summary Call inside the publish function. Registers a callback function to run when the subscription is stopped.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {Function} func The callback function\n */\n onStop: function (callback) {\n var self = this;\n callback = Meteor.bindEnvironment(callback, 'onStop callback', self);\n if (self._isDeactivated())\n callback();\n else\n self._stopCallbacks.push(callback);\n },\n\n // This returns true if the sub has been deactivated, *OR* if the session was\n // destroyed but the deferred call to _deactivateAllSubscriptions hasn't\n // happened yet.\n _isDeactivated: function () {\n var self = this;\n return self._deactivated || self._session.inQueue === null;\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been added to the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the new document.\n * @param {String} id The new document's ID.\n * @param {Object} fields The fields in the new document. If `_id` is present it is ignored.\n */\n added: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n let ids = self._documents.get(collectionName);\n if (ids == null) {\n ids = new Set();\n self._documents.set(collectionName, ids);\n }\n ids.add(id);\n self._session.added(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document in the record set has been modified.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that contains the changed document.\n * @param {String} id The changed document's ID.\n * @param {Object} fields The fields in the document that have changed, together with their new values. If a field is not present in `fields` it was left unchanged; if it is present in `fields` and has a value of `undefined` it was removed from the document. If `_id` is present it is ignored.\n */\n changed: function (collectionName, id, fields) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n self._session.changed(self._subscriptionHandle, collectionName, id, fields);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that a document has been removed from the record set.\n * @locus Server\n * @memberOf Subscription\n * @instance\n * @param {String} collection The name of the collection that the document has been removed from.\n * @param {String} id The ID of the document that has been removed.\n */\n removed: function (collectionName, id) {\n var self = this;\n if (self._isDeactivated())\n return;\n id = self._idFilter.idStringify(id);\n // We don't bother to delete sets of things in a collection if the\n // collection is empty. It could break _removeAllDocuments.\n self._documents.get(collectionName).delete(id);\n self._session.removed(self._subscriptionHandle, collectionName, id);\n },\n\n /**\n * @summary Call inside the publish function. Informs the subscriber that an initial, complete snapshot of the record set has been sent. This will trigger a call on the client to the `onReady` callback passed to [`Meteor.subscribe`](#meteor_subscribe), if any.\n * @locus Server\n * @memberOf Subscription\n * @instance\n */\n ready: function () {\n var self = this;\n if (self._isDeactivated())\n return;\n if (!self._subscriptionId)\n return; // unnecessary but ignored for universal sub\n if (!self._ready) {\n self._session.sendReady([self._subscriptionId]);\n self._ready = true;\n }\n }\n});\n\n/******************************************************************************/\n/* Server */\n/******************************************************************************/\n\nServer = function (options) {\n var self = this;\n\n // The default heartbeat interval is 30 seconds on the server and 35\n // seconds on the client. Since the client doesn't need to send a\n // ping as long as it is receiving pings, this means that pings\n // normally go from the server to the client.\n //\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n self.options = _.defaults(options || {}, {\n heartbeatInterval: 15000,\n heartbeatTimeout: 15000,\n // For testing, allow responding to pings to be disabled.\n respondToPings: true\n });\n\n // Map of callbacks to call when a new connection comes in to the\n // server and completes DDP version negotiation. Use an object instead\n // of an array so we can safely remove one from the list while\n // iterating over it.\n self.onConnectionHook = new Hook({\n debugPrintExceptions: \"onConnection callback\"\n });\n\n // Map of callbacks to call when a new message comes in.\n self.onMessageHook = new Hook({\n debugPrintExceptions: \"onMessage callback\"\n });\n\n self.publish_handlers = {};\n self.universal_publish_handlers = [];\n\n self.method_handlers = {};\n\n self.sessions = new Map(); // map from id to session\n\n self.stream_server = new StreamServer;\n\n self.stream_server.register(function (socket) {\n // socket implements the SockJSConnection interface\n socket._meteorSession = null;\n\n var sendError = function (reason, offendingMessage) {\n var msg = {msg: 'error', reason: reason};\n if (offendingMessage)\n msg.offendingMessage = offendingMessage;\n socket.send(DDPCommon.stringifyDDP(msg));\n };\n\n socket.on('data', function (raw_msg) {\n if (Meteor._printReceivedDDP) {\n Meteor._debug(\"Received DDP\", raw_msg);\n }\n try {\n try {\n var msg = DDPCommon.parseDDP(raw_msg);\n } catch (err) {\n sendError('Parse error');\n return;\n }\n if (msg === null || !msg.msg) {\n sendError('Bad request', msg);\n return;\n }\n\n if (msg.msg === 'connect') {\n if (socket._meteorSession) {\n sendError(\"Already connected\", msg);\n return;\n }\n Fiber(function () {\n self._handleConnect(socket, msg);\n }).run();\n return;\n }\n\n if (!socket._meteorSession) {\n sendError('Must connect first', msg);\n return;\n }\n socket._meteorSession.processMessage(msg);\n } catch (e) {\n // XXX print stack nicely\n Meteor._debug(\"Internal exception while processing message\", msg, e);\n }\n });\n\n socket.on('close', function () {\n if (socket._meteorSession) {\n Fiber(function () {\n socket._meteorSession.close();\n }).run();\n }\n });\n });\n};\n\n_.extend(Server.prototype, {\n\n /**\n * @summary Register a callback to be called when a new DDP connection is made to the server.\n * @locus Server\n * @param {function} callback The function to call when a new DDP connection is established.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onConnection: function (fn) {\n var self = this;\n return self.onConnectionHook.register(fn);\n },\n\n /**\n * @summary Register a callback to be called when a new DDP message is received.\n * @locus Server\n * @param {function} callback The function to call when a new DDP message is received.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n onMessage: function (fn) {\n var self = this;\n return self.onMessageHook.register(fn);\n },\n\n _handleConnect: function (socket, msg) {\n var self = this;\n\n // The connect message must specify a version and an array of supported\n // versions, and it must claim to support what it is proposing.\n if (!(typeof (msg.version) === 'string' &&\n _.isArray(msg.support) &&\n _.all(msg.support, _.isString) &&\n _.contains(msg.support, msg.version))) {\n socket.send(DDPCommon.stringifyDDP({msg: 'failed',\n version: DDPCommon.SUPPORTED_DDP_VERSIONS[0]}));\n socket.close();\n return;\n }\n\n // In the future, handle session resumption: something like:\n // socket._meteorSession = self.sessions[msg.session]\n var version = calculateVersion(msg.support, DDPCommon.SUPPORTED_DDP_VERSIONS);\n\n if (msg.version !== version) {\n // The best version to use (according to the client's stated preferences)\n // is not the one the client is trying to use. Inform them about the best\n // version to use.\n socket.send(DDPCommon.stringifyDDP({msg: 'failed', version: version}));\n socket.close();\n return;\n }\n\n // Yay, version matches! Create a new session.\n // Note: Troposphere depends on the ability to mutate\n // Meteor.server.options.heartbeatTimeout! This is a hack, but it's life.\n socket._meteorSession = new Session(self, version, socket, self.options);\n self.sessions.set(socket._meteorSession.id, socket._meteorSession);\n self.onConnectionHook.each(function (callback) {\n if (socket._meteorSession)\n callback(socket._meteorSession.connectionHandle);\n return true;\n });\n },\n /**\n * Register a publish handler function.\n *\n * @param name {String} identifier for query\n * @param handler {Function} publish handler\n * @param options {Object}\n *\n * Server will call handler function on each new subscription,\n * either when receiving DDP sub message for a named subscription, or on\n * DDP connect for a universal subscription.\n *\n * If name is null, this will be a subscription that is\n * automatically established and permanently on for all connected\n * client, instead of a subscription that can be turned on and off\n * with subscribe().\n *\n * options to contain:\n * - (mostly internal) is_auto: true if generated automatically\n * from an autopublish hook. this is for cosmetic purposes only\n * (it lets us determine whether to print a warning suggesting\n * that you turn off autopublish.)\n */\n\n /**\n * @summary Publish a record set.\n * @memberOf Meteor\n * @importFromPackage meteor\n * @locus Server\n * @param {String|Object} name If String, name of the record set. If Object, publications Dictionary of publish functions by name. If `null`, the set has no name, and the record set is automatically sent to all connected clients.\n * @param {Function} func Function called on the server each time a client subscribes. Inside the function, `this` is the publish handler object, described below. If the client passed arguments to `subscribe`, the function is called with the same arguments.\n */\n publish: function (name, handler, options) {\n var self = this;\n\n if (! _.isObject(name)) {\n options = options || {};\n\n if (name && name in self.publish_handlers) {\n Meteor._debug(\"Ignoring duplicate publish named '\" + name + \"'\");\n return;\n }\n\n if (Package.autopublish && !options.is_auto) {\n // They have autopublish on, yet they're trying to manually\n // picking stuff to publish. They probably should turn off\n // autopublish. (This check isn't perfect -- if you create a\n // publish before you turn on autopublish, it won't catch\n // it. But this will definitely handle the simple case where\n // you've added the autopublish package to your app, and are\n // calling publish from your app code.)\n if (!self.warned_about_autopublish) {\n self.warned_about_autopublish = true;\n Meteor._debug(\n \"** You've set up some data subscriptions with Meteor.publish(), but\\n\" +\n \"** you still have autopublish turned on. Because autopublish is still\\n\" +\n \"** on, your Meteor.publish() calls won't have much effect. All data\\n\" +\n \"** will still be sent to all clients.\\n\" +\n \"**\\n\" +\n \"** Turn off autopublish by removing the autopublish package:\\n\" +\n \"**\\n\" +\n \"** $ meteor remove autopublish\\n\" +\n \"**\\n\" +\n \"** .. and make sure you have Meteor.publish() and Meteor.subscribe() calls\\n\" +\n \"** for each collection that you want clients to see.\\n\");\n }\n }\n\n if (name)\n self.publish_handlers[name] = handler;\n else {\n self.universal_publish_handlers.push(handler);\n // Spin up the new publisher on any existing session too. Run each\n // session's subscription in a new Fiber, so that there's no change for\n // self.sessions to change while we're running this loop.\n self.sessions.forEach(function (session) {\n if (!session._dontStartNewUniversalSubs) {\n Fiber(function() {\n session._startSubscription(handler);\n }).run();\n }\n });\n }\n }\n else{\n _.each(name, function(value, key) {\n self.publish(key, value, {});\n });\n }\n },\n\n _removeSession: function (session) {\n var self = this;\n self.sessions.delete(session.id);\n },\n\n /**\n * @summary Defines functions that can be invoked over the network by clients.\n * @locus Anywhere\n * @param {Object} methods Dictionary whose keys are method names and values are functions.\n * @memberOf Meteor\n * @importFromPackage meteor\n */\n methods: function (methods) {\n var self = this;\n _.each(methods, function (func, name) {\n if (typeof func !== 'function')\n throw new Error(\"Method '\" + name + \"' must be a function\");\n if (self.method_handlers[name])\n throw new Error(\"A method named '\" + name + \"' is already defined\");\n self.method_handlers[name] = func;\n });\n },\n\n call: function (name, ...args) {\n if (args.length && typeof args[args.length - 1] === \"function\") {\n // If it's a function, the last argument is the result callback, not\n // a parameter to the remote method.\n var callback = args.pop();\n }\n\n return this.apply(name, args, callback);\n },\n\n // A version of the call method that always returns a Promise.\n callAsync: function (name, ...args) {\n return this.applyAsync(name, args);\n },\n\n apply: function (name, args, options, callback) {\n // We were passed 3 arguments. They may be either (name, args, options)\n // or (name, args, callback)\n if (! callback && typeof options === 'function') {\n callback = options;\n options = {};\n } else {\n options = options || {};\n }\n\n const promise = this.applyAsync(name, args, options);\n\n // Return the result in whichever way the caller asked for it. Note that we\n // do NOT block on the write fence in an analogous way to how the client\n // blocks on the relevant data being visible, so you are NOT guaranteed that\n // cursor observe callbacks have fired when your callback is invoked. (We\n // can change this if there's a real use case.)\n if (callback) {\n promise.then(\n result => callback(undefined, result),\n exception => callback(exception)\n );\n } else {\n return promise.await();\n }\n },\n\n // @param options {Optional Object}\n applyAsync: function (name, args, options) {\n // Run the handler\n var handler = this.method_handlers[name];\n if (! handler) {\n return Promise.reject(\n new Meteor.Error(404, `Method '${name}' not found`)\n );\n }\n\n // If this is a method call from within another method or publish function,\n // get the user state from the outer method or publish function, otherwise\n // don't allow setUserId to be called\n var userId = null;\n var setUserId = function() {\n throw new Error(\"Can't call setUserId on a server initiated method call\");\n };\n var connection = null;\n var currentMethodInvocation = DDP._CurrentMethodInvocation.get();\n var currentPublicationInvocation = DDP._CurrentPublicationInvocation.get();\n var randomSeed = null;\n if (currentMethodInvocation) {\n userId = currentMethodInvocation.userId;\n setUserId = function(userId) {\n currentMethodInvocation.setUserId(userId);\n };\n connection = currentMethodInvocation.connection;\n randomSeed = DDPCommon.makeRpcSeed(currentMethodInvocation, name);\n } else if (currentPublicationInvocation) {\n userId = currentPublicationInvocation.userId;\n setUserId = function(userId) {\n currentPublicationInvocation._session._setUserId(userId);\n };\n connection = currentPublicationInvocation.connection;\n }\n\n var invocation = new DDPCommon.MethodInvocation({\n isSimulation: false,\n userId,\n setUserId,\n connection,\n randomSeed\n });\n\n return new Promise(resolve => resolve(\n DDP._CurrentMethodInvocation.withValue(\n invocation,\n () => maybeAuditArgumentChecks(\n handler, invocation, EJSON.clone(args),\n \"internal call to '\" + name + \"'\"\n )\n )\n )).then(EJSON.clone);\n },\n\n _urlForSession: function (sessionId) {\n var self = this;\n var session = self.sessions.get(sessionId);\n if (session)\n return session._socketUrl;\n else\n return null;\n }\n});\n\nvar calculateVersion = function (clientSupportedVersions,\n serverSupportedVersions) {\n var correctVersion = _.find(clientSupportedVersions, function (version) {\n return _.contains(serverSupportedVersions, version);\n });\n if (!correctVersion) {\n correctVersion = serverSupportedVersions[0];\n }\n return correctVersion;\n};\n\nDDPServer._calculateVersion = calculateVersion;\n\n\n// \"blind\" exceptions other than those that were deliberately thrown to signal\n// errors to the client\nvar wrapInternalException = function (exception, context) {\n if (!exception) return exception;\n\n // To allow packages to throw errors intended for the client but not have to\n // depend on the Meteor.Error class, `isClientSafe` can be set to true on any\n // error before it is thrown.\n if (exception.isClientSafe) {\n if (!(exception instanceof Meteor.Error)) {\n const originalMessage = exception.message;\n exception = new Meteor.Error(exception.error, exception.reason, exception.details);\n exception.message = originalMessage;\n }\n return exception;\n }\n\n // Tests can set the '_expectedByTest' flag on an exception so it won't go to\n // the server log.\n if (!exception._expectedByTest) {\n Meteor._debug(\"Exception \" + context, exception.stack);\n if (exception.sanitizedError) {\n Meteor._debug(\"Sanitized and reported to the client as:\", exception.sanitizedError);\n Meteor._debug();\n }\n }\n\n // Did the error contain more details that could have been useful if caught in\n // server code (or if thrown from non-client-originated code), but also\n // provided a \"sanitized\" version with more context than 500 Internal server\n // error? Use that.\n if (exception.sanitizedError) {\n if (exception.sanitizedError.isClientSafe)\n return exception.sanitizedError;\n Meteor._debug(\"Exception \" + context + \" provides a sanitizedError that \" +\n \"does not have isClientSafe property set; ignoring\");\n }\n\n return new Meteor.Error(500, \"Internal server error\");\n};\n\n\n// Audit argument checks, if the audit-argument-checks package exists (it is a\n// weak dependency of this package).\nvar maybeAuditArgumentChecks = function (f, context, args, description) {\n args = args || [];\n if (Package['audit-argument-checks']) {\n return Match._failIfArgumentsAreNotAllChecked(\n f, context, args, description);\n }\n return f.apply(context, args);\n};\n","var Future = Npm.require('fibers/future');\n\n// A write fence collects a group of writes, and provides a callback\n// when all of the writes are fully committed and propagated (all\n// observers have been notified of the write and acknowledged it.)\n//\nDDPServer._WriteFence = function () {\n var self = this;\n\n self.armed = false;\n self.fired = false;\n self.retired = false;\n self.outstanding_writes = 0;\n self.before_fire_callbacks = [];\n self.completion_callbacks = [];\n};\n\n// The current write fence. When there is a current write fence, code\n// that writes to databases should register their writes with it using\n// beginWrite().\n//\nDDPServer._CurrentWriteFence = new Meteor.EnvironmentVariable;\n\n_.extend(DDPServer._WriteFence.prototype, {\n // Start tracking a write, and return an object to represent it. The\n // object has a single method, committed(). This method should be\n // called when the write is fully committed and propagated. You can\n // continue to add writes to the WriteFence up until it is triggered\n // (calls its callbacks because all writes have committed.)\n beginWrite: function () {\n var self = this;\n\n if (self.retired)\n return { committed: function () {} };\n\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to add writes\");\n\n self.outstanding_writes++;\n var committed = false;\n return {\n committed: function () {\n if (committed)\n throw new Error(\"committed called twice on the same write\");\n committed = true;\n self.outstanding_writes--;\n self._maybeFire();\n }\n };\n },\n\n // Arm the fence. Once the fence is armed, and there are no more\n // uncommitted writes, it will activate.\n arm: function () {\n var self = this;\n if (self === DDPServer._CurrentWriteFence.get())\n throw Error(\"Can't arm the current fence\");\n self.armed = true;\n self._maybeFire();\n },\n\n // Register a function to be called once before firing the fence.\n // Callback function can add new writes to the fence, in which case\n // it won't fire until those writes are done as well.\n onBeforeFire: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.before_fire_callbacks.push(func);\n },\n\n // Register a function to be called when the fence fires.\n onAllCommitted: function (func) {\n var self = this;\n if (self.fired)\n throw new Error(\"fence has already activated -- too late to \" +\n \"add a callback\");\n self.completion_callbacks.push(func);\n },\n\n // Convenience function. Arms the fence, then blocks until it fires.\n armAndWait: function () {\n var self = this;\n var future = new Future;\n self.onAllCommitted(function () {\n future['return']();\n });\n self.arm();\n future.wait();\n },\n\n _maybeFire: function () {\n var self = this;\n if (self.fired)\n throw new Error(\"write fence already activated?\");\n if (self.armed && !self.outstanding_writes) {\n function invokeCallback (func) {\n try {\n func(self);\n } catch (err) {\n Meteor._debug(\"exception in write fence callback\", err);\n }\n }\n\n self.outstanding_writes++;\n while (self.before_fire_callbacks.length > 0) {\n var callbacks = self.before_fire_callbacks;\n self.before_fire_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n self.outstanding_writes--;\n\n if (!self.outstanding_writes) {\n self.fired = true;\n var callbacks = self.completion_callbacks;\n self.completion_callbacks = [];\n _.each(callbacks, invokeCallback);\n }\n }\n },\n\n // Deactivate this fence so that adding more writes has no effect.\n // The fence must have already fired.\n retire: function () {\n var self = this;\n if (! self.fired)\n throw new Error(\"Can't retire a fence that hasn't fired.\");\n self.retired = true;\n }\n});\n","// A \"crossbar\" is a class that provides structured notification registration.\n// See _match for the definition of how a notification matches a trigger.\n// All notifications and triggers must have a string key named 'collection'.\n\nDDPServer._Crossbar = function (options) {\n var self = this;\n options = options || {};\n\n self.nextId = 1;\n // map from collection name (string) -> listener id -> object. each object has\n // keys 'trigger', 'callback'. As a hack, the empty string means \"no\n // collection\".\n self.listenersByCollection = {};\n self.listenersByCollectionCount = {};\n self.factPackage = options.factPackage || \"livedata\";\n self.factName = options.factName || null;\n};\n\n_.extend(DDPServer._Crossbar.prototype, {\n // msg is a trigger or a notification\n _collectionForMessage: function (msg) {\n var self = this;\n if (! _.has(msg, 'collection')) {\n return '';\n } else if (typeof(msg.collection) === 'string') {\n if (msg.collection === '')\n throw Error(\"Message has empty collection!\");\n return msg.collection;\n } else {\n throw Error(\"Message has non-string collection!\");\n }\n },\n\n // Listen for notification that match 'trigger'. A notification\n // matches if it has the key-value pairs in trigger as a\n // subset. When a notification matches, call 'callback', passing\n // the actual notification.\n //\n // Returns a listen handle, which is an object with a method\n // stop(). Call stop() to stop listening.\n //\n // XXX It should be legal to call fire() from inside a listen()\n // callback?\n listen: function (trigger, callback) {\n var self = this;\n var id = self.nextId++;\n\n var collection = self._collectionForMessage(trigger);\n var record = {trigger: EJSON.clone(trigger), callback: callback};\n if (! _.has(self.listenersByCollection, collection)) {\n self.listenersByCollection[collection] = {};\n self.listenersByCollectionCount[collection] = 0;\n }\n self.listenersByCollection[collection][id] = record;\n self.listenersByCollectionCount[collection]++;\n\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, 1);\n }\n\n return {\n stop: function () {\n if (self.factName && Package['facts-base']) {\n Package['facts-base'].Facts.incrementServerFact(\n self.factPackage, self.factName, -1);\n }\n delete self.listenersByCollection[collection][id];\n self.listenersByCollectionCount[collection]--;\n if (self.listenersByCollectionCount[collection] === 0) {\n delete self.listenersByCollection[collection];\n delete self.listenersByCollectionCount[collection];\n }\n }\n };\n },\n\n // Fire the provided 'notification' (an object whose attribute\n // values are all JSON-compatibile) -- inform all matching listeners\n // (registered with listen()).\n //\n // If fire() is called inside a write fence, then each of the\n // listener callbacks will be called inside the write fence as well.\n //\n // The listeners may be invoked in parallel, rather than serially.\n fire: function (notification) {\n var self = this;\n\n var collection = self._collectionForMessage(notification);\n\n if (! _.has(self.listenersByCollection, collection)) {\n return;\n }\n\n var listenersForCollection = self.listenersByCollection[collection];\n var callbackIds = [];\n _.each(listenersForCollection, function (l, id) {\n if (self._matches(notification, l.trigger)) {\n callbackIds.push(id);\n }\n });\n\n // Listener callbacks can yield, so we need to first find all the ones that\n // match in a single iteration over self.listenersByCollection (which can't\n // be mutated during this iteration), and then invoke the matching\n // callbacks, checking before each call to ensure they haven't stopped.\n // Note that we don't have to check that\n // self.listenersByCollection[collection] still === listenersForCollection,\n // because the only way that stops being true is if listenersForCollection\n // first gets reduced down to the empty object (and then never gets\n // increased again).\n _.each(callbackIds, function (id) {\n if (_.has(listenersForCollection, id)) {\n listenersForCollection[id].callback(notification);\n }\n });\n },\n\n // A notification matches a trigger if all keys that exist in both are equal.\n //\n // Examples:\n // N:{collection: \"C\"} matches T:{collection: \"C\"}\n // (a non-targeted write to a collection matches a\n // non-targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\"}\n // (a targeted write to a collection matches a non-targeted query)\n // N:{collection: \"C\"} matches T:{collection: \"C\", id: \"X\"}\n // (a non-targeted write to a collection matches a\n // targeted query)\n // N:{collection: \"C\", id: \"X\"} matches T:{collection: \"C\", id: \"X\"}\n // (a targeted write to a collection matches a targeted query targeted\n // at the same document)\n // N:{collection: \"C\", id: \"X\"} does not match T:{collection: \"C\", id: \"Y\"}\n // (a targeted write to a collection does not match a targeted query\n // targeted at a different document)\n _matches: function (notification, trigger) {\n // Most notifications that use the crossbar have a string `collection` and\n // maybe an `id` that is a string or ObjectID. We're already dividing up\n // triggers by collection, but let's fast-track \"nope, different ID\" (and\n // avoid the overly generic EJSON.equals). This makes a noticeable\n // performance difference; see https://github.com/meteor/meteor/pull/3697\n if (typeof(notification.id) === 'string' &&\n typeof(trigger.id) === 'string' &&\n notification.id !== trigger.id) {\n return false;\n }\n if (notification.id instanceof MongoID.ObjectID &&\n trigger.id instanceof MongoID.ObjectID &&\n ! notification.id.equals(trigger.id)) {\n return false;\n }\n\n return _.all(trigger, function (triggerValue, key) {\n return !_.has(notification, key) ||\n EJSON.equals(triggerValue, notification[key]);\n });\n }\n});\n\n// The \"invalidation crossbar\" is a specific instance used by the DDP server to\n// implement write fence notifications. Listener callbacks on this crossbar\n// should call beginWrite on the current write fence before they return, if they\n// want to delay the write fence from firing (ie, the DDP method-data-updated\n// message from being sent).\nDDPServer._InvalidationCrossbar = new DDPServer._Crossbar({\n factName: \"invalidation-crossbar-listeners\"\n});\n","if (process.env.DDP_DEFAULT_CONNECTION_URL) {\n __meteor_runtime_config__.DDP_DEFAULT_CONNECTION_URL =\n process.env.DDP_DEFAULT_CONNECTION_URL;\n}\n\nMeteor.server = new Server;\n\nMeteor.refresh = function (notification) {\n DDPServer._InvalidationCrossbar.fire(notification);\n};\n\n// Proxy the public methods of Meteor.server so they can\n// be called directly on Meteor.\n_.each(['publish', 'methods', 'call', 'apply', 'onConnection', 'onMessage'],\n function (name) {\n Meteor[name] = _.bind(Meteor.server[name], Meteor.server);\n });\n\n// Meteor.server used to be called Meteor.default_server. Provide\n// backcompat as a courtesy even though it was never documented.\n// XXX COMPAT WITH 0.6.4\nMeteor.default_server = Meteor.server;\n"]} \ No newline at end of file diff --git a/server/bundle/star.json b/server/bundle/star.json index c70d086232..24a9f631df 100644 --- a/server/bundle/star.json +++ b/server/bundle/star.json @@ -36,5 +36,5 @@ "meteorRelease": "METEOR@1.9.3", "nodeVersion": "12.16.1", "npmVersion": "6.13.4", - "gitCommitHash": "ff3716b5435f36644aa77f696f878d48faf1f906" + "gitCommitHash": "957145ac948fb1c17342669b1451edf987f03952" } \ No newline at end of file From a86c7943ef0d0f34e0ed24e9c640a554e97e5043 Mon Sep 17 00:00:00 2001 From: chenzhipei <18605199364@163.com> Date: Fri, 19 Jul 2024 06:26:33 +0000 Subject: [PATCH 4/6] =?UTF-8?q?fix:=20=E5=AE=A1=E6=89=B9=E7=8E=8B=E4=B8=AD?= =?UTF-8?q?=E5=9B=BE=E7=89=87=E7=B1=BB=E5=9E=8B=E5=90=8E=E7=BC=80=E5=90=8D?= =?UTF-8?q?=E5=A4=A7=E5=86=99=E4=B8=8D=E6=98=BE=E7=A4=BA=E9=A2=84=E8=A7=88?= =?UTF-8?q?=E6=8C=89=E9=92=AE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../client/lib/instance_readonly_template.coffee | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/creator/packages/steedos-workflow/client/lib/instance_readonly_template.coffee b/creator/packages/steedos-workflow/client/lib/instance_readonly_template.coffee index 2c5d3084fb..cc6e62b6ed 100644 --- a/creator/packages/steedos-workflow/client/lib/instance_readonly_template.coffee +++ b/creator/packages/steedos-workflow/client/lib/instance_readonly_template.coffee @@ -396,7 +396,7 @@ InstanceReadOnlyTemplate.getValue = (value, field, locale, utcOffset) -> fileName = item.original.name; fileUrl = Steedos.absoluteUrl('/api/files/files/'+item._id); filePreviewHtml = ''; - if [".pdf", ".jpg", ".jpeg", ".png", ".gif"].indexOf(fileName.slice(-4)) > -1 + if [".pdf", ".jpg", ".jpeg", ".png", ".gif"].indexOf(fileName.toLowerCase().slice(-4)) > -1 filePreviewHtml = " 预览" return "
#{fileName} #{filePreviewHtml ? filePreviewHtml : ''}
" From b7de0dc518ff3a27e974b4522f7874d8da9b53ba Mon Sep 17 00:00:00 2001 From: chenzhipei <18605199364@163.com> Date: Fri, 19 Jul 2024 06:27:02 +0000 Subject: [PATCH 5/6] build creator --- .../server/packages/aldeed_autoform.js | 17 ++++++++++------- .../server/packages/steedos_workflow.js | 4 ++-- .../server/packages/steedos_workflow.js.map | 2 +- ...022e4ace6cb1bfa61d2bb99bcc85909c9bcae65.js} | 2 +- ...6cb1bfa61d2bb99bcc85909c9bcae65.stats.json} | 8 ++++---- .../programs/web.browser.legacy/program.json | 18 +++++++++--------- ...022e4ace6cb1bfa61d2bb99bcc85909c9bcae65.js} | 2 +- ...6cb1bfa61d2bb99bcc85909c9bcae65.stats.json} | 8 ++++---- .../bundle/programs/web.browser/program.json | 18 +++++++++--------- ...3bf48e7712221391c1ba5ef6911357ec9380d7e.js} | 2 +- ...12221391c1ba5ef6911357ec9380d7e.stats.json} | 8 ++++---- .../bundle/programs/web.cordova/program.json | 18 +++++++++--------- server/bundle/star.json | 2 +- 13 files changed, 56 insertions(+), 53 deletions(-) rename server/bundle/programs/web.browser.legacy/{7d27de16d6eab9175efa4d52871e8cc6588f4811.js => d022e4ace6cb1bfa61d2bb99bcc85909c9bcae65.js} (88%) rename server/bundle/programs/web.browser.legacy/{7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json => d022e4ace6cb1bfa61d2bb99bcc85909c9bcae65.stats.json} (99%) rename server/bundle/programs/web.browser/{7d27de16d6eab9175efa4d52871e8cc6588f4811.js => d022e4ace6cb1bfa61d2bb99bcc85909c9bcae65.js} (88%) rename server/bundle/programs/web.browser/{7d27de16d6eab9175efa4d52871e8cc6588f4811.stats.json => d022e4ace6cb1bfa61d2bb99bcc85909c9bcae65.stats.json} (99%) rename server/bundle/programs/web.cordova/{717fd9820c5c4cf898af8b1c4a65e09c854f6d33.js => 93bf48e7712221391c1ba5ef6911357ec9380d7e.js} (88%) rename server/bundle/programs/web.cordova/{717fd9820c5c4cf898af8b1c4a65e09c854f6d33.stats.json => 93bf48e7712221391c1ba5ef6911357ec9380d7e.stats.json} (99%) diff --git a/server/bundle/programs/server/packages/aldeed_autoform.js b/server/bundle/programs/server/packages/aldeed_autoform.js index 8f60ab7750..439ea5b91e 100644 --- a/server/bundle/programs/server/packages/aldeed_autoform.js +++ b/server/bundle/programs/server/packages/aldeed_autoform.js @@ -9,21 +9,24 @@ var MongoObject = Package['aldeed:simple-schema'].MongoObject; var check = Package.check.check; var Match = Package.check.Match; +/* Package-scope variables */ +var AutoForm, globalDefaultTemplate, setDefaults, ArrayTracker, FormData, form_version, Hooks, getFlatDocOfFieldValues, getInputValue, getInputData, updateTrackedFieldValue, updateAllTrackedFieldValues, getAllFieldsInForm, validateField, arrayTracker, defaultTypeTemplates, deps, FormPreserve, res, Utility, year, month, date; + (function(){ -/////////////////////////////////////////////////////////////////////// -// // -// packages/aldeed_autoform/autoform-common.js // -// // -/////////////////////////////////////////////////////////////////////// - // +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// +// // +// packages/aldeed_autoform/autoform-common.js // +// // +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // // This is the only file that is run on the server, too // Extend the schema options allowed by SimpleSchema SimpleSchema.extendOptions({ autoform: Match.Optional(Object) }); -/////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// }).call(this); diff --git a/server/bundle/programs/server/packages/steedos_workflow.js b/server/bundle/programs/server/packages/steedos_workflow.js index 055600ee85..4457ae983f 100644 --- a/server/bundle/programs/server/packages/steedos_workflow.js +++ b/server/bundle/programs/server/packages/steedos_workflow.js @@ -3057,7 +3057,7 @@ InstanceReadOnlyTemplate.getValue = function (value, field, locale, utcOffset) { fileUrl = Steedos.absoluteUrl('/api/files/files/' + item._id); filePreviewHtml = ''; - if ([".pdf", ".jpg", ".jpeg", ".png", ".gif"].indexOf(fileName.slice(-4)) > -1) { + if ([".pdf", ".jpg", ".jpeg", ".png", ".gif"].indexOf(fileName.toLowerCase().slice(-4)) > -1) { filePreviewHtml = " 预览"; } @@ -12009,4 +12009,4 @@ Package._define("steedos:workflow", { })(); //# sourceURL=meteor://💻app/packages/steedos_workflow.js -//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/steedos:workflow/checkNpm.js","meteor://💻app/packages/steedos:workflow/lib/URI.js","meteor://💻app/packages/steedos_workflow/lib/core.coffee","meteor://💻app/lib/core.coffee","meteor://💻app/packages/steedos_workflow/lib/models/instance_tasks.coffee","meteor://💻app/packages/steedos_workflow/lib/models/auth_tokens.coffee","meteor://💻app/packages/steedos_workflow/client/lib/instance_readonly_template.coffee","meteor://💻app/client/lib/instance_readonly_template.coffee","meteor://💻app/packages/steedos_workflow/client/lib/template_manager.coffee","meteor://💻app/client/lib/template_manager.coffee","meteor://💻app/packages/steedos:workflow/client/coreform/inputTypes/coreform-table/steedos-table.js","meteor://💻app/packages/steedos_workflow/client/views/instance/_image_sign.coffee","meteor://💻app/client/views/instance/_image_sign.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_traces_handler.coffee","meteor://💻app/client/views/instance/_traces_handler.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_instance_form.coffee","meteor://💻app/client/views/instance/_instance_form.coffee","meteor://💻app/packages/steedos:workflow/client/views/instance/_instance_attachments.js","meteor://💻app/packages/steedos_workflow/client/views/instance/_instance_sign_text.coffee","meteor://💻app/client/views/instance/_instance_sign_text.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_traces_help.coffee","meteor://💻app/client/views/instance/_traces_help.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_related_instances.coffee","meteor://💻app/client/views/instance/_related_instances.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_related_records.coffee","meteor://💻app/client/views/instance/_related_records.coffee","meteor://💻app/packages/steedos:workflow/routes/getSpaceUsers.js","meteor://💻app/packages/steedos:workflow/routes/getFormulaUserObjects.js","meteor://💻app/packages/steedos:workflow/routes/init_formula_values.js","meteor://💻app/packages/steedos:workflow/routes/api_workflow_forward.js","meteor://💻app/packages/steedos_workflow/routes/test_webhook.coffee","meteor://💻app/routes/test_webhook.coffee","meteor://💻app/packages/steedos_workflow/server/methods/set_instance_step_approve.coffee","meteor://💻app/packages/steedos:workflow/server/methods/get_instance_data.js","meteor://💻app/packages/steedos:workflow/server/methods/save_instance.js","meteor://💻app/packages/steedos:workflow/server/methods/trace_approve_cc.js","meteor://💻app/packages/steedos:workflow/server/methods/forward_instance.js","meteor://💻app/packages/steedos:workflow/server/methods/cfs_instances.js","meteor://💻app/packages/steedos_workflow/server/methods/instance_approve.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_return.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_remind.coffee","meteor://💻app/packages/steedos_workflow/server/methods/next_step_users_not_found.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_number_rules.coffee","meteor://💻app/packages/steedos_workflow/server/methods/check_main_attach.coffee","meteor://💻app/packages/steedos_workflow/server/methods/related_instances.coffee","meteor://💻app/packages/steedos_workflow/server/methods/edit_flow_positions.coffee","meteor://💻app/packages/steedos_workflow/server/methods/start_flow.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_traces.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_batch.coffee","meteor://💻app/packages/steedos_workflow/server/methods/flow.coffee","meteor://💻app/packages/steedos_workflow/server/methods/hide_instance.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_value.coffee","meteor://💻app/packages/steedos_workflow/server/routes/instance.coffee","meteor://💻app/server/routes/instance.coffee","meteor://💻app/packages/steedos_workflow/server/routes/steedos_css.coffee","meteor://💻app/server/routes/steedos_css.coffee","meteor://💻app/packages/steedos_workflow/server/routes/instance_draft_view.coffee","meteor://💻app/server/routes/instance_draft_view.coffee","meteor://💻app/packages/steedos:workflow/server/lib/1_form_formula.js","meteor://💻app/packages/steedos_workflow/server/publications/categories.coffee","meteor://💻app/server/publications/categories.coffee","meteor://💻app/packages/steedos_workflow/server/publications/cfs_instances.coffee","meteor://💻app/server/publications/cfs_instances.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_positions.coffee","meteor://💻app/server/publications/flow_positions.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_positions_tabular.coffee","meteor://💻app/server/publications/flow_positions_tabular.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_roles.coffee","meteor://💻app/server/publications/flow_roles.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flows.coffee","meteor://💻app/server/publications/flows.coffee","meteor://💻app/packages/steedos_workflow/server/publications/forms.coffee","meteor://💻app/server/publications/forms.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_data.coffee","meteor://💻app/server/publications/instance_data.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_list.coffee","meteor://💻app/server/publications/instance_list.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_tabular.coffee","meteor://💻app/server/publications/instance_tabular.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_draft.coffee","meteor://💻app/server/publications/instance_draft.coffee","meteor://💻app/packages/steedos_workflow/server/publications/distributed_instances_state_by_ids.coffee","meteor://💻app/server/publications/distributed_instances_state_by_ids.coffee","meteor://💻app/packages/steedos_workflow/server/publications/related_instaces.coffee","meteor://💻app/server/publications/related_instaces.coffee","meteor://💻app/packages/steedos_workflow/server/publications/space_user_signs.coffee","meteor://💻app/server/publications/space_user_signs.coffee","meteor://💻app/packages/steedos_workflow/server/publications/user_inbox_instance.coffee","meteor://💻app/server/publications/user_inbox_instance.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_main_attach_template.coffee","meteor://💻app/server/publications/flow_main_attach_template.coffee","meteor://💻app/packages/steedos_workflow/server/flow-template/workflow_template.coffee","meteor://💻app/server/flow-template/workflow_template.coffee","meteor://💻app/packages/steedos_workflow/server/schedule/auto_finish_process_delegation.coffee","meteor://💻app/server/schedule/auto_finish_process_delegation.coffee","meteor://💻app/packages/steedos_workflow/server/schedule/timeout_auto_submit.coffee","meteor://💻app/server/schedule/timeout_auto_submit.coffee","meteor://💻app/packages/steedos_workflow/related_instances_tabular.coffee","meteor://💻app/related_instances_tabular.coffee","meteor://💻app/packages/steedos_workflow/tabular.coffee","meteor://💻app/tabular.coffee"],"names":["checkNpmVersions","module","link","v","root","factory","define","amd","URI","punycode","IPv6","SecondLevelDomains","SLD","_URI","url","base","_urlSupplied","arguments","length","_baseSupplied","undefined","TypeError","location","href","absoluteTo","version","p","prototype","hasOwn","Object","hasOwnProperty","escapeRegEx","string","replace","getType","value","String","toString","call","slice","isArray","obj","filterArrayValues","data","lookup","i","_match","test","splice","arrayContains","list","_type","match","arraysEqual","one","two","sort","l","trimSlashes","text","trim_expression","_parts","protocol","username","password","hostname","urn","port","path","query","fragment","duplicateQueryParameters","escapeQuerySpace","protocol_expression","idn_expression","punycode_expression","ip4_expression","ip6_expression","find_uri_expression","findUri","start","end","trim","defaultPorts","http","https","ftp","gopher","ws","wss","invalid_hostname_characters","domAttributes","getDomAttribute","node","nodeName","toLowerCase","type","escapeForDumbFirefox36","escape","strictEncodeURIComponent","encodeURIComponent","encode","decode","decodeURIComponent","iso8859","unescape","unicode","characters","pathname","expression","map","reserved","urnpath","encodeQuery","escaped","decodeQuery","e","_part","generateAccessor","_group","c","generateSegmentedPathFunction","_sep","_codingFuncName","_innerCodingFuncName","actualCodingFunc","segments","split","join","decodePath","decodeUrnPath","recodePath","recodeUrnPath","encodeReserved","parse","parts","pos","indexOf","substring","parseAuthority","parseHost","bracketPos","t","charAt","firstColon","firstSlash","nextColon","parseUserinfo","lastIndexOf","shift","parseQuery","items","splits","name","push","build","buildAuthority","buildHost","buildUserinfo","buildQuery","unique","key","buildQueryParameter","addQuery","concat","removeQuery","hasQuery","withinArray","_booly","Boolean","op","commonPath","Math","min","withinString","callback","options","_start","_end","_trim","_attributeOpen","lastIndex","exec","index","ignoreHtml","attributeOpen","max","search","ignore","result","ensureValidHostname","toASCII","noConflict","removeAll","unconflicted","URITemplate","deferBuild","_deferred_build","_string","clone","valueOf","generateSimpleAccessor","generatePrefixAccessor","_key","hash","res","_object","attribute","src","is","what","ip","ip4","ip6","sld","idn","relative","has","_protocol","_port","_hostname","scheme","x","origin","authority","host","userinfo","resource","subdomain","domain","sub","RegExp","tld","get","ReferenceError","directory","filename","decodePathSegment","mutatedDirectory","normalizePath","suffix","s","segment","separator","absolute","Error","pop","unshift","segmentCoded","q","setQuery","setSearch","addSearch","removeSearch","hasSearch","normalize","normalizeProtocol","normalizeQuery","normalizeFragment","normalizeHostname","normalizePort","best","_path","_was_relative","_leadingParents","_parent","_pos","normalizePathname","normalizeSearch","normalizeHash","d","readable","uri","toUnicode","qp","kv","resolved","properties","basedir","relativeTo","relativeParts","baseParts","common","relativePath","basePath","parents","equals","one_map","two_map","checked","one_query","two_query","Workflow","ImageSign","TracesHandler","TracesTemplate","InstanceformTemplate","InstanceAttachmentTemplate","InstanceSignText","RelatedInstances","RelatedRecords","InstanceMacro","context","TracesManager","isOpinionField_from_string","field_formula","includesOpinionField","form","form_version","_form_version","field_formulas","fields","Array","Meteor","isServer","uuflowManager","getFormVersion","db","forms","findOne","_id","form_versions","forEach","f","ref","console","log","f1","formula","_","some","helpers","instance_tasks","Collection","_simpleSchema","SimpleSchema","instance","trace","is_finished","user","user_name","handler","handler_name","handler_organization","handler_organization_name","handler_organization_fullname","start_date","Date","due_date","is_read","is_error","values","deadline","remind_date","reminded_count","Number","read_date","description","modified","modified_by","sign_show","judge","next_steps","finish_date","cost_time","space","instance_name","submitter","submitter_name","applicant","applicant_name","applicant_organization_name","submit_date","flow","flow_name","step","step_name","category_name","instance_state","distribute_from_instance","forward_from_instance","keywords","is_archived","category","auth_tokens","_getLocale","_getRequiredFields","_getStartStepEditableFields","_getStartStepRequiredFields","_getTemplateData","_getViewHtml","getLinkText","marked","require","InstanceReadOnlyTemplate","instance_attachment","afSelectUserRead","afFormGroupRead","afFormGroup","create","tempalteName","steedosData","template","templateCompiled","templateRenderFunction","SpacebarsCompiler","compile","isBody","eval","Template","Blaze","createInstanceSignText","instanceSignTextCompiled","instanceSignTextHtml","instanceSignTextRenderFunction","instanceSignText","createImageSign","imageSignCompiled","imageSignHtml","imageSignRenderFunction","imageSign","createTracesHanlder","tracesHanlderCompiled","tracesHanlderHtml","tracesHanlderRenderFunction","instance_traces_handler","init","item","label","detail_url","Steedos","absoluteUrl","getValue","field","locale","utcOffset","date","fieldOptions","hours","month","nameField","records","seconds","selectedOption","selectedOptions","splitedValues","t0","t1","uiSchema","year","n","itemSplits","encodeURI","error","is_multiselect","getProperty","fullname","TAPi18n","__","formatDate","formatTime","is_textarea","find","filter","is_percent","numberToPercentString","digits","numberToString","isClient","authRequest","JSON","stringify","async","objectFind","filters","fileName","filePreviewHtml","fileUrl","original","Creator","getObject","reference_to","NAME_FIELD_KEY","reference_to_field","getObjectNameFieldKey","getLabel","code","findPropertyByPK","getInstanceFormVersion","form_fields","current","where","historys","getFlowVersion","flow_version","flows","viewHtml","Assets","getText","ref1","toLocaleLowerCase","rev","is_required","steps","editableCode","startStep","keys","permissions","requiredFields","intersection","WorkflowManager","WorkflowManager_format","getAutoformSchemaValues","insname","ins_state","state","ins_final_decision","ins_code","ins_is_archived","ins_is_deleted","applicantContext","sessionUserId","editable","startStepEditableFields","passing","moment","format","getInstanceView","body","instanceCompiled","instanceRenderFunction","instanceTemplate","TemplateManager","getTemplate","templateName","instance_readonly_view","toHTMLWithData","getTracesView","traceCompiled","traceRenderFunction","tracesHtml","instance_style","trace_readonly_view","traces","getAttachmentView","attachmentCompiled","attachmentHtml","attachmentRenderFunction","attachments_readonly_view","getRelatedInstancesView","relatedInstancesCompiled","relatedInstancesHtml","relatedInstancesRenderFunction","related_instances_view","getRelatedRecordsView","relatedRecordsCompiled","relatedRecordsHtml","relatedRecordsRenderFunction","related_records_view","getOnLoadScript","form_script","getInstanceHtml","allCssLink","attachment","creatorService","cssHref","formDescription","formDescriptionHtml","html","ins_record_ids","instanceBoxStyle","jqHref","onLoadScript","openFileScript","related_instances","related_records","showTracesBtn","showTracesScript","traceCheck","width","settings","webservices","creator","record_ids","isMobile","showTrace","final_decision","showAttachments","isEmpty","tagger","styles","plugins","add_styles","formId","instance_title","pageTitle","pageTitleTrClass","val","CoreForm","pageTitleFieldName","handleTableTemplate","_export","table_fields","table_field","field_permission","pureCode","required","title_permission","removeSpecialCharacter","isOpinionField","tr_start","td_colspan","tr_end","includes","permission","_template","table","_templateHelps","steedos_instance","getInstance","atts","id","style","disabled","instanceId","form_types","ApproveManager","isReadOnly","steedos_form","innersubformContext","doc_values","Session","a","b","getAutoformSchema","instance_box_style","box","ins","print_template","instance_template","SteedosTable","checkItem","item_index","fieldObj","getField","fieldVal","getItemModalValue","sf_name","sfields","sf","InstanceManager","checkFormFieldValue","$","setTableItemValue","item_value","tableValue","getTableValue","getTableItemValue","removeTableItem","removed","setTableValue","getValidValue","validValue","handleData","instanceFields","getInstanceFields","getModalData","Form_formula","getFormulaFieldVariable","AutoForm","getFormValues","insertDoc","addItem","_item_value","getKeys","append","getTr","updateItem","tds","getRemoveTd","sfield","getTd","empty","runFormula","removeItem","hide","showModal","method","modalData","setTimeout","Modal","show","getCurrentDataForForm","ss","getFormSchema","schema","objectKeys","_makeGeneric","getThead","isObject","thead","trs","sf_length","wide_fields","filterProperty","is_wide","getTbody","sfieldsEditable","tbody","tr","td","td_value","getTDValue","view","CFDataManager","getFormulaSpaceUsers","u","getFormulaOrganizations","o","getFormulaOrganization","pluck","addInputType","valueOut","valueConverters","stringToStringArray","stringToNumber","stringToNumberArray","stringToBoolean","stringToBooleanArray","stringToDate","stringToDateArray","contextAdjust","maxlength","afTable","events","event","new_item_index","currentTarget","dataset","set","rendered","str","addItemTr","getCurrentStep","step_type","ccHasEditPermission","autorun","currentData","spaceUserSign","userId","space_user_signs","imageURL","sign","showSignImage","traceShowSignImage","objectUrl","object_name","record_id","app_id","getObjectUrl","unempty","unequals","include","ref2","ref3","getInstanceFlowVersion","approves","ref4","approve","judge_name","opinion_fields_code","sign_field_code","after_field","before_field","pre_fields","pre_wide_fields","sort_approve","order","p1","p2","_p1","_p2","getTime","_t","isTextarea","getCfClass","getTableThead","getTableBody","showLabel","templateData","getOpinionFieldStepsName","top_keywords","foo1","opinionFields","foo","json_formula","s1","error1","yijianlan","stepName","image_sign","only_cc_opinion","only_cc","default_description","only_handler","showCCOpinion","markDownToHtml","markDownString","Npm","Spacebars","SafeString","f_label","that","isSection","registerHelper","ins_attach_download_url","getPermissions","instanceformChangeEvent","preventDefault","openWindow","target","onCreated","compiled","instanceCustomTemplate","instanceView","renderFunction","View","instance_custom_template","onRendered","currentApprove","currentStep","formula_fields","instanceNumberFields","setInstanceFormApplicant","nextSteps","nextStepUsers","InstanceEvent","initEvents","getCurrentApprove","each","element","schemaKey","toastr","reason","getFieldValue","InstanceNumberRules","instanceNumberBuilder","trigger","run","showMainTitle","workflowMainAttachTitle","enabled_add_main_attachment","current_step","currentTrace","getCurrentTrace","main_attach_count","cfs","instances","count","distribute_main_attach_count","start_step","getStartStep","can_edit_main_attach","enabled_edit_normal_attachment","getFlow","upload_after_being_distributed","isCC","getCCStep","can_edit_normal_attach","main_attachment","main_attach","normal_attachments","selector","$ne","dfis","distribute_from_instances","$in","distribute_main","firstVersionMain","metadata","parent","attachmentUploadedAt","uploadedAt","firstVersion","sortBy","instanceIds","attachments_count","flow_files","files","isDraftAndFlowfilesExist","compact","attachments","$or","fetch","myApprove","myTrace","isInbox","defaultDescription","approve_sort","approvesGroup","approves_sorted","completed_date","hasNext","haveDescriptionApprove","is_completed","last","top_approves","union","top_approve","groupBy","handlerApproves","descriptionApproves","workflow","showBlankApproveDescription","_display","isMyApprove","myApproveDescription","approveId","now","isOpinionOfField","imageSignData","getLastSignApprove","getHandlerSignShowApproves","lastMyApproveDescription","showApprove","judge_description","is_approved","is_rejected","is_readed","addClass","dateFormat","getFullYear","getStepName","stepId","getInstanceStep","showDeleteButton","approved","from_user","isShowModificationButton","approve_admins","isShow","contains","isEditing","is_editing","isShowDescription","getApproveStatusIcon","approveJudge","autoSubmitted","approveStatusIcon","getApproveStatusText","approveStatusText","getApproveJudgeClass","isForward","showForwardDeleteButton","forward_instance","isDistribute","showDistributeDeleteButton","hasFlowAdminPermission","finishDateSchema","isAndroidOrIOS","autoform","optional","readonly","dateTimePickerOptions","ignoreReadonly","widgetPositioning","horizontal","finishDateValues","showTracesView","show_modal_traces_list","space_settings","getInstanceStateText","instance_id","getInstanceStateColor","cla","firstTrace","last_distribute_from","dis_info","$exists","created","created_by","UUflow_api","getNameForUser","users","from_user_name","isCCOrDistributeOrForwardTerminated","judgeTerminated","instanceExists","agentDescription","userName","traceName","traceId","handlerDoc","handlerId","users_can_read_cc_handler_detail_info","getContactInfoForUser","stopPropagation","calling","err","removeClass","success","allowMultiple","closest","target_user_id","openSafeObjectUrl","forward_space","forwardspace","forwardinstance","Tracker","afterFlush","on","scrollTop","finish_input","opinion_input","showRelatedInstaces","related_instaces","related_instace_url","isCordova","show_delete","showRelatedRecords","relatedRecordUrl","objcetName","ids","process","env","CREATOR_NODE_ENV","JsonRoutes","add","req","next","hashData","action","to_users","sendResult","stack","errors","errorMessage","message","workflowMethods","methods","set_instance_step_approve","ins_id","step_approve","stepsApprovesOptions","apply","set_instance_skip_steps","get_instance_data","formCached","flowCached","draft_save_instance","inbox_save_instance","cc_do","cc_user_ids","cc_read","cc_submit","cc_remove","batch_cancel_cc","approve_ids","cc_save","space_id","flow_id","hasSaveInstanceToAttachment","isForwardAttachments","selectedUsers","action_type","related","from_approve_id","forward_remove","trace_id","approve_id","cancelDistribute","cfs_instances_remove","file_id","cfs_instances_set_current","cfs_instances_lock","user_id","cfs_instances_unlock","download_space_instance_attachments_to_disk","spaceId","cfsRecordIds","set_approve_have_read","change_approve_info","update_approve_sign","sign_type","lastSignApprove","update_sign_show","objs","myApprove_id","instance_return","instance_remind","remind_users","remind_count","remind_deadline","action_types","next_step_users_not_found","deal_type","params","_eval","check_main_attach","remove_related","re_ins_id","update_instance_related","updateFlowPosition","updateFlowRole","start_flow","flowId","get_instance_traces","categoryId","flowIds","get_batch_instances","get_batch_instances_count","get_my_approves","change_flow_state","hide_instance","insId","is_hidden","getInstanceValues","Cookies","getInstanceReadOnly","_hasPermission","_locale","_parent_instances","dataBuf","hide_traces","spaceUserCount","getAPILoginUser","access_token","getUserIdFromAccessToken","spaces","space_users","hasInstancePermissions","_parent_id","_parent_ins","charset","Buffer","setHeader","statusCode","ret_sync_token","spaceUser","spaceUserOrganizations","sync_token","APIAuthenticationCheck","headers","isSpaceAdmin","organizations","canMonitor","canAdmin","$gt","$nin","inbox_uers","cc_users","outbox_users","skip","limit","copies","allCss","WebApp","getRefreshableAssets","css","rootUrl","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","ROOT_URL","endsWith","h","g","m","k","getEach","uniq","mixin","dest","handerUserObject","organization","hr","sort_no","mobile","work_phone","position","userRoles","roles","handerOrgObject","org","init_formula_values","autoFormDoc","approver","__values","tableFields","tableValues","formulaTableValues","__tableValues","tablefield","getFormulaUserObjects","getFormulaOrgObjects","getFormulaUserObject","publish","check","ready","categories","app","flow_positions","role","publishComposite","tableName","Match","Optional","unblock","children","flow_roles","createTemplateFormAndFlow","perms","company_id","distribute_optional_users","distribute_to_self","enable_amisform","versionId","handle","self","latest","observeChanges","changed","added","onStop","stop","flow_ids","distribute_end_notification","allow_select_step","amis_schema","getMiniInstance","getMyapproveModified","instance_fields_0","miniApproveFields","needChange","triggerChangeFields","triggerChangeFieldsValues","myApproveModifieds","_instanceId","_trace","changeFields","_change","_rev","_my_approve_modifieds","isEqual","getInstanceTraces","_insId","inbox_users","asyncLastFinishedApprove","lastFinishedApproveAggregate","instanceid","dataMap","operation","rawCollection","aggregate","toArray","doc","isFunction","wrapAsync","getMyApprove","getMyLastFinishedApprove","getStepCurrentName","notFinishedTraces","agent","stepCurrentName","$slice","myLastFinishedApprove","agent_user_name","my_finish_date","is_cc","cc_count","tabularName","instance_ids","related_instance_ids","_async_get_flow_instances_aggregate","_get_flow_instances_aggregate","_items","$match","$group","$sum","_changeData","_flowsData","_init","dataItem","flow_instance","observe","getCollection","workflowTemplate","startup","absolute_path_cn","absolute_path_us","filesList_cn","filesList_us","fs","mime","path_cn","path_us","readFileList","pathDir","filesList","readdirSync","stat","statSync","isDirectory","workflowTemplates","resolve","existsSync","file","readFileSync","go_next","rule","schedule","cron","auto_finish_process_delegation","scheduleJob","bindEnvironment","time","process_delegation_rules","update","enabled","end_time","$lte","$set","multi","timeEnd","timeout_auto_submit","timeoutAutoSubmit","TabularTables","related_instances_tabular","Tabular","Table","collection","columns","title","orderable","render","input","step_current_name","current_step_name","dom","lengthChange","extraFields","pageLength","info","searching","responsive","details","autoWidth","changeSelector","curSpaceUser","$and","admins","fl","extend","GetBoxInstancesTabularOptions","_get_inbox_instances_tabular_options","_get_outbox_instances_tabular_options","_handleListFields","instanceTasksListTableTabular","instancesListTableTabular","newInstancesListTabular","updateTabularTitle","subs","SubsManager","ins_fields","pub","onUnload","instance_list","_tableColumns","drawCallback","ellipsisLink","emptyTd","colSpan","isPad","perfectScrollbar","oInstance","attr","click","goPage","height","pages","ceil","fnRecordsDisplay","_iDisplayLength","DataTable","page","draw","blur","currentPage","keydown","keyCode","createdRow","row","dataIndex","FlowRouter","setAttribute","agent_view","cc_view","instanceNamePriorityClass","modifiedFromNow","modifiedString","priorityIcon","priorityIconClass","priorityValue","step_current_name_view","unread","momentReactiveFromNow","priority","visible","cc_tag","record_need","lengthMenu","space_user","pagingType","is_list_display","inbox_instances","outbox_instances","getSort","flowInstances","ReactiveVar","_changeOrder"],"mappings":"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,CAAL;;AAEA,QAAG1wB,QAAH;AACC,aAAOqE,OAAOsH,WAAP,CAAmB,WAAS8kB,UAAT,GAAoB,QAApB,GAA4BhZ,EAA/C,CAAP;AADD;AAGC,aAAO/L,QAAQC,WAAR,CAAoB,WAAS8kB,UAAT,GAAoB,QAApB,GAA4BhZ,EAAhD,CAAP;ACIE;AD9BJ;AAAA,CADD,C;;;;;;;;;;;;;;;;;;;;;;;AEAA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;AC/BA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;AC/BA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AAEA;AACA;AAEA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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","file":"/packages/steedos_workflow.js","sourcesContent":["import { checkNpmVersions } from 'meteor/tmeasday:check-npm-versions';\ncheckNpmVersions({\n\t\"node-schedule\": \"^1.3.1\",\n\t\"xml2js\": \"^0.4.19\",\n}, 'steedos:workflow');","/*!\n * URI.js - Mutating URLs\n *\n * Version: 1.17.0\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/\n *\n * Licensed under\n *   MIT License http://www.opensource.org/licenses/mit-license\n *   GPL v3 http://opensource.org/licenses/GPL-3.0\n *\n */\n(function (root, factory) {\n\t'use strict';\n\t// https://github.com/umdjs/umd/blob/master/returnExports.js\n\t// if (typeof exports === 'object') {\n\t//   // Node\n\t//   module.exports = factory(require('./punycode'), require('./IPv6'), require('./SecondLevelDomains'));\n\t// } else\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine(['./punycode', './IPv6', './SecondLevelDomains'], factory);\n\t} else {\n\t\t// Browser globals (root is window)\n\t\troot.URI = factory(root.punycode, root.IPv6, root.SecondLevelDomains, root);\n\t}\n}(this, function (punycode, IPv6, SLD, root) {\n\t'use strict';\n\t/*global location, escape, unescape */\n\t// FIXME: v2.0.0 renamce non-camelCase properties to uppercase\n\t/*jshint camelcase: false */\n\n\t// save current URI variable, if any\n\tvar _URI = root && root.URI;\n\n\tfunction URI(url, base) {\n\t\tvar _urlSupplied = arguments.length >= 1;\n\t\tvar _baseSupplied = arguments.length >= 2;\n\n\t\t// Allow instantiation without the 'new' keyword\n\t\tif (!(this instanceof URI)) {\n\t\t\tif (_urlSupplied) {\n\t\t\t\tif (_baseSupplied) {\n\t\t\t\t\treturn new URI(url, base);\n\t\t\t\t}\n\n\t\t\t\treturn new URI(url);\n\t\t\t}\n\n\t\t\treturn new URI();\n\t\t}\n\n\t\tif (url === undefined) {\n\t\t\tif (_urlSupplied) {\n\t\t\t\tthrow new TypeError('undefined is not a valid argument for URI');\n\t\t\t}\n\n\t\t\tif (typeof location !== 'undefined') {\n\t\t\t\turl = location.href + '';\n\t\t\t} else {\n\t\t\t\turl = '';\n\t\t\t}\n\t\t}\n\n\t\tthis.href(url);\n\n\t\t// resolve to base according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#constructor\n\t\tif (base !== undefined) {\n\t\t\treturn this.absoluteTo(base);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tURI.version = '1.17.0';\n\n\tvar p = URI.prototype;\n\tvar hasOwn = Object.prototype.hasOwnProperty;\n\n\tfunction escapeRegEx(string) {\n\t\t// https://github.com/medialize/URI.js/commit/85ac21783c11f8ccab06106dba9735a31a86924d#commitcomment-821963\n\t\treturn string.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n\t}\n\n\tfunction getType(value) {\n\t\t// IE8 doesn't return [Object Undefined] but [Object Object] for undefined value\n\t\tif (value === undefined) {\n\t\t\treturn 'Undefined';\n\t\t}\n\n\t\treturn String(Object.prototype.toString.call(value)).slice(8, -1);\n\t}\n\n\tfunction isArray(obj) {\n\t\treturn getType(obj) === 'Array';\n\t}\n\n\tfunction filterArrayValues(data, value) {\n\t\tvar lookup = {};\n\t\tvar i, length;\n\n\t\tif (getType(value) === 'RegExp') {\n\t\t\tlookup = null;\n\t\t} else if (isArray(value)) {\n\t\t\tfor (i = 0, length = value.length; i < length; i++) {\n\t\t\t\tlookup[value[i]] = true;\n\t\t\t}\n\t\t} else {\n\t\t\tlookup[value] = true;\n\t\t}\n\n\t\tfor (i = 0, length = data.length; i < length; i++) {\n\t\t\t/*jshint laxbreak: true */\n\t\t\tvar _match = lookup && lookup[data[i]] !== undefined\n\t\t\t\t|| !lookup && value.test(data[i]);\n\t\t\t/*jshint laxbreak: false */\n\t\t\tif (_match) {\n\t\t\t\tdata.splice(i, 1);\n\t\t\t\tlength--;\n\t\t\t\ti--;\n\t\t\t}\n\t\t}\n\n\t\treturn data;\n\t}\n\n\tfunction arrayContains(list, value) {\n\t\tvar i, length;\n\n\t\t// value may be string, number, array, regexp\n\t\tif (isArray(value)) {\n\t\t\t// Note: this can be optimized to O(n) (instead of current O(m * n))\n\t\t\tfor (i = 0, length = value.length; i < length; i++) {\n\t\t\t\tif (!arrayContains(list, value[i])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\n\t\tvar _type = getType(value);\n\t\tfor (i = 0, length = list.length; i < length; i++) {\n\t\t\tif (_type === 'RegExp') {\n\t\t\t\tif (typeof list[i] === 'string' && list[i].match(value)) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else if (list[i] === value) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tfunction arraysEqual(one, two) {\n\t\tif (!isArray(one) || !isArray(two)) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// arrays can't be equal if they have different amount of content\n\t\tif (one.length !== two.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tone.sort();\n\t\ttwo.sort();\n\n\t\tfor (var i = 0, l = one.length; i < l; i++) {\n\t\t\tif (one[i] !== two[i]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tfunction trimSlashes(text) {\n\t\tvar trim_expression = /^\\/+|\\/+$/g;\n\t\treturn text.replace(trim_expression, '');\n\t}\n\n\tURI._parts = function() {\n\t\treturn {\n\t\t\tprotocol: null,\n\t\t\tusername: null,\n\t\t\tpassword: null,\n\t\t\thostname: null,\n\t\t\turn: null,\n\t\t\tport: null,\n\t\t\tpath: null,\n\t\t\tquery: null,\n\t\t\tfragment: null,\n\t\t\t// state\n\t\t\tduplicateQueryParameters: URI.duplicateQueryParameters,\n\t\t\tescapeQuerySpace: URI.escapeQuerySpace\n\t\t};\n\t};\n\t// state: allow duplicate query parameters (a=1&a=1)\n\tURI.duplicateQueryParameters = false;\n\t// state: replaces + with %20 (space in query strings)\n\tURI.escapeQuerySpace = true;\n\t// static properties\n\tURI.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;\n\tURI.idn_expression = /[^a-z0-9\\.-]/i;\n\tURI.punycode_expression = /(xn--)/i;\n\t// well, 333.444.555.666 matches, but it sure ain't no IPv4 - do we care?\n\tURI.ip4_expression = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\n\t// credits to Rich Brown\n\t// source: http://forums.intermapper.com/viewtopic.php?p=1096#1096\n\t// specification: http://www.ietf.org/rfc/rfc4291.txt\n\tURI.ip6_expression = /^\\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\s*$/;\n\t// expression used is \"gruber revised\" (@gruber v2) determined to be the\n\t// best solution in a regex-golf we did a couple of ages ago at\n\t// * http://mathiasbynens.be/demo/url-regex\n\t// * http://rodneyrehm.de/t/url-regex.html\n\tURI.find_uri_expression = /\\b((?:[a-z][\\w-]+:(?:\\/{1,3}|[a-z0-9%])|www\\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}\\/)(?:[^\\s()<>]+|\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\))+(?:\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\)|[^\\s`!()\\[\\]{};:'\".,<>?«»“”‘’]))/ig;\n\tURI.findUri = {\n\t\t// valid \"scheme://\" or \"www.\"\n\t\tstart: /\\b(?:([a-z][a-z0-9.+-]*:\\/\\/)|www\\.)/gi,\n\t\t// everything up to the next whitespace\n\t\tend: /[\\s\\r\\n]|$/,\n\t\t// trim trailing punctuation captured by end RegExp\n\t\ttrim: /[`!()\\[\\]{};:'\".,<>?«»“”„‘’]+$/\n\t};\n\t// http://www.iana.org/assignments/uri-schemes.html\n\t// http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Well-known_ports\n\tURI.defaultPorts = {\n\t\thttp: '80',\n\t\thttps: '443',\n\t\tftp: '21',\n\t\tgopher: '70',\n\t\tws: '80',\n\t\twss: '443'\n\t};\n\t// allowed hostname characters according to RFC 3986\n\t// ALPHA DIGIT \"-\" \".\" \"_\" \"~\" \"!\" \"$\" \"&\" \"'\" \"(\" \")\" \"*\" \"+\" \",\" \";\" \"=\" %encoded\n\t// I've never seen a (non-IDN) hostname other than: ALPHA DIGIT . -\n\tURI.invalid_hostname_characters = /[^a-zA-Z0-9\\.-]/;\n\t// map DOM Elements to their URI attribute\n\tURI.domAttributes = {\n\t\t'a': 'href',\n\t\t'blockquote': 'cite',\n\t\t'link': 'href',\n\t\t'base': 'href',\n\t\t'script': 'src',\n\t\t'form': 'action',\n\t\t'img': 'src',\n\t\t'area': 'href',\n\t\t'iframe': 'src',\n\t\t'embed': 'src',\n\t\t'source': 'src',\n\t\t'track': 'src',\n\t\t'input': 'src', // but only if type=\"image\"\n\t\t'audio': 'src',\n\t\t'video': 'src'\n\t};\n\tURI.getDomAttribute = function(node) {\n\t\tif (!node || !node.nodeName) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tvar nodeName = node.nodeName.toLowerCase();\n\t\t// <input> should only expose src for type=\"image\"\n\t\tif (nodeName === 'input' && node.type !== 'image') {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn URI.domAttributes[nodeName];\n\t};\n\n\tfunction escapeForDumbFirefox36(value) {\n\t\t// https://github.com/medialize/URI.js/issues/91\n\t\treturn escape(value);\n\t}\n\n\t// encoding / decoding according to RFC3986\n\tfunction strictEncodeURIComponent(string) {\n\t\t// see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent\n\t\treturn encodeURIComponent(string)\n\t\t\t.replace(/[!'()*]/g, escapeForDumbFirefox36)\n\t\t\t.replace(/\\*/g, '%2A');\n\t}\n\tURI.encode = strictEncodeURIComponent;\n\tURI.decode = decodeURIComponent;\n\tURI.iso8859 = function() {\n\t\tURI.encode = escape;\n\t\tURI.decode = unescape;\n\t};\n\tURI.unicode = function() {\n\t\tURI.encode = strictEncodeURIComponent;\n\t\tURI.decode = decodeURIComponent;\n\t};\n\tURI.characters = {\n\t\tpathname: {\n\t\t\tencode: {\n\t\t\t\t// RFC3986 2.1: For consistency, URI producers and normalizers should\n\t\t\t\t// use uppercase hexadecimal digits for all percent-encodings.\n\t\t\t\texpression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t// -._~!'()*\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%26': '&',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '=',\n\t\t\t\t\t'%3A': ':',\n\t\t\t\t\t'%40': '@'\n\t\t\t\t}\n\t\t\t},\n\t\t\tdecode: {\n\t\t\t\texpression: /[\\/\\?#]/g,\n\t\t\t\tmap: {\n\t\t\t\t\t'/': '%2F',\n\t\t\t\t\t'?': '%3F',\n\t\t\t\t\t'#': '%23'\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\treserved: {\n\t\t\tencode: {\n\t\t\t\t// RFC3986 2.1: For consistency, URI producers and normalizers should\n\t\t\t\t// use uppercase hexadecimal digits for all percent-encodings.\n\t\t\t\texpression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t// gen-delims\n\t\t\t\t\t'%3A': ':',\n\t\t\t\t\t'%2F': '/',\n\t\t\t\t\t'%3F': '?',\n\t\t\t\t\t'%23': '#',\n\t\t\t\t\t'%5B': '[',\n\t\t\t\t\t'%5D': ']',\n\t\t\t\t\t'%40': '@',\n\t\t\t\t\t// sub-delims\n\t\t\t\t\t'%21': '!',\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%26': '&',\n\t\t\t\t\t'%27': '\\'',\n\t\t\t\t\t'%28': '(',\n\t\t\t\t\t'%29': ')',\n\t\t\t\t\t'%2A': '*',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '='\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\turnpath: {\n\t\t\t// The characters under `encode` are the characters called out by RFC 2141 as being acceptable\n\t\t\t// for usage in a URN. RFC2141 also calls out \"-\", \".\", and \"_\" as acceptable characters, but\n\t\t\t// these aren't encoded by encodeURIComponent, so we don't have to call them out here. Also\n\t\t\t// note that the colon character is not featured in the encoding map; this is because URI.js\n\t\t\t// gives the colons in URNs semantic meaning as the delimiters of path segements, and so it\n\t\t\t// should not appear unencoded in a segment itself.\n\t\t\t// See also the note above about RFC3986 and capitalalized hex digits.\n\t\t\tencode: {\n\t\t\t\texpression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t'%21': '!',\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%27': '\\'',\n\t\t\t\t\t'%28': '(',\n\t\t\t\t\t'%29': ')',\n\t\t\t\t\t'%2A': '*',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '=',\n\t\t\t\t\t'%40': '@'\n\t\t\t\t}\n\t\t\t},\n\t\t\t// These characters are the characters called out by RFC2141 as \"reserved\" characters that\n\t\t\t// should never appear in a URN, plus the colon character (see note above).\n\t\t\tdecode: {\n\t\t\t\texpression: /[\\/\\?#:]/g,\n\t\t\t\tmap: {\n\t\t\t\t\t'/': '%2F',\n\t\t\t\t\t'?': '%3F',\n\t\t\t\t\t'#': '%23',\n\t\t\t\t\t':': '%3A'\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\tURI.encodeQuery = function(string, escapeQuerySpace) {\n\t\tvar escaped = URI.encode(string + '');\n\t\tif (escapeQuerySpace === undefined) {\n\t\t\tescapeQuerySpace = URI.escapeQuerySpace;\n\t\t}\n\n\t\treturn escapeQuerySpace ? escaped.replace(/%20/g, '+') : escaped;\n\t};\n\tURI.decodeQuery = function(string, escapeQuerySpace) {\n\t\tstring += '';\n\t\tif (escapeQuerySpace === undefined) {\n\t\t\tescapeQuerySpace = URI.escapeQuerySpace;\n\t\t}\n\n\t\ttry {\n\t\t\treturn URI.decode(escapeQuerySpace ? string.replace(/\\+/g, '%20') : string);\n\t\t} catch(e) {\n\t\t\t// we're not going to mess with weird encodings,\n\t\t\t// give up and return the undecoded original string\n\t\t\t// see https://github.com/medialize/URI.js/issues/87\n\t\t\t// see https://github.com/medialize/URI.js/issues/92\n\t\t\treturn string;\n\t\t}\n\t};\n\t// generate encode/decode path functions\n\tvar _parts = {'encode':'encode', 'decode':'decode'};\n\tvar _part;\n\tvar generateAccessor = function(_group, _part) {\n\t\treturn function(string) {\n\t\t\ttry {\n\t\t\t\treturn URI[_part](string + '').replace(URI.characters[_group][_part].expression, function(c) {\n\t\t\t\t\treturn URI.characters[_group][_part].map[c];\n\t\t\t\t});\n\t\t\t} catch (e) {\n\t\t\t\t// we're not going to mess with weird encodings,\n\t\t\t\t// give up and return the undecoded original string\n\t\t\t\t// see https://github.com/medialize/URI.js/issues/87\n\t\t\t\t// see https://github.com/medialize/URI.js/issues/92\n\t\t\t\treturn string;\n\t\t\t}\n\t\t};\n\t};\n\n\tfor (_part in _parts) {\n\t\tURI[_part + 'PathSegment'] = generateAccessor('pathname', _parts[_part]);\n\t\tURI[_part + 'UrnPathSegment'] = generateAccessor('urnpath', _parts[_part]);\n\t}\n\n\tvar generateSegmentedPathFunction = function(_sep, _codingFuncName, _innerCodingFuncName) {\n\t\treturn function(string) {\n\t\t\t// Why pass in names of functions, rather than the function objects themselves? The\n\t\t\t// definitions of some functions (but in particular, URI.decode) will occasionally change due\n\t\t\t// to URI.js having ISO8859 and Unicode modes. Passing in the name and getting it will ensure\n\t\t\t// that the functions we use here are \"fresh\".\n\t\t\tvar actualCodingFunc;\n\t\t\tif (!_innerCodingFuncName) {\n\t\t\t\tactualCodingFunc = URI[_codingFuncName];\n\t\t\t} else {\n\t\t\t\tactualCodingFunc = function(string) {\n\t\t\t\t\treturn URI[_codingFuncName](URI[_innerCodingFuncName](string));\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tvar segments = (string + '').split(_sep);\n\n\t\t\tfor (var i = 0, length = segments.length; i < length; i++) {\n\t\t\t\tsegments[i] = actualCodingFunc(segments[i]);\n\t\t\t}\n\n\t\t\treturn segments.join(_sep);\n\t\t};\n\t};\n\n\t// This takes place outside the above loop because we don't want, e.g., encodeUrnPath functions.\n\tURI.decodePath = generateSegmentedPathFunction('/', 'decodePathSegment');\n\tURI.decodeUrnPath = generateSegmentedPathFunction(':', 'decodeUrnPathSegment');\n\tURI.recodePath = generateSegmentedPathFunction('/', 'encodePathSegment', 'decode');\n\tURI.recodeUrnPath = generateSegmentedPathFunction(':', 'encodeUrnPathSegment', 'decode');\n\n\tURI.encodeReserved = generateAccessor('reserved', 'encode');\n\n\tURI.parse = function(string, parts) {\n\t\tvar pos;\n\t\tif (!parts) {\n\t\t\tparts = {};\n\t\t}\n\t\t// [protocol\"://\"[username[\":\"password]\"@\"]hostname[\":\"port]\"/\"?][path][\"?\"querystring][\"#\"fragment]\n\n\t\t// extract fragment\n\t\tpos = string.indexOf('#');\n\t\tif (pos > -1) {\n\t\t\t// escaping?\n\t\t\tparts.fragment = string.substring(pos + 1) || null;\n\t\t\tstring = string.substring(0, pos);\n\t\t}\n\n\t\t// extract query\n\t\tpos = string.indexOf('?');\n\t\tif (pos > -1) {\n\t\t\t// escaping?\n\t\t\tparts.query = string.substring(pos + 1) || null;\n\t\t\tstring = string.substring(0, pos);\n\t\t}\n\n\t\t// extract protocol\n\t\tif (string.substring(0, 2) === '//') {\n\t\t\t// relative-scheme\n\t\t\tparts.protocol = null;\n\t\t\tstring = string.substring(2);\n\t\t\t// extract \"user:pass@host:port\"\n\t\t\tstring = URI.parseAuthority(string, parts);\n\t\t} else {\n\t\t\tpos = string.indexOf(':');\n\t\t\tif (pos > -1) {\n\t\t\t\tparts.protocol = string.substring(0, pos) || null;\n\t\t\t\tif (parts.protocol && !parts.protocol.match(URI.protocol_expression)) {\n\t\t\t\t\t// : may be within the path\n\t\t\t\t\tparts.protocol = undefined;\n\t\t\t\t} else if (string.substring(pos + 1, pos + 3) === '//') {\n\t\t\t\t\tstring = string.substring(pos + 3);\n\n\t\t\t\t\t// extract \"user:pass@host:port\"\n\t\t\t\t\tstring = URI.parseAuthority(string, parts);\n\t\t\t\t} else {\n\t\t\t\t\tstring = string.substring(pos + 1);\n\t\t\t\t\tparts.urn = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// what's left must be the path\n\t\tparts.path = string;\n\n\t\t// and we're done\n\t\treturn parts;\n\t};\n\tURI.parseHost = function(string, parts) {\n\t\t// Copy chrome, IE, opera backslash-handling behavior.\n\t\t// Back slashes before the query string get converted to forward slashes\n\t\t// See: https://github.com/joyent/node/blob/386fd24f49b0e9d1a8a076592a404168faeecc34/lib/url.js#L115-L124\n\t\t// See: https://code.google.com/p/chromium/issues/detail?id=25916\n\t\t// https://github.com/medialize/URI.js/pull/233\n\t\tstring = string.replace(/\\\\/g, '/');\n\n\t\t// extract host:port\n\t\tvar pos = string.indexOf('/');\n\t\tvar bracketPos;\n\t\tvar t;\n\n\t\tif (pos === -1) {\n\t\t\tpos = string.length;\n\t\t}\n\n\t\tif (string.charAt(0) === '[') {\n\t\t\t// IPv6 host - http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04#section-6\n\t\t\t// I claim most client software breaks on IPv6 anyways. To simplify things, URI only accepts\n\t\t\t// IPv6+port in the format [2001:db8::1]:80 (for the time being)\n\t\t\tbracketPos = string.indexOf(']');\n\t\t\tparts.hostname = string.substring(1, bracketPos) || null;\n\t\t\tparts.port = string.substring(bracketPos + 2, pos) || null;\n\t\t\tif (parts.port === '/') {\n\t\t\t\tparts.port = null;\n\t\t\t}\n\t\t} else {\n\t\t\tvar firstColon = string.indexOf(':');\n\t\t\tvar firstSlash = string.indexOf('/');\n\t\t\tvar nextColon = string.indexOf(':', firstColon + 1);\n\t\t\tif (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {\n\t\t\t\t// IPv6 host contains multiple colons - but no port\n\t\t\t\t// this notation is actually not allowed by RFC 3986, but we're a liberal parser\n\t\t\t\tparts.hostname = string.substring(0, pos) || null;\n\t\t\t\tparts.port = null;\n\t\t\t} else {\n\t\t\t\tt = string.substring(0, pos).split(':');\n\t\t\t\tparts.hostname = t[0] || null;\n\t\t\t\tparts.port = t[1] || null;\n\t\t\t}\n\t\t}\n\n\t\tif (parts.hostname && string.substring(pos).charAt(0) !== '/') {\n\t\t\tpos++;\n\t\t\tstring = '/' + string;\n\t\t}\n\n\t\treturn string.substring(pos) || '/';\n\t};\n\tURI.parseAuthority = function(string, parts) {\n\t\tstring = URI.parseUserinfo(string, parts);\n\t\treturn URI.parseHost(string, parts);\n\t};\n\tURI.parseUserinfo = function(string, parts) {\n\t\t// extract username:password\n\t\tvar firstSlash = string.indexOf('/');\n\t\tvar pos = string.lastIndexOf('@', firstSlash > -1 ? firstSlash : string.length - 1);\n\t\tvar t;\n\n\t\t// authority@ must come before /path\n\t\tif (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {\n\t\t\tt = string.substring(0, pos).split(':');\n\t\t\tparts.username = t[0] ? URI.decode(t[0]) : null;\n\t\t\tt.shift();\n\t\t\tparts.password = t[0] ? URI.decode(t.join(':')) : null;\n\t\t\tstring = string.substring(pos + 1);\n\t\t} else {\n\t\t\tparts.username = null;\n\t\t\tparts.password = null;\n\t\t}\n\n\t\treturn string;\n\t};\n\tURI.parseQuery = function(string, escapeQuerySpace) {\n\t\tif (!string) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// throw out the funky business - \"?\"[name\"=\"value\"&\"]+\n\t\tstring = string.replace(/&+/g, '&').replace(/^\\?*&*|&+$/g, '');\n\n\t\tif (!string) {\n\t\t\treturn {};\n\t\t}\n\n\t\tvar items = {};\n\t\tvar splits = string.split('&');\n\t\tvar length = splits.length;\n\t\tvar v, name, value;\n\n\t\tfor (var i = 0; i < length; i++) {\n\t\t\tv = splits[i].split('=');\n\t\t\tname = URI.decodeQuery(v.shift(), escapeQuerySpace);\n\t\t\t// no \"=\" is null according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#collect-url-parameters\n\t\t\tvalue = v.length ? URI.decodeQuery(v.join('='), escapeQuerySpace) : null;\n\n\t\t\tif (hasOwn.call(items, name)) {\n\t\t\t\tif (typeof items[name] === 'string' || items[name] === null) {\n\t\t\t\t\titems[name] = [items[name]];\n\t\t\t\t}\n\n\t\t\t\titems[name].push(value);\n\t\t\t} else {\n\t\t\t\titems[name] = value;\n\t\t\t}\n\t\t}\n\n\t\treturn items;\n\t};\n\n\tURI.build = function(parts) {\n\t\tvar t = '';\n\n\t\tif (parts.protocol) {\n\t\t\tt += parts.protocol + ':';\n\t\t}\n\n\t\tif (!parts.urn && (t || parts.hostname)) {\n\t\t\tt += '//';\n\t\t}\n\n\t\tt += (URI.buildAuthority(parts) || '');\n\n\t\tif (typeof parts.path === 'string') {\n\t\t\tif (parts.path.charAt(0) !== '/' && typeof parts.hostname === 'string') {\n\t\t\t\tt += '/';\n\t\t\t}\n\n\t\t\tt += parts.path;\n\t\t}\n\n\t\tif (typeof parts.query === 'string' && parts.query) {\n\t\t\tt += '?' + parts.query;\n\t\t}\n\n\t\tif (typeof parts.fragment === 'string' && parts.fragment) {\n\t\t\tt += '#' + parts.fragment;\n\t\t}\n\t\treturn t;\n\t};\n\tURI.buildHost = function(parts) {\n\t\tvar t = '';\n\n\t\tif (!parts.hostname) {\n\t\t\treturn '';\n\t\t} else if (URI.ip6_expression.test(parts.hostname)) {\n\t\t\tt += '[' + parts.hostname + ']';\n\t\t} else {\n\t\t\tt += parts.hostname;\n\t\t}\n\n\t\tif (parts.port) {\n\t\t\tt += ':' + parts.port;\n\t\t}\n\n\t\treturn t;\n\t};\n\tURI.buildAuthority = function(parts) {\n\t\treturn URI.buildUserinfo(parts) + URI.buildHost(parts);\n\t};\n\tURI.buildUserinfo = function(parts) {\n\t\tvar t = '';\n\n\t\tif (parts.username) {\n\t\t\tt += URI.encode(parts.username);\n\n\t\t\tif (parts.password) {\n\t\t\t\tt += ':' + URI.encode(parts.password);\n\t\t\t}\n\n\t\t\tt += '@';\n\t\t}\n\n\t\treturn t;\n\t};\n\tURI.buildQuery = function(data, duplicateQueryParameters, escapeQuerySpace) {\n\t\t// according to http://tools.ietf.org/html/rfc3986 or http://labs.apache.org/webarch/uri/rfc/rfc3986.html\n\t\t// being »-._~!$&'()*+,;=:@/?« %HEX and alnum are allowed\n\t\t// the RFC explicitly states ?/foo being a valid use case, no mention of parameter syntax!\n\t\t// URI.js treats the query string as being application/x-www-form-urlencoded\n\t\t// see http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type\n\n\t\tvar t = '';\n\t\tvar unique, key, i, length;\n\t\tfor (key in data) {\n\t\t\tif (hasOwn.call(data, key) && key) {\n\t\t\t\tif (isArray(data[key])) {\n\t\t\t\t\tunique = {};\n\t\t\t\t\tfor (i = 0, length = data[key].length; i < length; i++) {\n\t\t\t\t\t\tif (data[key][i] !== undefined && unique[data[key][i] + ''] === undefined) {\n\t\t\t\t\t\t\tt += '&' + URI.buildQueryParameter(key, data[key][i], escapeQuerySpace);\n\t\t\t\t\t\t\tif (duplicateQueryParameters !== true) {\n\t\t\t\t\t\t\t\tunique[data[key][i] + ''] = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (data[key] !== undefined) {\n\t\t\t\t\tt += '&' + URI.buildQueryParameter(key, data[key], escapeQuerySpace);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn t.substring(1);\n\t};\n\tURI.buildQueryParameter = function(name, value, escapeQuerySpace) {\n\t\t// http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type -- application/x-www-form-urlencoded\n\t\t// don't append \"=\" for null values, according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#url-parameter-serialization\n\t\treturn URI.encodeQuery(name, escapeQuerySpace) + (value !== null ? '=' + URI.encodeQuery(value, escapeQuerySpace) : '');\n\t};\n\n\tURI.addQuery = function(data, name, value) {\n\t\tif (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tURI.addQuery(data, key, name[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'string') {\n\t\t\tif (data[name] === undefined) {\n\t\t\t\tdata[name] = value;\n\t\t\t\treturn;\n\t\t\t} else if (typeof data[name] === 'string') {\n\t\t\t\tdata[name] = [data[name]];\n\t\t\t}\n\n\t\t\tif (!isArray(value)) {\n\t\t\t\tvalue = [value];\n\t\t\t}\n\n\t\t\tdata[name] = (data[name] || []).concat(value);\n\t\t} else {\n\t\t\tthrow new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n\t\t}\n\t};\n\tURI.removeQuery = function(data, name, value) {\n\t\tvar i, length, key;\n\n\t\tif (isArray(name)) {\n\t\t\tfor (i = 0, length = name.length; i < length; i++) {\n\t\t\t\tdata[name[i]] = undefined;\n\t\t\t}\n\t\t} else if (getType(name) === 'RegExp') {\n\t\t\tfor (key in data) {\n\t\t\t\tif (name.test(key)) {\n\t\t\t\t\tdata[key] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'object') {\n\t\t\tfor (key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tURI.removeQuery(data, key, name[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'string') {\n\t\t\tif (value !== undefined) {\n\t\t\t\tif (getType(value) === 'RegExp') {\n\t\t\t\t\tif (!isArray(data[name]) && value.test(data[name])) {\n\t\t\t\t\t\tdata[name] = undefined;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdata[name] = filterArrayValues(data[name], value);\n\t\t\t\t\t}\n\t\t\t\t} else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {\n\t\t\t\t\tdata[name] = undefined;\n\t\t\t\t} else if (isArray(data[name])) {\n\t\t\t\t\tdata[name] = filterArrayValues(data[name], value);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdata[name] = undefined;\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('URI.removeQuery() accepts an object, string, RegExp as the first parameter');\n\t\t}\n\t};\n\tURI.hasQuery = function(data, name, value, withinArray) {\n\t\tif (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tif (!URI.hasQuery(data, key, name[key])) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t} else if (typeof name !== 'string') {\n\t\t\tthrow new TypeError('URI.hasQuery() accepts an object, string as the name parameter');\n\t\t}\n\n\t\tswitch (getType(value)) {\n\t\t\tcase 'Undefined':\n\t\t\t\t// true if exists (but may be empty)\n\t\t\t\treturn name in data; // data[name] !== undefined;\n\n\t\t\tcase 'Boolean':\n\t\t\t\t// true if exists and non-empty\n\t\t\t\tvar _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);\n\t\t\t\treturn value === _booly;\n\n\t\t\tcase 'Function':\n\t\t\t\t// allow complex comparison\n\t\t\t\treturn !!value(data[name], name, data);\n\n\t\t\tcase 'Array':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tvar op = withinArray ? arrayContains : arraysEqual;\n\t\t\t\treturn op(data[name], value);\n\n\t\t\tcase 'RegExp':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn Boolean(data[name] && data[name].match(value));\n\t\t\t\t}\n\n\t\t\t\tif (!withinArray) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\treturn arrayContains(data[name], value);\n\n\t\t\tcase 'Number':\n\t\t\t\tvalue = String(value);\n\t\t\t/* falls through */\n\t\t\tcase 'String':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn data[name] === value;\n\t\t\t\t}\n\n\t\t\t\tif (!withinArray) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\treturn arrayContains(data[name], value);\n\n\t\t\tdefault:\n\t\t\t\tthrow new TypeError('URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter');\n\t\t}\n\t};\n\n\n\tURI.commonPath = function(one, two) {\n\t\tvar length = Math.min(one.length, two.length);\n\t\tvar pos;\n\n\t\t// find first non-matching character\n\t\tfor (pos = 0; pos < length; pos++) {\n\t\t\tif (one.charAt(pos) !== two.charAt(pos)) {\n\t\t\t\tpos--;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (pos < 1) {\n\t\t\treturn one.charAt(0) === two.charAt(0) && one.charAt(0) === '/' ? '/' : '';\n\t\t}\n\n\t\t// revert to last /\n\t\tif (one.charAt(pos) !== '/' || two.charAt(pos) !== '/') {\n\t\t\tpos = one.substring(0, pos).lastIndexOf('/');\n\t\t}\n\n\t\treturn one.substring(0, pos + 1);\n\t};\n\n\tURI.withinString = function(string, callback, options) {\n\t\toptions || (options = {});\n\t\tvar _start = options.start || URI.findUri.start;\n\t\tvar _end = options.end || URI.findUri.end;\n\t\tvar _trim = options.trim || URI.findUri.trim;\n\t\tvar _attributeOpen = /[a-z0-9-]=[\"']?$/i;\n\n\t\t_start.lastIndex = 0;\n\t\twhile (true) {\n\t\t\tvar match = _start.exec(string);\n\t\t\tif (!match) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar start = match.index;\n\t\t\tif (options.ignoreHtml) {\n\t\t\t\t// attribut(e=[\"']?$)\n\t\t\t\tvar attributeOpen = string.slice(Math.max(start - 3, 0), start);\n\t\t\t\tif (attributeOpen && _attributeOpen.test(attributeOpen)) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar end = start + string.slice(start).search(_end);\n\t\t\tvar slice = string.slice(start, end).replace(_trim, '');\n\t\t\tif (options.ignore && options.ignore.test(slice)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tend = start + slice.length;\n\t\t\tvar result = callback(slice, start, end, string);\n\t\t\tstring = string.slice(0, start) + result + string.slice(end);\n\t\t\t_start.lastIndex = start + result.length;\n\t\t}\n\n\t\t_start.lastIndex = 0;\n\t\treturn string;\n\t};\n\n\tURI.ensureValidHostname = function(v) {\n\t\t// Theoretically URIs allow percent-encoding in Hostnames (according to RFC 3986)\n\t\t// they are not part of DNS and therefore ignored by URI.js\n\n\t\tif (v.match(URI.invalid_hostname_characters)) {\n\t\t\t// test punycode\n\t\t\tif (!punycode) {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-] and Punycode.js is not available');\n\t\t\t}\n\n\t\t\tif (punycode.toASCII(v).match(URI.invalid_hostname_characters)) {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\t\t}\n\t};\n\n\t// noConflict\n\tURI.noConflict = function(removeAll) {\n\t\tif (removeAll) {\n\t\t\tvar unconflicted = {\n\t\t\t\tURI: this.noConflict()\n\t\t\t};\n\n\t\t\tif (root.URITemplate && typeof root.URITemplate.noConflict === 'function') {\n\t\t\t\tunconflicted.URITemplate = root.URITemplate.noConflict();\n\t\t\t}\n\n\t\t\tif (root.IPv6 && typeof root.IPv6.noConflict === 'function') {\n\t\t\t\tunconflicted.IPv6 = root.IPv6.noConflict();\n\t\t\t}\n\n\t\t\tif (root.SecondLevelDomains && typeof root.SecondLevelDomains.noConflict === 'function') {\n\t\t\t\tunconflicted.SecondLevelDomains = root.SecondLevelDomains.noConflict();\n\t\t\t}\n\n\t\t\treturn unconflicted;\n\t\t} else if (root.URI === this) {\n\t\t\troot.URI = _URI;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\tp.build = function(deferBuild) {\n\t\tif (deferBuild === true) {\n\t\t\tthis._deferred_build = true;\n\t\t} else if (deferBuild === undefined || this._deferred_build) {\n\t\t\tthis._string = URI.build(this._parts);\n\t\t\tthis._deferred_build = false;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\tp.clone = function() {\n\t\treturn new URI(this);\n\t};\n\n\tp.valueOf = p.toString = function() {\n\t\treturn this.build(false)._string;\n\t};\n\n\n\tfunction generateSimpleAccessor(_part){\n\t\treturn function(v, build) {\n\t\t\tif (v === undefined) {\n\t\t\t\treturn this._parts[_part] || '';\n\t\t\t} else {\n\t\t\t\tthis._parts[_part] = v || null;\n\t\t\t\tthis.build(!build);\n\t\t\t\treturn this;\n\t\t\t}\n\t\t};\n\t}\n\n\tfunction generatePrefixAccessor(_part, _key){\n\t\treturn function(v, build) {\n\t\t\tif (v === undefined) {\n\t\t\t\treturn this._parts[_part] || '';\n\t\t\t} else {\n\t\t\t\tif (v !== null) {\n\t\t\t\t\tv = v + '';\n\t\t\t\t\tif (v.charAt(0) === _key) {\n\t\t\t\t\t\tv = v.substring(1);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._parts[_part] = v;\n\t\t\t\tthis.build(!build);\n\t\t\t\treturn this;\n\t\t\t}\n\t\t};\n\t}\n\n\tp.protocol = generateSimpleAccessor('protocol');\n\tp.username = generateSimpleAccessor('username');\n\tp.password = generateSimpleAccessor('password');\n\tp.hostname = generateSimpleAccessor('hostname');\n\tp.port = generateSimpleAccessor('port');\n\tp.query = generatePrefixAccessor('query', '?');\n\tp.fragment = generatePrefixAccessor('fragment', '#');\n\n\tp.search = function(v, build) {\n\t\tvar t = this.query(v, build);\n\t\treturn typeof t === 'string' && t.length ? ('?' + t) : t;\n\t};\n\tp.hash = function(v, build) {\n\t\tvar t = this.fragment(v, build);\n\t\treturn typeof t === 'string' && t.length ? ('#' + t) : t;\n\t};\n\n\tp.pathname = function(v, build) {\n\t\tif (v === undefined || v === true) {\n\t\t\tvar res = this._parts.path || (this._parts.hostname ? '/' : '');\n\t\t\treturn v ? (this._parts.urn ? URI.decodeUrnPath : URI.decodePath)(res) : res;\n\t\t} else {\n\t\t\tif (this._parts.urn) {\n\t\t\t\tthis._parts.path = v ? URI.recodeUrnPath(v) : '';\n\t\t\t} else {\n\t\t\t\tthis._parts.path = v ? URI.recodePath(v) : '/';\n\t\t\t}\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.path = p.pathname;\n\tp.href = function(href, build) {\n\t\tvar key;\n\n\t\tif (href === undefined) {\n\t\t\treturn this.toString();\n\t\t}\n\n\t\tthis._string = '';\n\t\tthis._parts = URI._parts();\n\n\t\tvar _URI = href instanceof URI;\n\t\tvar _object = typeof href === 'object' && (href.hostname || href.path || href.pathname);\n\t\tif (href.nodeName) {\n\t\t\tvar attribute = URI.getDomAttribute(href);\n\t\t\thref = href[attribute] || '';\n\t\t\t_object = false;\n\t\t}\n\n\t\t// window.location is reported to be an object, but it's not the sort\n\t\t// of object we're looking for:\n\t\t// * location.protocol ends with a colon\n\t\t// * location.query != object.search\n\t\t// * location.hash != object.fragment\n\t\t// simply serializing the unknown object should do the trick\n\t\t// (for location, not for everything...)\n\t\tif (!_URI && _object && href.pathname !== undefined) {\n\t\t\thref = href.toString();\n\t\t}\n\n\t\tif (typeof href === 'string' || href instanceof String) {\n\t\t\tthis._parts = URI.parse(String(href), this._parts);\n\t\t} else if (_URI || _object) {\n\t\t\tvar src = _URI ? href._parts : href;\n\t\t\tfor (key in src) {\n\t\t\t\tif (hasOwn.call(this._parts, key)) {\n\t\t\t\t\tthis._parts[key] = src[key];\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('invalid input');\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\n\t// identification accessors\n\tp.is = function(what) {\n\t\tvar ip = false;\n\t\tvar ip4 = false;\n\t\tvar ip6 = false;\n\t\tvar name = false;\n\t\tvar sld = false;\n\t\tvar idn = false;\n\t\tvar punycode = false;\n\t\tvar relative = !this._parts.urn;\n\n\t\tif (this._parts.hostname) {\n\t\t\trelative = false;\n\t\t\tip4 = URI.ip4_expression.test(this._parts.hostname);\n\t\t\tip6 = URI.ip6_expression.test(this._parts.hostname);\n\t\t\tip = ip4 || ip6;\n\t\t\tname = !ip;\n\t\t\tsld = name && SLD && SLD.has(this._parts.hostname);\n\t\t\tidn = name && URI.idn_expression.test(this._parts.hostname);\n\t\t\tpunycode = name && URI.punycode_expression.test(this._parts.hostname);\n\t\t}\n\n\t\tswitch (what.toLowerCase()) {\n\t\t\tcase 'relative':\n\t\t\t\treturn relative;\n\n\t\t\tcase 'absolute':\n\t\t\t\treturn !relative;\n\n\t\t\t// hostname identification\n\t\t\tcase 'domain':\n\t\t\tcase 'name':\n\t\t\t\treturn name;\n\n\t\t\tcase 'sld':\n\t\t\t\treturn sld;\n\n\t\t\tcase 'ip':\n\t\t\t\treturn ip;\n\n\t\t\tcase 'ip4':\n\t\t\tcase 'ipv4':\n\t\t\tcase 'inet4':\n\t\t\t\treturn ip4;\n\n\t\t\tcase 'ip6':\n\t\t\tcase 'ipv6':\n\t\t\tcase 'inet6':\n\t\t\t\treturn ip6;\n\n\t\t\tcase 'idn':\n\t\t\t\treturn idn;\n\n\t\t\tcase 'url':\n\t\t\t\treturn !this._parts.urn;\n\n\t\t\tcase 'urn':\n\t\t\t\treturn !!this._parts.urn;\n\n\t\t\tcase 'punycode':\n\t\t\t\treturn punycode;\n\t\t}\n\n\t\treturn null;\n\t};\n\n\t// component specific input validation\n\tvar _protocol = p.protocol;\n\tvar _port = p.port;\n\tvar _hostname = p.hostname;\n\n\tp.protocol = function(v, build) {\n\t\tif (v !== undefined) {\n\t\t\tif (v) {\n\t\t\t\t// accept trailing ://\n\t\t\t\tv = v.replace(/:(\\/\\/)?$/, '');\n\n\t\t\t\tif (!v.match(URI.protocol_expression)) {\n\t\t\t\t\tthrow new TypeError('Protocol \"' + v + '\" contains characters other than [A-Z0-9.+-] or doesn\\'t start with [A-Z]');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn _protocol.call(this, v, build);\n\t};\n\tp.scheme = p.protocol;\n\tp.port = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v !== undefined) {\n\t\t\tif (v === 0) {\n\t\t\t\tv = null;\n\t\t\t}\n\n\t\t\tif (v) {\n\t\t\t\tv += '';\n\t\t\t\tif (v.charAt(0) === ':') {\n\t\t\t\t\tv = v.substring(1);\n\t\t\t\t}\n\n\t\t\t\tif (v.match(/[^0-9]/)) {\n\t\t\t\t\tthrow new TypeError('Port \"' + v + '\" contains characters other than [0-9]');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn _port.call(this, v, build);\n\t};\n\tp.hostname = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v !== undefined) {\n\t\t\tvar x = {};\n\t\t\tvar res = URI.parseHost(v, x);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tv = x.hostname;\n\t\t}\n\t\treturn _hostname.call(this, v, build);\n\t};\n\n\t// compound accessors\n\tp.origin = function(v, build) {\n\t\tvar parts;\n\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tvar protocol = this.protocol();\n\t\t\tvar authority = this.authority();\n\t\t\tif (!authority) return '';\n\t\t\treturn (protocol ? protocol + '://' : '') + this.authority();\n\t\t} else {\n\t\t\tvar origin = URI(v);\n\t\t\tthis\n\t\t\t\t.protocol(origin.protocol())\n\t\t\t\t.authority(origin.authority())\n\t\t\t\t.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.host = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\treturn this._parts.hostname ? URI.buildHost(this._parts) : '';\n\t\t} else {\n\t\t\tvar res = URI.parseHost(v, this._parts);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.authority = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\treturn this._parts.hostname ? URI.buildAuthority(this._parts) : '';\n\t\t} else {\n\t\t\tvar res = URI.parseAuthority(v, this._parts);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.userinfo = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.username) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar t = URI.buildUserinfo(this._parts);\n\t\t\treturn t.substring(0, t.length -1);\n\t\t} else {\n\t\t\tif (v[v.length-1] !== '@') {\n\t\t\t\tv += '@';\n\t\t\t}\n\n\t\t\tURI.parseUserinfo(v, this._parts);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.resource = function(v, build) {\n\t\tvar parts;\n\n\t\tif (v === undefined) {\n\t\t\treturn this.path() + this.search() + this.hash();\n\t\t}\n\n\t\tparts = URI.parse(v);\n\t\tthis._parts.path = parts.path;\n\t\tthis._parts.query = parts.query;\n\t\tthis._parts.fragment = parts.fragment;\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\n\t// fraction accessors\n\tp.subdomain = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\t// convenience, return \"www\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// grab domain and add another segment\n\t\t\tvar end = this._parts.hostname.length - this.domain().length - 1;\n\t\t\treturn this._parts.hostname.substring(0, end) || '';\n\t\t} else {\n\t\t\tvar e = this._parts.hostname.length - this.domain().length;\n\t\t\tvar sub = this._parts.hostname.substring(0, e);\n\t\t\tvar replace = new RegExp('^' + escapeRegEx(sub));\n\n\t\t\tif (v && v.charAt(v.length - 1) !== '.') {\n\t\t\t\tv += '.';\n\t\t\t}\n\n\t\t\tif (v) {\n\t\t\t\tURI.ensureValidHostname(v);\n\t\t\t}\n\n\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.domain = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (typeof v === 'boolean') {\n\t\t\tbuild = v;\n\t\t\tv = undefined;\n\t\t}\n\n\t\t// convenience, return \"example.org\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// if hostname consists of 1 or 2 segments, it must be the domain\n\t\t\tvar t = this._parts.hostname.match(/\\./g);\n\t\t\tif (t && t.length < 2) {\n\t\t\t\treturn this._parts.hostname;\n\t\t\t}\n\n\t\t\t// grab tld and add another segment\n\t\t\tvar end = this._parts.hostname.length - this.tld(build).length - 1;\n\t\t\tend = this._parts.hostname.lastIndexOf('.', end -1) + 1;\n\t\t\treturn this._parts.hostname.substring(end) || '';\n\t\t} else {\n\t\t\tif (!v) {\n\t\t\t\tthrow new TypeError('cannot set domain empty');\n\t\t\t}\n\n\t\t\tURI.ensureValidHostname(v);\n\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\tthis._parts.hostname = v;\n\t\t\t} else {\n\t\t\t\tvar replace = new RegExp(escapeRegEx(this.domain()) + '$');\n\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.tld = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (typeof v === 'boolean') {\n\t\t\tbuild = v;\n\t\t\tv = undefined;\n\t\t}\n\n\t\t// return \"org\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar pos = this._parts.hostname.lastIndexOf('.');\n\t\t\tvar tld = this._parts.hostname.substring(pos + 1);\n\n\t\t\tif (build !== true && SLD && SLD.list[tld.toLowerCase()]) {\n\t\t\t\treturn SLD.get(this._parts.hostname) || tld;\n\t\t\t}\n\n\t\t\treturn tld;\n\t\t} else {\n\t\t\tvar replace;\n\n\t\t\tif (!v) {\n\t\t\t\tthrow new TypeError('cannot set TLD empty');\n\t\t\t} else if (v.match(/[^a-zA-Z0-9-]/)) {\n\t\t\t\tif (SLD && SLD.is(v)) {\n\t\t\t\t\treplace = new RegExp(escapeRegEx(this.tld()) + '$');\n\t\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t\t} else {\n\t\t\t\t\tthrow new TypeError('TLD \"' + v + '\" contains characters other than [A-Z0-9]');\n\t\t\t\t}\n\t\t\t} else if (!this._parts.hostname || this.is('IP')) {\n\t\t\t\tthrow new ReferenceError('cannot set TLD on non-domain host');\n\t\t\t} else {\n\t\t\t\treplace = new RegExp(escapeRegEx(this.tld()) + '$');\n\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.directory = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path && !this._parts.hostname) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tif (this._parts.path === '/') {\n\t\t\t\treturn '/';\n\t\t\t}\n\n\t\t\tvar end = this._parts.path.length - this.filename().length - 1;\n\t\t\tvar res = this._parts.path.substring(0, end) || (this._parts.hostname ? '/' : '');\n\n\t\t\treturn v ? URI.decodePath(res) : res;\n\n\t\t} else {\n\t\t\tvar e = this._parts.path.length - this.filename().length;\n\t\t\tvar directory = this._parts.path.substring(0, e);\n\t\t\tvar replace = new RegExp('^' + escapeRegEx(directory));\n\n\t\t\t// fully qualifier directories begin with a slash\n\t\t\tif (!this.is('relative')) {\n\t\t\t\tif (!v) {\n\t\t\t\t\tv = '/';\n\t\t\t\t}\n\n\t\t\t\tif (v.charAt(0) !== '/') {\n\t\t\t\t\tv = '/' + v;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// directories always end with a slash\n\t\t\tif (v && v.charAt(v.length - 1) !== '/') {\n\t\t\t\tv += '/';\n\t\t\t}\n\n\t\t\tv = URI.recodePath(v);\n\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.filename = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path || this._parts.path === '/') {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar pos = this._parts.path.lastIndexOf('/');\n\t\t\tvar res = this._parts.path.substring(pos+1);\n\n\t\t\treturn v ? URI.decodePathSegment(res) : res;\n\t\t} else {\n\t\t\tvar mutatedDirectory = false;\n\n\t\t\tif (v.charAt(0) === '/') {\n\t\t\t\tv = v.substring(1);\n\t\t\t}\n\n\t\t\tif (v.match(/\\.?\\//)) {\n\t\t\t\tmutatedDirectory = true;\n\t\t\t}\n\n\t\t\tvar replace = new RegExp(escapeRegEx(this.filename()) + '$');\n\t\t\tv = URI.recodePath(v);\n\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\n\t\t\tif (mutatedDirectory) {\n\t\t\t\tthis.normalizePath(build);\n\t\t\t} else {\n\t\t\t\tthis.build(!build);\n\t\t\t}\n\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.suffix = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path || this._parts.path === '/') {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar filename = this.filename();\n\t\t\tvar pos = filename.lastIndexOf('.');\n\t\t\tvar s, res;\n\n\t\t\tif (pos === -1) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// suffix may only contain alnum characters (yup, I made this up.)\n\t\t\ts = filename.substring(pos+1);\n\t\t\tres = (/^[a-z0-9%]+$/i).test(s) ? s : '';\n\t\t\treturn v ? URI.decodePathSegment(res) : res;\n\t\t} else {\n\t\t\tif (v.charAt(0) === '.') {\n\t\t\t\tv = v.substring(1);\n\t\t\t}\n\n\t\t\tvar suffix = this.suffix();\n\t\t\tvar replace;\n\n\t\t\tif (!suffix) {\n\t\t\t\tif (!v) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t\tthis._parts.path += '.' + URI.recodePath(v);\n\t\t\t} else if (!v) {\n\t\t\t\treplace = new RegExp(escapeRegEx('.' + suffix) + '$');\n\t\t\t} else {\n\t\t\t\treplace = new RegExp(escapeRegEx(suffix) + '$');\n\t\t\t}\n\n\t\t\tif (replace) {\n\t\t\t\tv = URI.recodePath(v);\n\t\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.segment = function(segment, v, build) {\n\t\tvar separator = this._parts.urn ? ':' : '/';\n\t\tvar path = this.path();\n\t\tvar absolute = path.substring(0, 1) === '/';\n\t\tvar segments = path.split(separator);\n\n\t\tif (segment !== undefined && typeof segment !== 'number') {\n\t\t\tbuild = v;\n\t\t\tv = segment;\n\t\t\tsegment = undefined;\n\t\t}\n\n\t\tif (segment !== undefined && typeof segment !== 'number') {\n\t\t\tthrow new Error('Bad segment \"' + segment + '\", must be 0-based integer');\n\t\t}\n\n\t\tif (absolute) {\n\t\t\tsegments.shift();\n\t\t}\n\n\t\tif (segment < 0) {\n\t\t\t// allow negative indexes to address from the end\n\t\t\tsegment = Math.max(segments.length + segment, 0);\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\t/*jshint laxbreak: true */\n\t\t\treturn segment === undefined\n\t\t\t\t? segments\n\t\t\t\t: segments[segment];\n\t\t\t/*jshint laxbreak: false */\n\t\t} else if (segment === null || segments[segment] === undefined) {\n\t\t\tif (isArray(v)) {\n\t\t\t\tsegments = [];\n\t\t\t\t// collapse empty elements within array\n\t\t\t\tfor (var i=0, l=v.length; i < l; i++) {\n\t\t\t\t\tif (!v[i].length && (!segments.length || !segments[segments.length -1].length)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (segments.length && !segments[segments.length -1].length) {\n\t\t\t\t\t\tsegments.pop();\n\t\t\t\t\t}\n\n\t\t\t\t\tsegments.push(trimSlashes(v[i]));\n\t\t\t\t}\n\t\t\t} else if (v || typeof v === 'string') {\n\t\t\t\tv = trimSlashes(v);\n\t\t\t\tif (segments[segments.length -1] === '') {\n\t\t\t\t\t// empty trailing elements have to be overwritten\n\t\t\t\t\t// to prevent results such as /foo//bar\n\t\t\t\t\tsegments[segments.length -1] = v;\n\t\t\t\t} else {\n\t\t\t\t\tsegments.push(v);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (v) {\n\t\t\t\tsegments[segment] = trimSlashes(v);\n\t\t\t} else {\n\t\t\t\tsegments.splice(segment, 1);\n\t\t\t}\n\t\t}\n\n\t\tif (absolute) {\n\t\t\tsegments.unshift('');\n\t\t}\n\n\t\treturn this.path(segments.join(separator), build);\n\t};\n\tp.segmentCoded = function(segment, v, build) {\n\t\tvar segments, i, l;\n\n\t\tif (typeof segment !== 'number') {\n\t\t\tbuild = v;\n\t\t\tv = segment;\n\t\t\tsegment = undefined;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tsegments = this.segment(segment, v, build);\n\t\t\tif (!isArray(segments)) {\n\t\t\t\tsegments = segments !== undefined ? URI.decode(segments) : undefined;\n\t\t\t} else {\n\t\t\t\tfor (i = 0, l = segments.length; i < l; i++) {\n\t\t\t\t\tsegments[i] = URI.decode(segments[i]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn segments;\n\t\t}\n\n\t\tif (!isArray(v)) {\n\t\t\tv = (typeof v === 'string' || v instanceof String) ? URI.encode(v) : v;\n\t\t} else {\n\t\t\tfor (i = 0, l = v.length; i < l; i++) {\n\t\t\t\tv[i] = URI.encode(v[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn this.segment(segment, v, build);\n\t};\n\n\t// mutating query string\n\tvar q = p.query;\n\tp.query = function(v, build) {\n\t\tif (v === true) {\n\t\t\treturn URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\t} else if (typeof v === 'function') {\n\t\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\t\tvar result = v.call(this, data);\n\t\t\tthis._parts.query = URI.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t} else if (v !== undefined && typeof v !== 'string') {\n\t\t\tthis._parts.query = URI.buildQuery(v, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn q.call(this, v, build);\n\t\t}\n\t};\n\tp.setQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\n\t\tif (typeof name === 'string' || name instanceof String) {\n\t\t\tdata[name] = value !== undefined ? value : null;\n\t\t} else if (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tdata[key] = name[key];\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n\t\t}\n\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.addQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\tURI.addQuery(data, name, value === undefined ? null : value);\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.removeQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\tURI.removeQuery(data, name, value);\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.hasQuery = function(name, value, withinArray) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\treturn URI.hasQuery(data, name, value, withinArray);\n\t};\n\tp.setSearch = p.setQuery;\n\tp.addSearch = p.addQuery;\n\tp.removeSearch = p.removeQuery;\n\tp.hasSearch = p.hasQuery;\n\n\t// sanitizing URLs\n\tp.normalize = function() {\n\t\tif (this._parts.urn) {\n\t\t\treturn this\n\t\t\t\t.normalizeProtocol(false)\n\t\t\t\t.normalizePath(false)\n\t\t\t\t.normalizeQuery(false)\n\t\t\t\t.normalizeFragment(false)\n\t\t\t\t.build();\n\t\t}\n\n\t\treturn this\n\t\t\t.normalizeProtocol(false)\n\t\t\t.normalizeHostname(false)\n\t\t\t.normalizePort(false)\n\t\t\t.normalizePath(false)\n\t\t\t.normalizeQuery(false)\n\t\t\t.normalizeFragment(false)\n\t\t\t.build();\n\t};\n\tp.normalizeProtocol = function(build) {\n\t\tif (typeof this._parts.protocol === 'string') {\n\t\t\tthis._parts.protocol = this._parts.protocol.toLowerCase();\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeHostname = function(build) {\n\t\tif (this._parts.hostname) {\n\t\t\tif (this.is('IDN') && punycode) {\n\t\t\t\tthis._parts.hostname = punycode.toASCII(this._parts.hostname);\n\t\t\t} else if (this.is('IPv6') && IPv6) {\n\t\t\t\tthis._parts.hostname = IPv6.best(this._parts.hostname);\n\t\t\t}\n\n\t\t\tthis._parts.hostname = this._parts.hostname.toLowerCase();\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizePort = function(build) {\n\t\t// remove port of it's the protocol's default\n\t\tif (typeof this._parts.protocol === 'string' && this._parts.port === URI.defaultPorts[this._parts.protocol]) {\n\t\t\tthis._parts.port = null;\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizePath = function(build) {\n\t\tvar _path = this._parts.path;\n\t\tif (!_path) {\n\t\t\treturn this;\n\t\t}\n\n\t\tif (this._parts.urn) {\n\t\t\tthis._parts.path = URI.recodeUrnPath(this._parts.path);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\n\t\tif (this._parts.path === '/') {\n\t\t\treturn this;\n\t\t}\n\n\t\tvar _was_relative;\n\t\tvar _leadingParents = '';\n\t\tvar _parent, _pos;\n\n\t\t// handle relative paths\n\t\tif (_path.charAt(0) !== '/') {\n\t\t\t_was_relative = true;\n\t\t\t_path = '/' + _path;\n\t\t}\n\n\t\t// handle relative files (as opposed to directories)\n\t\tif (_path.slice(-3) === '/..' || _path.slice(-2) === '/.') {\n\t\t\t_path += '/';\n\t\t}\n\n\t\t// resolve simples\n\t\t_path = _path\n\t\t\t.replace(/(\\/(\\.\\/)+)|(\\/\\.$)/g, '/')\n\t\t\t.replace(/\\/{2,}/g, '/');\n\n\t\t// remember leading parents\n\t\tif (_was_relative) {\n\t\t\t_leadingParents = _path.substring(1).match(/^(\\.\\.\\/)+/) || '';\n\t\t\tif (_leadingParents) {\n\t\t\t\t_leadingParents = _leadingParents[0];\n\t\t\t}\n\t\t}\n\n\t\t// resolve parents\n\t\twhile (true) {\n\t\t\t_parent = _path.indexOf('/..');\n\t\t\tif (_parent === -1) {\n\t\t\t\t// no more ../ to resolve\n\t\t\t\tbreak;\n\t\t\t} else if (_parent === 0) {\n\t\t\t\t// top level cannot be relative, skip it\n\t\t\t\t_path = _path.substring(3);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t_pos = _path.substring(0, _parent).lastIndexOf('/');\n\t\t\tif (_pos === -1) {\n\t\t\t\t_pos = _parent;\n\t\t\t}\n\t\t\t_path = _path.substring(0, _pos) + _path.substring(_parent + 3);\n\t\t}\n\n\t\t// revert to relative\n\t\tif (_was_relative && this.is('relative')) {\n\t\t\t_path = _leadingParents + _path.substring(1);\n\t\t}\n\n\t\t_path = URI.recodePath(_path);\n\t\tthis._parts.path = _path;\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.normalizePathname = p.normalizePath;\n\tp.normalizeQuery = function(build) {\n\t\tif (typeof this._parts.query === 'string') {\n\t\t\tif (!this._parts.query.length) {\n\t\t\t\tthis._parts.query = null;\n\t\t\t} else {\n\t\t\t\tthis.query(URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace));\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeFragment = function(build) {\n\t\tif (!this._parts.fragment) {\n\t\t\tthis._parts.fragment = null;\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeSearch = p.normalizeQuery;\n\tp.normalizeHash = p.normalizeFragment;\n\n\tp.iso8859 = function() {\n\t\t// expect unicode input, iso8859 output\n\t\tvar e = URI.encode;\n\t\tvar d = URI.decode;\n\n\t\tURI.encode = escape;\n\t\tURI.decode = decodeURIComponent;\n\t\ttry {\n\t\t\tthis.normalize();\n\t\t} finally {\n\t\t\tURI.encode = e;\n\t\t\tURI.decode = d;\n\t\t}\n\t\treturn this;\n\t};\n\n\tp.unicode = function() {\n\t\t// expect iso8859 input, unicode output\n\t\tvar e = URI.encode;\n\t\tvar d = URI.decode;\n\n\t\tURI.encode = strictEncodeURIComponent;\n\t\tURI.decode = unescape;\n\t\ttry {\n\t\t\tthis.normalize();\n\t\t} finally {\n\t\t\tURI.encode = e;\n\t\t\tURI.decode = d;\n\t\t}\n\t\treturn this;\n\t};\n\n\tp.readable = function() {\n\t\tvar uri = this.clone();\n\t\t// removing username, password, because they shouldn't be displayed according to RFC 3986\n\t\turi.username('').password('').normalize();\n\t\tvar t = '';\n\t\tif (uri._parts.protocol) {\n\t\t\tt += uri._parts.protocol + '://';\n\t\t}\n\n\t\tif (uri._parts.hostname) {\n\t\t\tif (uri.is('punycode') && punycode) {\n\t\t\t\tt += punycode.toUnicode(uri._parts.hostname);\n\t\t\t\tif (uri._parts.port) {\n\t\t\t\t\tt += ':' + uri._parts.port;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tt += uri.host();\n\t\t\t}\n\t\t}\n\n\t\tif (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== '/') {\n\t\t\tt += '/';\n\t\t}\n\n\t\tt += uri.path(true);\n\t\tif (uri._parts.query) {\n\t\t\tvar q = '';\n\t\t\tfor (var i = 0, qp = uri._parts.query.split('&'), l = qp.length; i < l; i++) {\n\t\t\t\tvar kv = (qp[i] || '').split('=');\n\t\t\t\tq += '&' + URI.decodeQuery(kv[0], this._parts.escapeQuerySpace)\n\t\t\t\t\t.replace(/&/g, '%26');\n\n\t\t\t\tif (kv[1] !== undefined) {\n\t\t\t\t\tq += '=' + URI.decodeQuery(kv[1], this._parts.escapeQuerySpace)\n\t\t\t\t\t\t.replace(/&/g, '%26');\n\t\t\t\t}\n\t\t\t}\n\t\t\tt += '?' + q.substring(1);\n\t\t}\n\n\t\tt += URI.decodeQuery(uri.hash(), true);\n\t\treturn t;\n\t};\n\n\t// resolving relative and absolute URLs\n\tp.absoluteTo = function(base) {\n\t\tvar resolved = this.clone();\n\t\tvar properties = ['protocol', 'username', 'password', 'hostname', 'port'];\n\t\tvar basedir, i, p;\n\n\t\tif (this._parts.urn) {\n\t\t\tthrow new Error('URNs do not have any generally defined hierarchical components');\n\t\t}\n\n\t\tif (!(base instanceof URI)) {\n\t\t\tbase = new URI(base);\n\t\t}\n\n\t\tif (!resolved._parts.protocol) {\n\t\t\tresolved._parts.protocol = base._parts.protocol;\n\t\t}\n\n\t\tif (this._parts.hostname) {\n\t\t\treturn resolved;\n\t\t}\n\n\t\tfor (i = 0; (p = properties[i]); i++) {\n\t\t\tresolved._parts[p] = base._parts[p];\n\t\t}\n\n\t\tif (!resolved._parts.path) {\n\t\t\tresolved._parts.path = base._parts.path;\n\t\t\tif (!resolved._parts.query) {\n\t\t\t\tresolved._parts.query = base._parts.query;\n\t\t\t}\n\t\t} else if (resolved._parts.path.substring(-2) === '..') {\n\t\t\tresolved._parts.path += '/';\n\t\t}\n\n\t\tif (resolved.path().charAt(0) !== '/') {\n\t\t\tbasedir = base.directory();\n\t\t\tbasedir = basedir ? basedir : base.path().indexOf('/') === 0 ? '/' : '';\n\t\t\tresolved._parts.path = (basedir ? (basedir + '/') : '') + resolved._parts.path;\n\t\t\tresolved.normalizePath();\n\t\t}\n\n\t\tresolved.build();\n\t\treturn resolved;\n\t};\n\tp.relativeTo = function(base) {\n\t\tvar relative = this.clone().normalize();\n\t\tvar relativeParts, baseParts, common, relativePath, basePath;\n\n\t\tif (relative._parts.urn) {\n\t\t\tthrow new Error('URNs do not have any generally defined hierarchical components');\n\t\t}\n\n\t\tbase = new URI(base).normalize();\n\t\trelativeParts = relative._parts;\n\t\tbaseParts = base._parts;\n\t\trelativePath = relative.path();\n\t\tbasePath = base.path();\n\n\t\tif (relativePath.charAt(0) !== '/') {\n\t\t\tthrow new Error('URI is already relative');\n\t\t}\n\n\t\tif (basePath.charAt(0) !== '/') {\n\t\t\tthrow new Error('Cannot calculate a URI relative to another relative URI');\n\t\t}\n\n\t\tif (relativeParts.protocol === baseParts.protocol) {\n\t\t\trelativeParts.protocol = null;\n\t\t}\n\n\t\tif (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {\n\t\t\trelativeParts.hostname = null;\n\t\t\trelativeParts.port = null;\n\t\t} else {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativePath === basePath) {\n\t\t\trelativeParts.path = '';\n\t\t\treturn relative.build();\n\t\t}\n\n\t\t// determine common sub path\n\t\tcommon = URI.commonPath(relativePath, basePath);\n\n\t\t// If the paths have nothing in common, return a relative URL with the absolute path.\n\t\tif (!common) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tvar parents = baseParts.path\n\t\t\t.substring(common.length)\n\t\t\t.replace(/[^\\/]*$/, '')\n\t\t\t.replace(/.*?\\//g, '../');\n\n\t\trelativeParts.path = (parents + relativeParts.path.substring(common.length)) || './';\n\n\t\treturn relative.build();\n\t};\n\n\t// comparing URIs\n\tp.equals = function(uri) {\n\t\tvar one = this.clone();\n\t\tvar two = new URI(uri);\n\t\tvar one_map = {};\n\t\tvar two_map = {};\n\t\tvar checked = {};\n\t\tvar one_query, two_query, key;\n\n\t\tone.normalize();\n\t\ttwo.normalize();\n\n\t\t// exact match\n\t\tif (one.toString() === two.toString()) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// extract query string\n\t\tone_query = one.query();\n\t\ttwo_query = two.query();\n\t\tone.query('');\n\t\ttwo.query('');\n\n\t\t// definitely not equal if not even non-query parts match\n\t\tif (one.toString() !== two.toString()) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// query parameters have the same length, even if they're permuted\n\t\tif (one_query.length !== two_query.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tone_map = URI.parseQuery(one_query, this._parts.escapeQuerySpace);\n\t\ttwo_map = URI.parseQuery(two_query, this._parts.escapeQuerySpace);\n\n\t\tfor (key in one_map) {\n\t\t\tif (hasOwn.call(one_map, key)) {\n\t\t\t\tif (!isArray(one_map[key])) {\n\t\t\t\t\tif (one_map[key] !== two_map[key]) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t} else if (!arraysEqual(one_map[key], two_map[key])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tchecked[key] = true;\n\t\t\t}\n\t\t}\n\n\t\tfor (key in two_map) {\n\t\t\tif (hasOwn.call(two_map, key)) {\n\t\t\t\tif (!checked[key]) {\n\t\t\t\t\t// two contains a parameter not present in one\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t};\n\n\t// state\n\tp.duplicateQueryParameters = function(v) {\n\t\tthis._parts.duplicateQueryParameters = !!v;\n\t\treturn this;\n\t};\n\n\tp.escapeQuerySpace = function(v) {\n\t\tthis._parts.escapeQuerySpace = !!v;\n\t\treturn this;\n\t};\n\n\treturn URI;\n}));","Workflow = {}\n\n@ImageSign = {};\n\n@TracesHandler = {};\n\n@TracesTemplate = {};\n\n@InstanceformTemplate = {};\n\n@InstanceAttachmentTemplate = {};\n\n@InstanceSignText = {}\n\n@RelatedInstances = {}\n\n@RelatedRecords = {}\n\n@InstanceMacro = {context: {}}\n\n@TracesManager = {};\n\nInstanceSignText.isOpinionField_from_string = (field_formula)->\n\treturn (field_formula?.indexOf(\"{traces.\") > -1 || field_formula?.indexOf(\"{signature.traces.\") > -1 || field_formula?.indexOf(\"{yijianlan:\") > -1 || field_formula?.indexOf(\"{\\\"yijianlan\\\":\") > -1 || field_formula?.indexOf(\"{'yijianlan':\") > -1)\n\nInstanceSignText.includesOpinionField = (form, form_version)->\n\tfield_formulas = new Array();\n\n\t_form_version = {}\n\n\tif Meteor.isServer\n\t\t_form_version = uuflowManager.getFormVersion(db.forms.findOne({_id: form}), form_version)\n\telse\n\t\t_form_version = db.form_versions.findOne({_id: form_version, form: form})\n\n\tfields = _form_version?.fields || []\n\n\tfields.forEach (f)->\n\t\tif f.type == 'table'\n\t\t\tconsole.log 'ignore opinion field in table'\n\t\telse if f.type == 'section'\n\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\tfield_formulas.push f1.formula\n\t\telse\n\t\t\tfield_formulas.push f.formula\n\n\t_.some field_formulas, (field_formula)->\n\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\n","             \n\nWorkflow = {};\n\nthis.ImageSign = {};\n\nthis.TracesHandler = {};\n\nthis.TracesTemplate = {};\n\nthis.InstanceformTemplate = {};\n\nthis.InstanceAttachmentTemplate = {};\n\nthis.InstanceSignText = {};\n\nthis.RelatedInstances = {};\n\nthis.RelatedRecords = {};\n\nthis.InstanceMacro = {\n  context: {}\n};\n\nthis.TracesManager = {};\n\nInstanceSignText.isOpinionField_from_string = function(field_formula) {\n  return (field_formula != null ? field_formula.indexOf(\"{traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{signature.traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{yijianlan:\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{\\\"yijianlan\\\":\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{'yijianlan':\") : void 0) > -1;\n};\n\nInstanceSignText.includesOpinionField = function(form, form_version) {\n  var _form_version, field_formulas, fields;\n  field_formulas = new Array();\n  _form_version = {};\n  if (Meteor.isServer) {\n    _form_version = uuflowManager.getFormVersion(db.forms.findOne({\n      _id: form\n    }), form_version);\n  } else {\n    _form_version = db.form_versions.findOne({\n      _id: form_version,\n      form: form\n    });\n  }\n  fields = (_form_version != null ? _form_version.fields : void 0) || [];\n  fields.forEach(function(f) {\n    var ref;\n    if (f.type === 'table') {\n      return console.log('ignore opinion field in table');\n    } else if (f.type === 'section') {\n      return f != null ? (ref = f.fields) != null ? ref.forEach(function(f1) {\n        return field_formulas.push(f1.formula);\n      }) : void 0 : void 0;\n    } else {\n      return field_formulas.push(f.formula);\n    }\n  });\n  return _.some(field_formulas, function(field_formula) {\n    return InstanceformTemplate.helpers.isOpinionField_from_string(field_formula);\n  });\n};\n","db.instance_tasks = new Meteor.Collection('instance_tasks')\n\ndb.instance_tasks._simpleSchema = new SimpleSchema\n    instance:\n        type: String\n    trace:\n        type: String\n    is_finished:\n        type: String\n    user:\n        type: String\n    user_name:\n        type: String\n    handler:\n        type: String\n    handler_name:\n        type: String\n    handler_organization:\n        type: String\n    handler_organization_name:\n        type: String\n    handler_organization_fullname:\n        type: String\n    start_date:\n        type: Date\n    due_date:\n        type: Date\n    is_read:\n        type: Boolean\n    is_error:\n        type: Boolean\n    values:\n        type: Object\n    deadline:\n        type: Date\n    remind_date:\n        type: Date\n    reminded_count:\n        type: Number\n    read_date:\n        type: Date\n    description:\n        type: String\n    modified:\n        type: Date\n    modified_by:\n        type: String\n    sign_show:\n        type: Boolean\n    judge:\n        type: String\n    next_steps:\n        type: Array\n    \"next_steps.$\":\n        type: Object\n    \"next_steps.$.step\":\n        type: String\n    \"next_steps.$.users\":\n        type: [String]\n    finish_date:\n        type: Date\n    cost_time:\n        type: Number\n    space:\n        type: String\n    instance_name:\n        type: String\n    submitter:\n        type: String\n    submitter_name:\n        type: String\n    applicant:\n        type: String\n    applicant_name:\n        type: String\n    applicant_organization_name:\n        type: String\n    submit_date:\n        type: Date\n    flow:\n        type: String\n    flow_name:\n        type: String\n    form:\n        type: String\n    step:\n        type: String\n    step_name:\n        type: String\n    category_name:\n        type: String\n    instance_state:\n        type: String\n    distribute_from_instance:\n        type: String\n    forward_from_instance:\n        type: String\n    keywords:\n        type: String\n    is_archived:\n        type: Boolean\n    category:\n        type: String\n","db.auth_tokens = new Meteor.Collection('auth_tokens')","marked = require(\"marked\")\n\nInstanceReadOnlyTemplate = {};\n\n\nInstanceReadOnlyTemplate.instance_attachment = \"\"\"\n\t<tr>\n\t\t<td class=\"ins-attach-view\">\n\t\t\t<a href=\"{{ins_attach_download_url _id absolute}}\" class=\"ins_attach_href\" target=\"_parent\" data-name=\"{{this.name}}\" data-type=\"{{this.original.type}}\" data-id=\"{{_id}}\">{{this.name}}</a>\n\t\t</td>\n\t</tr>\n\"\"\"\n\nInstanceReadOnlyTemplate.afSelectUserRead = \"\"\"\n\t<div class='selectUser form-control ins_applicant'>{{value}}</div>\n\"\"\"\n\n\nInstanceReadOnlyTemplate.afFormGroupRead = \"\"\"\n\t<div class='form-group'>\n\t\t{{#with getField this.name}}\n\t\t\t{{#if equals type 'section'}}\n\t\t\t\t\t<div class='section callout callout-default'>\n\t\t\t\t\t\t<label class=\"control-label\">{{f_label this}}</label>\n\t\t\t\t\t\t<p>{{{description}}}</p>\n\t\t\t\t\t</div>\n\t\t\t{{else}}\n\t\t\t\t{{#if equals type 'table'}}\n\t\t\t\t\t<div class=\"panel panel-default steedos-table\">\n\t\t\t\t\t\t<div class=\"panel-body\" style=\"padding:0px;\">\n\t\t\t\t\t\t\t<div class=\"panel-heading\" >\n\t\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t<span class=\"description\">{{{description}}}</span>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t<div class=\"readonly-table\" style=\"padding:0px;overflow-x:auto;\">\n\t\t\t\t\t\t\t\t\t<table type='table' class=\"table table-bordered table-condensed autoform-table\" style='margin-bottom:0px;' {{this.atts}} id=\"{{this.code}}Table\" name=\"{{this.code}}\" data-schema-key=\"{{this.name}}\">\n\t\t\t\t\t\t\t\t\t\t<thead id=\"{{this.name}}Thead\" name=\"{{this.name}}Thead\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\n\t\t\t\t\t\t\t\t\t\t</thead>\n\t\t\t\t\t\t\t\t\t\t<tbody id=\"{{this.name}}Tbody\" name=\"{{this.name}}Tbody\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\n\t\t\t\t\t\t\t\t\t\t</tbody>\n\t\t\t\t\t\t\t\t\t</table>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if showLabel}}\n\t\t\t\t\t\t<label>{{getLabel code}}</label>\n\t\t\t\t\t{{/if}}\n\t\t\t\t\t{{#if isTextarea this}}\n\t\t\t\t\t\t<p class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</p>\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/if}}\n\t\t{{/with}}\n\t</div>\n\"\"\"\n\nInstanceReadOnlyTemplate.afFormGroup = \"\"\"\n\n\t{{#with getField this.name}}\n\t\t\t{{#if equals type 'section'}}\n\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t<div class='section callout callout-default'>\n\t\t\t\t\t\t<label class=\"control-label\">{{f_label this}}</label>\n\t\t\t\t\t\t<p>{{{description}}}</p>\n\t\t\t\t\t</div>\n  \t\t\t\t</div>\n\t\t\t{{else}}\n\t\t\t\t{{#if equals type 'table'}}\n\t\t\t\t\t<div class=\"panel panel-default steedos-table\">\n\t\t\t\t\t\t<div class=\"panel-body\" style=\"padding:0px;\">\n\t\t\t\t\t\t\t<div class=\"panel-heading\" >\n\t\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t<span class=\"description\">{{{description}}}</span>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t<div class=\"readonly-table\" style=\"padding:0px;overflow-x:auto;\">\n\t\t\t\t\t\t\t\t\t<table type='table' class=\"table table-bordered table-condensed autoform-table\" style='margin-bottom:0px;' {{this.atts}} id=\"{{this.code}}Table\" name=\"{{this.code}}\" data-schema-key=\"{{this.name}}\">\n\t\t\t\t\t\t\t\t\t\t<thead id=\"{{this.name}}Thead\" name=\"{{this.name}}Thead\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\n\t\t\t\t\t\t\t\t\t\t</thead>\n\t\t\t\t\t\t\t\t\t\t<tbody id=\"{{this.name}}Tbody\" name=\"{{this.name}}Tbody\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\n\t\t\t\t\t\t\t\t\t\t</tbody>\n\t\t\t\t\t\t\t\t\t</table>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if equals type 'input'}}\n\t\t\t\t\t\t<div class=\"form-group\" data-required=\"{{#if is_required}}true{{/if}}\">\n\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t{{#if is_textarea}}\n\t\t\t\t\t\t\t\t<textarea title=\"{{getLabel code}}\" name=\"{{code}}\" {{getPermissions code}} data-schema-key=\"{{getLabel code}}\" class=\"form-control\"></textarea>\n\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t{{#unless is_textarea}}\n\t\t\t\t\t\t\t\t<input type=\"text\" title=\"{{getLabel code}}\" name=\"{{code}}\" {{getPermissions code}} data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t{{/unless}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t{{#if equals type 'number'}}\n\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t<input type=\"number\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t{{#if equals type 'date'}}\n\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t<input type=\"text\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-type=\"date\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t{{#if equals type 'dateTime'}}\n\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t<input type=\"text\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-type='datetime' data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t{{#if equals type 'password'}}\n\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t<input type=\"password\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t{{#if equals type 'select'}}\n\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t<select name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<option value=\"{{value}}\">{{label}}</option>\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n\t\t\t\t\t\t\t\t\t\t\t\t</select>\n\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'radio'}}\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"af-radio-group\" data-schema-key=\"{{getLabel code}}\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n        \t\t\t\t\t\t\t\t\t\t\t\t<label class=\"radio-inline fix-indent\"><input type=\"radio\" value=\"{{value}}\" name=\"{{../code}}\" class=\"radio-inline fix-indent\"> {{label}}</label>\n    \t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n    \t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'multiSelect'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"af-checkbox-group\" data-schema-key=\"{{getLabel code}}\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label class=\"checkbox-inline fix-indent\"><input type=\"checkbox\" value=\"{{value}}\" name=\"{{../code}}\" class=\"checkbox-inline fix-indent\"> {{label}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'url'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\"url\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'email'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\"email\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'checkbox'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"checkbox\" data-schema-key=\"{{getLabel code}}\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label style=\"width: 100%;\"><input type=\"checkbox\" value=\"true\" name=\"{{code}}\" class=\"checkbox-inline fix-indent\"></label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/if}}\n\t\t{{/with}}\n\"\"\"\n\nInstanceReadOnlyTemplate.create = (tempalteName, steedosData) ->\n\ttemplate = InstanceReadOnlyTemplate[tempalteName]\n\n\ttemplateCompiled = SpacebarsCompiler.compile(template, {isBody: true});\n\n\ttemplateRenderFunction = eval(templateCompiled);\n\n\tTemplate[tempalteName] = new Blaze.Template(tempalteName, templateRenderFunction);\n\tTemplate[tempalteName].steedosData = steedosData\n\tTemplate[tempalteName].helpers InstanceformTemplate.helpers\n\nInstanceReadOnlyTemplate.createInstanceSignText = (steedosData)->\n\tinstanceSignTextHtml = _getViewHtml('client/views/instance/instance_sign_text.html')\n\n\tinstanceSignTextCompiled = SpacebarsCompiler.compile(instanceSignTextHtml, {isBody: true});\n\n\tinstanceSignTextRenderFunction = eval(instanceSignTextCompiled);\n\n\tTemplate.instanceSignText = new Blaze.Template(\"instanceSignText\", instanceSignTextRenderFunction);\n\tTemplate.instanceSignText.steedosData = steedosData\n\tTemplate.instanceSignText.helpers InstanceSignText.helpers\n\nInstanceReadOnlyTemplate.createImageSign = (steedosData) ->\n\timageSignHtml = _getViewHtml('client/views/instance/image_sign.html')\n\timageSignCompiled = SpacebarsCompiler.compile(imageSignHtml, {isBody: true});\n\timageSignRenderFunction = eval(imageSignCompiled);\n\tTemplate.imageSign = new Blaze.Template(\"imageSign\", imageSignRenderFunction);\n\tTemplate.imageSign.steedosData = steedosData\n\tTemplate.imageSign.helpers ImageSign.helpers\n\nInstanceReadOnlyTemplate.createTracesHanlder = (steedosData) ->\n\ttracesHanlderHtml = _getViewHtml('client/views/instance/traces_handler.html')\n\ttracesHanlderCompiled = SpacebarsCompiler.compile(tracesHanlderHtml, {isBody: true});\n\ttracesHanlderRenderFunction = eval(tracesHanlderCompiled);\n\tTemplate.instance_traces_handler = new Blaze.Template(\"instance_traces_handler\", tracesHanlderRenderFunction);\n\tTemplate.instance_traces_handler.steedosData = steedosData\n\tTemplate.instance_traces_handler.helpers TracesHandler.helpers\n\n\nInstanceReadOnlyTemplate.init = (steedosData) ->\n\tInstanceReadOnlyTemplate.create(\"afSelectUserRead\", steedosData);\n\n\tif Meteor.isServer\n\t\tInstanceReadOnlyTemplate.create(\"afFormGroup\", steedosData);\n\n\tInstanceReadOnlyTemplate.create(\"afFormGroupRead\", steedosData);\n\tif Meteor.isServer\n\t\tInstanceReadOnlyTemplate.create(\"instance_attachment\", {absolute: steedosData.absolute});\n\t\tInstanceReadOnlyTemplate.createImageSign(steedosData)\n\t\tInstanceReadOnlyTemplate.createTracesHanlder(steedosData);\n\t\tInstanceReadOnlyTemplate.createInstanceSignText(steedosData)\n\ngetLinkText = (item, label, detail_url)->\n\tif detail_url\n\t\tdetail_url = detail_url.replace(\"{_id}\", item._id)\n\t\tif !/^http(s?):\\/\\//.test(detail_url)\n\t\t\tdetail_url = Steedos.absoluteUrl(detail_url)\n\t\treturn '<a href=\"'+detail_url+'\" target=\"_blank\">'+label+'</a>';\n\telse\n\t\treturn label\n\nInstanceReadOnlyTemplate.getValue = (value, field, locale, utcOffset) ->\n\tif !value && value != false\n\t\treturn ''\n\tif [\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1\n\t\tfieldOptions = field.options.split(\"\\n\").map (n)->\n\t\t\titemSplits = n.split(\":\")\n\t\t\treturn {\n\t\t\t\tlabel: itemSplits[0],\n\t\t\t\tvalue: itemSplits[1] || n\n\t\t\t}\n\tswitch field.type\n\t\twhen 'email'\n\t\t\tvalue = if value then '<a href=\\'mailto:' + value + '\\'>' + value + '</a>' else ''\n\t\twhen 'url'\n\t\t\tif value\n\t\t\t\tif value.indexOf(\"http\") == 0\n\t\t\t\t\ttry\n\t\t\t\t\t\tvalue = \"<a href='\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n\t\t\t\t\tcatch e\n\t\t\t\t\t\tvalue = \"<a href='' target='_blank'>\" + value + \"</a>\";\n\n\t\t\t\telse\n\t\t\t\t\tvalue = \"<a href='http://\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n\t\t\telse\n\t\t\t\tvalue = ''\n\t\twhen 'group'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = value?.getProperty(\"fullname\").toString()\n\t\t\telse\n\t\t\t\tvalue = value?.fullname\n\t\twhen 'user'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = value?.getProperty(\"name\").toString()\n\t\t\telse\n\t\t\t\tvalue = value?.name\n\t\twhen 'password'\n\t\t\tvalue = '******'\n\t\twhen 'checkbox'\n\t\t\tif value && value != 'false'\n\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\", {}, locale)\n\t\t\telse\n\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\", {}, locale)\n\t\twhen 'dateTime'\n\t\t\tif value && value.length == 16\n\t\t\t\tt = value.split(\"T\")\n\t\t\t\tt0 = t[0].split(\"-\");\n\t\t\t\tt1 = t[1].split(\":\");\n\n\t\t\t\tyear = t0[0];\n\t\t\t\tmonth = t0[1];\n\t\t\t\tdate = t0[2];\n\t\t\t\thours = t1[0];\n\t\t\t\tseconds = t1[1];\n\n\t\t\t\tvalue = new Date(year, month - 1, date, hours, seconds)\n\t\t\telse\n\t\t\t\tvalue = new Date(value)\n\n\t\t\tvalue = InstanceReadOnlyTemplate.formatDate(value, utcOffset);\n\t\twhen 'time'\n\t\t\tif value && value.length == 16\n\t\t\t\tt = value.split(\"T\")\n\t\t\t\tt0 = t[0].split(\"-\");\n\t\t\t\tt1 = t[1].split(\":\");\n\n\t\t\t\tyear = t0[0];\n\t\t\t\tmonth = t0[1];\n\t\t\t\tdate = t0[2];\n\t\t\t\thours = t1[0];\n\t\t\t\tseconds = t1[1];\n\n\t\t\t\tvalue = new Date(year, month - 1, date, hours, seconds)\n\t\t\telse\n\t\t\t\tvalue = new Date(value)\n\n\t\t\tvalue = InstanceReadOnlyTemplate.formatTime(value);\n\t\twhen 'input'\n\t\t\tif field.is_textarea\n\t\t\t\tvalue = value\n\t\twhen 'select'\n\t\t\tselectedOption = fieldOptions.find((item) -> return item.value == value)\n\t\t\tif selectedOption\n\t\t\t\tvalue = selectedOption.label\n\t\twhen 'radio'\n\t\t\tselectedOption = fieldOptions.find((item) -> return item.value == value)\n\t\t\tif selectedOption\n\t\t\t\tvalue = selectedOption.label\n\t\twhen 'multiSelect'\n\t\t\tsplitedValues = value.split(\",\")\n\t\t\tselectedOptions = fieldOptions.filter((item) -> return splitedValues.indexOf(item.value) > -1)\n\t\t\tif selectedOptions.length\n\t\t\t\tvalue = selectedOptions.map((item) -> return item.label).join(\",\")\n\t\twhen 'number'\n\t\t\tif value or value == 0\n\t\t\t\tif field.is_percent\n\t\t\t\t\tvalue = Steedos.numberToPercentString value, field.digits\n\t\t\t\telse\n\t\t\t\t\tvalue = Steedos.numberToString value, field.digits\n\t\twhen 'odata'\n\t\t\tdetail_url = field.detail_url\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = _.map value, (item)->\n\t\t\t\t\treturn getLinkText(item, item['@label'], detail_url)\n\t\t\telse\n\t\t\t\tvalue = getLinkText(value, value['@label'], detail_url)\n\t\twhen 'image'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = _.map value, (item)->\n\t\t\t\t\treturn '<div class=\"antd-ImageControl-item is-uploaded\">\n\t\t\t\t\t\t<div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\">\n\t\t\t\t\t\t\t<div class=\"antd-Image-thumbWrap\">\n\t\t\t\t\t\t\t\t<div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\"\n\t\t\t\t\t\t\t\t\t\tsrc=\"/api/files/images/'+item+'\"></div>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>'\n\t\t\t\tvalue = value.join(\"\");\n\t\t\telse\n\t\t\t\tvalue = '<div class=\"antd-ImageControl-item is-uploaded\">\n\t\t\t\t\t\t<div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\">\n\t\t\t\t\t\t\t<div class=\"antd-Image-thumbWrap\">\n\t\t\t\t\t\t\t\t<div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\"\n\t\t\t\t\t\t\t\t\t\tsrc=\"/api/files/images/'+value+'\"></div>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>'\n\t\twhen 'file'\n\t\t\tif value\n\t\t\t\tif !field.is_multiselect\n\t\t\t\t\tvalue = [value]\n\t\t\t\tif Meteor.isClient\n\t\t\t\t\tres = Steedos.authRequest('/api/v1/cfs_files_filerecord?filters=[[\"_id\",\"in\", '+JSON.stringify(value)+']]&fields=[\"_id\",\"original\"]', {async:false})\n\t\t\t\t\trecords = res.data.items\n\t\t\t\telse if Meteor.isServer\n\t\t\t\t\trecords = Steedos.objectFind(\"cfs_files_filerecord\", { filters: [[\"_id\", 'in', value]], fields: [\"_id\", \"original\"] });\n\n\t\t\t\tvalue = _.map records, (item)->\n\t\t\t\t\tfileName = item.original.name;\n\t\t\t\t\tfileUrl = Steedos.absoluteUrl('/api/files/files/'+item._id);\n\t\t\t\t\tfilePreviewHtml = '';\n\t\t\t\t\tif [\".pdf\", \".jpg\", \".jpeg\", \".png\", \".gif\"].indexOf(fileName.slice(-4)) > -1\n\t\t\t\t\t\tfilePreviewHtml = \"&ensp;<a href='#{fileUrl}' target='_blank' class='antd-Link'><span class='antd-TplField'><span>预览</span></span></a>\"\n\t\t\t\t\treturn \"<div><a href='#{fileUrl+'?download=true'}' target='_blank'>#{fileName}</a> #{filePreviewHtml ? filePreviewHtml : ''}</div>\"\n\n\t\t\t\tvalue = value.join(\"\");\n\t\twhen 'lookup'\n\t\t\tif value\n\t\t\t\tif !field.is_multiselect\n\t\t\t\t\tvalue = [value]\n\t\t\t\tif Meteor.isClient\n\t\t\t\t\tuiSchema = Creator.getObject(field.reference_to)\n\t\t\t\t\tnameField = uiSchema?.NAME_FIELD_KEY || 'name'\n\t\t\t\t\tres = Steedos.authRequest('/api/v1/'+field.reference_to+'?filters=[[\"'+(field.reference_to_field || '_id')+'\",\"in\", '+JSON.stringify(value)+']]&fields=[\"_id\",\"'+nameField+'\"]', {async:false})\n\t\t\t\t\trecords = res.data.items\n\t\t\t\telse if Meteor.isServer\n\t\t\t\t\tnameField = Steedos.getObjectNameFieldKey(field.reference_to);\n\t\t\t\t\trecords = Steedos.objectFind(field.reference_to, { filters: [[(field.reference_to_field || '_id'), 'in', value]], fields: [\"_id\", nameField] });\n\t\t\t\tvalue = _.map records, (item)->\n\t\t\t\t\treturn \"<a href='#{Steedos.absoluteUrl('/app/-/'+field.reference_to+'/view/'+item._id)}' target='_blank'>#{item[nameField]}</a>\"\n\n\t\t\t\tvalue = value.join(\" , \");\t\n\t\twhen 'html'\n\t\t\tvalue = if value then \"<div class=\\\"steedos-html\\\">#{value}</div>\" else ''\n\n\treturn value;\n\nInstanceReadOnlyTemplate.getLabel = (fields, code) ->\n\tfield = fields.findPropertyByPK(\"code\", code)\n\tif field\n\t\tif field.name\n\t\t\treturn field.name\n\t\telse\n\t\t\treturn field.code\n\n\nInstanceReadOnlyTemplate.getInstanceFormVersion = (instance)->\n\tform = db.forms.findOne(instance.form);\n\n\tform_version = {}\n\n\tform_fields = [];\n\n\tif form.current._id == instance.form_version\n\t\tform_version = form.current\n\telse\n\t\tform_version = _.where(form.historys, {_id: instance.form_version})[0]\n\n\tform_version.fields.forEach (field)->\n\t\tif field.type == 'section'\n\t\t\tform_fields.push(field);\n\t\t\tif field.fields\n\t\t\t\tfield.fields.forEach (f) ->\n\t\t\t\t\tform_fields.push(f);\n\t\telse if field.type == 'table'\n\t\t\tfield['sfields'] = field['fields']\n\t\t\tdelete field['fields']\n\t\t\tform_fields.push(field);\n\t\telse\n\t\t\tform_fields.push(field);\n\n\tform_version.fields = form_fields;\n\n\treturn form_version;\n\nInstanceReadOnlyTemplate.getFlowVersion = (instance)->\n\tflow = db.flows.findOne(instance.flow);\n\tflow_version = {}\n\tif flow.current._id == instance.flow_version\n\t\tflow_version = flow.current\n\telse\n\t\tflow_version = _.where(flow.historys, {_id: instance.flow_version})[0]\n\n\treturn flow_version;\n\n\n_getViewHtml = (path) ->\n\tviewHtml = Assets.getText(path)\n\n\tif viewHtml\n\t\tviewHtml = viewHtml.replace(/<template[\\w\\s\\\"\\=']+>/i,\"\").replace(/<\\/template>/i,\"\")\n\n\treturn viewHtml;\n\n_getLocale = (user)->\n\tif user?.locale?.toLocaleLowerCase() == 'zh-cn'\n\t\tlocale = \"zh-CN\"\n\telse if user?.locale?.toLocaleLowerCase() == 'en-us'\n\t\tlocale = \"en\"\n\telse\n\t\tlocale = \"zh-CN\"\n\treturn locale\n\n\n_getRequiredFields = (fields, rev)->\n\tif !rev\n\t\trev = [];\n\n\tfields.forEach (field)->\n\t\tif field.type == 'section'\n\t\t\t_getRequiredFields(field.fields, rev)\n\t\telse if field.type == 'table'\n\n\t\telse\n\t\t\tif field.is_required\n\t\t\t\trev.push field.code\n\treturn rev;\n\n_getStartStepEditableFields = (fields, steps)->\n\tstartStep = steps.findPropertyByPK(\"step_type\",\"start\")\n\n\teditableCode = []\n\n\t_.keys(startStep.permissions).forEach (key)->\n\t\tif startStep.permissions[key] == 'editable'\n\t\t\teditableCode.push key\n\n\treturn editableCode\n\n_getStartStepRequiredFields = (fields, steps)->\n\trequiredFields = _getRequiredFields(fields)\n\n\teditableCode = _getStartStepEditableFields(fields, steps)\n\n\treturn _.intersection(requiredFields, editableCode)\n\n_getTemplateData = (user, space, instance, options)->\n\tif Meteor.isServer\n\t\tform_version = InstanceReadOnlyTemplate.getInstanceFormVersion(instance)\n\telse\n\t\tform_version = WorkflowManager.getInstanceFormVersion(instance)\n\n\tlocale = _getLocale(user)\n\n\tsteedosData = {}\n\n\tif Meteor.isClient\n\t\tsteedosData = _.clone(WorkflowManager_format.getAutoformSchemaValues())\n\t\tsteedosData.insname = instance.name\n\t\tsteedosData.ins_state = instance.state\n\t\tsteedosData.ins_final_decision = instance.ins_final_decision\n\t\tsteedosData.ins_code = instance.code\n\t\tsteedosData.ins_is_archived = instance.is_archived\n\t\tsteedosData.ins_is_deleted = instance.ins_is_deleted\n\t\tsteedosData.applicant_name = instance.applicant_name\n\t\tsteedosData.applicantContext = instance.applicant_name\n\n\tsteedosData.instance = instance\n\tsteedosData.form_version = form_version\n\tsteedosData.locale = locale\n\tsteedosData.utcOffset = user.utcOffset\n\tsteedosData.space = instance.space\n\tsteedosData.sessionUserId = user._id\n\n\tif Meteor.isServer\n\t\tif options?.editable\n\t\t\tform = db.forms.findOne({_id: instance.form})\n\n\t\t\tflow = db.flows.findOne({_id: instance.flow})\n\n\t\t\tsteedosData.startStepEditableFields = _getStartStepEditableFields(form.current.fields, flow.current.steps);\n\n\treturn steedosData;\n\nInstanceReadOnlyTemplate.formatDate = (date, utcOffset)->\n\tif Meteor.isServer\n\t\tpassing = false;\n\telse\n\t\tpassing = true;\n\n\tif !utcOffset && utcOffset !=0\n\t\tutcOffset = 8\n\n\treturn moment(date).utcOffset(utcOffset, passing).format(\"YYYY-MM-DD HH:mm\");\n\nInstanceReadOnlyTemplate.formatTime = (date)->\n\tutcOffset = 0\n\treturn moment(date).utcOffset(utcOffset).format(\"HH:mm\");\n\nInstanceReadOnlyTemplate.getInstanceView = (user, space, instance, options)->\n\n\tsteedosData = _getTemplateData(user, space, instance, options)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\tinstanceTemplate = TemplateManager.getTemplate(instance, options?.templateName);\n\n\tinstanceTemplate = instanceTemplate.replace(/afSelectUser/g,\"afSelectUserRead\")\n\n\tif !options?.editable\n\t\tinstanceTemplate = instanceTemplate.replace(/afFormGroup/g,\"afFormGroupRead\")\n\n\tinstanceCompiled = SpacebarsCompiler.compile(instanceTemplate, {isBody: true});\n\n\tinstanceRenderFunction = eval(instanceCompiled);\n\n\tTemplate.instance_readonly_view = new Blaze.Template(\"instance_readonly_view\", instanceRenderFunction);\n\n\tTemplate.instance_readonly_view.steedosData = steedosData\n\n\tTemplate.instance_readonly_view.helpers InstanceformTemplate.helpers\n\n\tInstanceReadOnlyTemplate.init(steedosData);\n\n\tbody = Blaze.toHTMLWithData(Template.instance_readonly_view, steedosData)\n\n\treturn \"\"\"\n\t\t<div id='instanceform' >\n\t\t\t#{body}\n\t\t</div>\n\t\"\"\"\n\nInstanceReadOnlyTemplate.getTracesView = (user, space, instance, options)->\n\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tform = db.forms.findOne(instance.form);\n\tif form.instance_style == \"table\" || options?.templateName == \"table\"\n\t\ttracesHtml = _getViewHtml('client/views/instance/traces_table.html')\n\telse\n\t\ttracesHtml = _getViewHtml('client/views/instance/traces.html')\n\n\ttraceCompiled = SpacebarsCompiler.compile(tracesHtml, {isBody: true});\n\n\ttraceRenderFunction = eval(traceCompiled);\n\n\tTemplate.trace_readonly_view = new Blaze.Template(\"trace_readonly_view\", traceRenderFunction);\n\n\tTemplate.trace_readonly_view.steedosData = steedosData\n\n\tTemplate.trace_readonly_view.helpers TracesTemplate.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.trace_readonly_view, instance.traces)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getAttachmentView = (user, space, instance)->\n\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tattachmentHtml = _getViewHtml('client/views/instance/instance_attachments.html')\n\n\tattachmentCompiled = SpacebarsCompiler.compile(attachmentHtml, {isBody: true});\n\n\tattachmentRenderFunction = eval(attachmentCompiled);\n\n\tTemplate.attachments_readonly_view = new Blaze.Template(\"attachments_readonly_view\", attachmentRenderFunction);\n\n\tTemplate.attachments_readonly_view.steedosData = steedosData\n\n\tTemplate.attachments_readonly_view.helpers InstanceAttachmentTemplate.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.attachments_readonly_view)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getRelatedInstancesView = (user, space, instance, options)->\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\trelatedInstancesHtml = _getViewHtml('client/views/instance/related_instances.html')\n\n\trelatedInstancesCompiled = SpacebarsCompiler.compile(relatedInstancesHtml, {isBody: true});\n\n\trelatedInstancesRenderFunction = eval(relatedInstancesCompiled);\n\n\tTemplate.related_instances_view = new Blaze.Template(\"related_instances_view\", relatedInstancesRenderFunction);\n\n\tTemplate.related_instances_view.steedosData = steedosData\n\n\tTemplate.related_instances_view.helpers RelatedInstances.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.related_instances_view, steedosData)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getRelatedRecordsView = (user, space, instance, options)->\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\trelatedRecordsHtml = _getViewHtml('client/views/instance/related_records.html')\n\n\trelatedRecordsCompiled = SpacebarsCompiler.compile(relatedRecordsHtml, {isBody: true});\n\n\trelatedRecordsRenderFunction = eval(relatedRecordsCompiled);\n\n\tTemplate.related_records_view = new Blaze.Template(\"related_records_view\", relatedRecordsRenderFunction);\n\n\tTemplate.related_records_view.steedosData = steedosData\n\n\tTemplate.related_records_view.helpers RelatedRecords.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.related_records_view, steedosData)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getOnLoadScript = (instance)->\n\tform_version = WorkflowManager.getFormVersion(instance.form, instance.form_version)\n\n\tform_script = form_version.form_script;\n\n\tif form_script && form_script.replace(/\\n/g,\"\").replace(/\\s/g,\"\").length > 0\n\t\tform_script = \"CoreForm = {};CoreForm.instanceform = {};\" + form_script\n\t\tform_script += \";if(CoreForm.form_OnLoad){window.onload = CoreForm.form_OnLoad();}\"\n\telse\n\t\tform_script = \"\"\n\n\n\nInstanceReadOnlyTemplate.getInstanceHtml = (user, space, instance, options)->\n\n\tbody = InstanceReadOnlyTemplate.getInstanceView(user, space, instance, options);\n\n\tonLoadScript = InstanceReadOnlyTemplate.getOnLoadScript(instance);\n\n\tcreatorService = Meteor.settings.public.webservices?.creator?.url\n\tins_record_ids = instance.record_ids\n\tlocale = _getLocale(user);\n\topenFileScript = \"\"\"\n\t\t\tif(window.isNode && isNode()){\n\t\t\t\tattachs = document.getElementsByClassName(\"ins_attach_href\");\n\t\t\t\tfor(var i = 0; i < attachs.length; i++){\n\t\t\t\t\tattach = attachs[i];\n\t\t\t\t\tattach.addEventListener(\"click\", function(e){\n\t\t\t\t\t\tif(isImage(this.dataset.type) || isHtml(this.dataset.type)){\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\topenWindow(\"/api/files/instances/\" + this.dataset.id);\n\t\t\t\t\t\t}else if(nw_core.canOpenFile(this.dataset.name)){\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\tnw_core.openFile(this.href, this.dataset.name)\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar flow = \"#{instance.flow}\";\n\t\t\tvar space = \"#{instance.space}\";\n\n\t\t\tfunction getCookie(name){\n\t\t\t\tlet pattern = RegExp(name + \"=.[^;]*\")\n\t\t\t\tlet matched = document.cookie.match(pattern)\n\t\t\t\tif(matched){\n\t\t\t\t\tlet cookie = matched[0].split('=')\n\t\t\t\t\treturn cookie[1]\n\t\t\t\t}\n\t\t\t\treturn ''\n\t\t\t}\n\n\t\t\tvar records = document.getElementsByClassName(\"ins-related-records\");\n\t\t\tfor(var i = 0; i < records.length; i++){\n\t\t\t\t\tvar record = records[i];\n\t\t\t\t\trecord.addEventListener(\"click\", function(e){\n\t\t\t\t\t\tvar creatorService = \"#{creatorService}\"\n\t\t\t\t\t\tvar ins_record_ids = #{JSON.stringify(ins_record_ids)}\n\t\t\t\t\t\tif(creatorService && ins_record_ids && ins_record_ids.length > 0){\n\t\t\t\t\t\t\tvar objcetName = ins_record_ids[0].o\n\t\t\t\t\t\t\tvar id = ins_record_ids[0].ids[0]\n\t\t\t\t\t\t\tvar uobj = {};\n\t\t\t\t\t\t\tuobj[\"X-User-Id\"] = getCookie(\"X-User-Id\");\n\t\t\t\t\t\t\tuobj[\"X-Auth-Token\"] = getCookie(\"X-Auth-Token\");\n\t\t\t\t\t\t\tredirectUrl = creatorService + \"app/-/\" + objcetName + \"/view/\" + id + \"?\" + $.param(uobj);\n\t\t\t\t\t\t\topenWindow(redirectUrl);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\"\"\";\n\n\n\tif !Steedos.isMobile()\n\t\tform = db.forms.findOne(instance.form);\n\t\tif form?.instance_style == 'table'\n\t\t\tinstance_style = \"instance-table\"\n\n\tif options?.templateName == 'table'\n\t\tinstance_style = \"instance-table\"\n\n\tif options?.instance_style\n\t\tinstance_style = options.instance_style\n\n\tif !options || options.showTrace == true\n\t\ttrace = InstanceReadOnlyTemplate.getTracesView(user, space, instance)\n\telse\n\t\ttrace = \"\"\n\n\tinstanceBoxStyle = \"\";\n\n\tif instance && instance.final_decision\n\t\tif instance.final_decision == \"approved\"\n\t\t\tinstanceBoxStyle = \"box-success\"\n\t\telse if (instance.final_decision == \"rejected\")\n\t\t\tinstanceBoxStyle = \"box-danger\"\n\tif !options || options.showAttachments == true\n\t\tattachment = InstanceReadOnlyTemplate.getAttachmentView(user, space, instance)\n\t\trelated_instances = InstanceReadOnlyTemplate.getRelatedInstancesView(user, space, instance, options)\n\t\trelated_records = InstanceReadOnlyTemplate.getRelatedRecordsView(user, space, instance, options)\n\telse\n\t\tattachment = \"\"\n\t\trelated_instances = \"\"\n\t\trelated_records = \"\"\n\n\n\twidth = \"960px\"\n\t#\t如果给table的parent设置width，则会导致阿里云邮箱显示table 异常\n\tif options?.width\n\t\twidth = \"\"\n\n\tcssHref = Meteor.absoluteUrl(\"steedos-css\")\n\t\n\tjqHref = Meteor.absoluteUrl(\"website/libs/jquery.min.js\")\n\n\tallCssLink = \"\"\"<link rel=\"stylesheet\" type=\"text/css\" class=\"__meteor-css__\" href=\"#{cssHref}\">\"\"\"\n\n\ttraceCheck = \"\"\n\tif !_.isEmpty(trace)\n\t\ttraceCheck = \"checked\"\n\tif options?.tagger == 'email' || options?.editable\n\t\tshowTracesBtn = \"\"\n\telse\n\t\tshowTracesBtn = \"\"\"\n\t\t\t<div class=\"navigation-bar btn-group no-print\" style=\"min-width: 600px; z-index: 999; box-sizing: border-box;\">\n\t\t\t\t<div class=\"print-tool\">\n\t\t\t\t\t<label class=\"cbx-label\"><input type=\"checkbox\" class=\"cbx-print cbx-print-attachments\" id=\"cbx-print-attachments\" checked=\"checked\"><span>#{TAPi18n.__('instance_attachment', {}, locale)}</span></label>\n\t\t\t\t\t<label class=\"cbx-label\"><input type=\"checkbox\" class=\"cbx-print cbx-print-traces\" id=\"cbx-print-traces\" checked=\"#{traceCheck}\"><span>#{TAPi18n.__('instance_approval_history', {}, locale)}</span></label>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t\"\"\"\n\n\tshowTracesScript = \"\"\"\n\t\t$( document ).ready(function(){\n\t\t\tvar b = document.getElementById('cbx-print-traces');\n\t\t\tvar t = document.getElementsByClassName('instance-traces')[0];\n\t\t\tif (b && b.checked && t){\n\t\t\t\tt.style = 'display: block;'\n\t\t\t} else if(t){\n\t\t\t\tt.style = 'display: none;'\n\t\t\t}\n\t\t\tif(b){\n\t\t\t\tb.addEventListener('change', function(e){\n\t\t\t\t\tif (e.target.checked){\n\t\t\t\t\t\tt.style = 'display: block;'\n\t\t\t\t\t} else {\n\t\t\t\t\t\tt.style = 'display: none;'\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\n\n\t\t\tvar attachmentsCheckbox = document.getElementById('cbx-print-attachments');\n\t\t\tvar attachmentsView = document.getElementsByClassName('attachments-section')[0];\n\t\t\tif (attachmentsCheckbox && attachmentsCheckbox.checked && attachmentsView){\n\t\t\t\tattachmentsView.style = 'display: block;'\n\t\t\t} else if(attachmentsView){\n\t\t\t\tattachmentsView.style = 'display: none;'\n\t\t\t}\n\t\t\tif(attachmentsCheckbox){\n\t\t\t\tattachmentsCheckbox.addEventListener('change', function(e){\n\t\t\t\t\tif (e.target.checked){\n\t\t\t\t\t\tattachmentsView.style = 'display: block;'\n\t\t\t\t\t} else {\n\t\t\t\t\t\tattachmentsView.style = 'display: none;'\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\"\"\"\n\n\tif options?.styles\n\t\tallCssLink = \"\"\n\n\tform = db.forms.findOne({_id: instance.form});\n\tformDescriptionHtml = \"\"\n\tif form\n\t\tformDescription = form.description\n\t\tif formDescription\n\t\t\tformDescription = formDescription.replace(/\\n/g,\"<br/>\")\n\t\t\tformDescriptionHtml = \"\"\"\n\t\t\t\t<div class=\"box-header  with-border instance-header\">\n\t\t\t\t\t<div>\n\t\t\t\t\t\t#{formDescription}\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\"\"\"\n\n\thtml = \"\"\"\n\t\t<!DOCTYPE html>\n\t\t<html>\n\t\t\t<head>\n\t\t\t\t<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\"/>\n\t\t\t\t#{allCssLink}\n\t\t\t\t<script src=\"#{jqHref}\" type=\"text/javascript\"></script>\n\t\t\t\t<script src=\"/js/nw_core.js\" type=\"text/javascript\"></script>\n\t\t\t\t#{options.plugins || \"\"}\n\n\t\t\t\t<style>\n\t\t\t\t\t.steedos{\n\t\t\t\t\t\twidth: #{width};\n\t\t\t\t\t\tmargin-left: auto;\n\t\t\t\t\t\tmargin-right: auto;\n\t\t\t\t\t}\n\n\t\t\t\t\t.instance-view .instance-name{\n\t\t\t\t\t\tdisplay: inline !important\n\t\t\t\t\t}\n\t\t\t\t\t.box-tools{\n\t\t\t\t\t\tdisplay: none;\n\t\t\t\t\t}\n\t\t\t\t\t.box.collapsed-box .box-body,.box.collapsed-box .box-footer {\n\t\t\t\t\t  display: block;\n\t\t\t\t\t}\n\n\t\t\t\t\tbody{\n\t\t\t\t\t\tbackground: azure !important;\n\t\t\t\t\t}\n\n\t\t\t\t\t.instance-view .instance-traces{\n\t\t\t\t\t\tpadding-left: 15px;\n\t\t\t\t\t\tpadding-right: 15px;\n\t\t\t\t\t}\n\n\t\t\t\t\t.antd-ImageControl-item {\n\t\t\t\t\tborder-radius: var(--ImageControl-addBtn-borderRadius);\n\t\t\t\t\tvertical-align: top;\n\t\t\t\t\tpadding: var(--gap-xs);\n\t\t\t\t\tdisplay: inline-block;\n\t\t\t\t\tmargin-right: var(--gap-base);\n\t\t\t\t\tmargin-bottom: var(--gap-base);\n\t\t\t\t\tposition: relative;\n\t\t\t\t\twidth: 7.5rem;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item.is-invalid {\n\t\t\t\t\tpadding: 0;\n\t\t\t\t\tborder-color: var(--FileControl-danger-color);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item svg.icon-refresh {\n\t\t\t\t\ttransform: rotate(180deg);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-filename {\n\t\t\t\t\tdisplay: inline-flex;\n\t\t\t\t\tflex-direction: column;\n\t\t\t\t\tjustify-content: center;\n\t\t\t\t\talign-items: center;\n\t\t\t\t\tcolor: var(--FileControl-danger-color);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-filename > svg.icon-image {\n\t\t\t\t\tmargin-bottom: 8px;\n\t\t\t\t\twidth: 24px;\n\t\t\t\t\theight: 24px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-filename > span {\n\t\t\t\t\tmax-width: 100%;\n\t\t\t\t\toverflow: hidden;\n\t\t\t\t\twhite-space: nowrap;\n\t\t\t\t\ttext-overflow: ellipsis;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-image {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\theight: 100%;\n\t\t\t\t\tpadding: 0;\n\t\t\t\t\tborder: none;\n\t\t\t\t\tdisplay: block;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemClear {\n\t\t\t\t\tposition: absolute;\n\t\t\t\t\tcursor: pointer;\n\t\t\t\t\tcolor: #999;\n\t\t\t\t\ttop: 5px;\n\t\t\t\t\tright: 5px;\n\t\t\t\t\tline-height: 1;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemClear > svg {\n\t\t\t\t\ttop: 0;\n\t\t\t\t\twidth: 10px;\n\t\t\t\t\theight: 10px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemInfo {\n\t\t\t\t\tdisplay: inline-flex;\n\t\t\t\t\twidth: 110px;\n\t\t\t\t\theight: 110px;\n\t\t\t\t\tjustify-content: center;\n\t\t\t\t\talign-items: center;\n\t\t\t\t\talign-content: center;\n\t\t\t\t\tflex-wrap: wrap;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemInfo > p {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\ttext-align: center;\n\t\t\t\t\tfont-size: 12px;\n\t\t\t\t\tmargin-bottom: 5px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-progress {\n\t\t\t\t\twidth: 70px;\n\t\t\t\t\theight: 5px;\n\t\t\t\t\tbackground: #ebebeb;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-progressValue {\n\t\t\t\t\theight: 5px;\n\t\t\t\t\tborder-radius: var(--ImageControl-progress-borderRadius);\n\t\t\t\t\tdisplay: block;\n\t\t\t\t\tbackground: var(--info);\n\t\t\t\t\tmin-width: 10%;\n\t\t\t\t\ttransition: ease-out width var(--animation-duration);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item.is-invalid .antd-ImageControl-itemClear {\n\t\t\t\t\tdisplay: none;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item.is-invalid:hover .antd-ImageControl-itemClear {\n\t\t\t\t\tdisplay: block;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-errorMsg {\n\t\t\t\t\tcolor: var(--danger);\n\t\t\t\t\tmargin: 5px 0 0;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-uploadBtn {\n\t\t\t\t\tmargin-top: 5px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-cropperWrapper {\n\t\t\t\t\tposition: relative;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-cropperWrapper img {\n\t\t\t\t\tmax-width: 100%;\n\t\t\t\t\tmax-height: 400px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-croperToolbar {\n\t\t\t\t\tdisplay: inline-flex;\n\t\t\t\t\tposition: absolute;\n\t\t\t\t\tright: 0;\n\t\t\t\t\tbottom: 0;\n\t\t\t\t\tflex-direction: column;\n\t\t\t\t\talign-items: flex-end;\n\t\t\t\t\tbackground: #fff;\n\t\t\t\t\tborder-radius: 4px;\n\t\t\t\t\tmargin: 0.5rem;\n\t\t\t\t\tbox-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.1);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-croperToolbar > a {\n\t\t\t\t\tcolor: var(--Form-item-fontColor);\n\t\t\t\t\tpadding: 2px 5px;\n\t\t\t\t\tcursor: pointer;\n\t\t\t\t\tfont-size: 18px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-croperToolbar > a:hover {\n\t\t\t\t\tcolor: var(--link-color);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-acceptTip {\n\t\t\t\t\theight: 120px;\n\t\t\t\t\tcolor: #999;\n\t\t\t\t\tborder: 2px dashed var(--borderColor);\n\t\t\t\t\tborder-color: var(--info);\n\t\t\t\t\tbackground: #f3f9fe;\n\t\t\t\t\tborder-radius: var(--borderRadius);\n\t\t\t\t\tline-height: 120px;\n\t\t\t\t\ttext-align: center;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-fixed-size {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\theight: 100%;\n\t\t\t\t\tpadding: 0;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-fixed-size .antd-ImageControl-itemOverlay {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\theight: 100%;\n\t\t\t\t\t}\n\n\t\t\t\t\t.antd-Images {\n\t\t\t\t\t\tdisplay: flex;\n\t\t\t\t\t\tflex-wrap: wrap;\n\t\t\t\t\t\tmargin: calc(var(--gap-xs) * -1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Images-item {\n\t\t\t\t\t\tdisplay: flex;\n\t\t\t\t\t\tmargin: var(--gap-xs);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image {\n\t\t\t\t\t\tborder: var(--borderWidth) solid var(--borderColor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image--thumb {\n\t\t\t\t\t\tdisplay: inline-block;\n\t\t\t\t\t\tpadding: var(--gap-xs);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumbWrap {\n\t\t\t\t\t\tposition: relative;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-image {\n\t\t\t\t\t\tdisplay: block;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-image--loading {\n\t\t\t\t\t\tvisibility: hidden;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image--original .antd-Image-image {\n\t\t\t\t\t\tmax-width: 100%;\n\t\t\t\t\t\tmax-height: 100%;\n\t\t\t\t\t\twidth: auto;\n\t\t\t\t\t\tmargin: auto;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb {\n\t\t\t\t\t\twidth: 6.875rem;\n\t\t\t\t\t\theight: 6.875rem;\n\t\t\t\t\t\tposition: relative;\n\t\t\t\t\t\toverflow: hidden;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb > img {\n\t\t\t\t\t\tposition: absolute;\n\t\t\t\t\t\tleft: 50%;\n\t\t\t\t\t\ttop: 50%;\n\t\t\t\t\t\tmax-height: 100%;\n\t\t\t\t\t\twidth: auto;\n\t\t\t\t\t\ttransform: translate(-50%, -50%);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-info {\n\t\t\t\t\t\tpadding: 5px 10px;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image--thumb .antd-Image-info {\n\t\t\t\t\t\twidth: 6.875rem;\n\t\t\t\t\t\tpadding: 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--4-3 {\n\t\t\t\t\t\theight: 5.15625rem;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--16-9 {\n\t\t\t\t\t\theight: 3.8671875rem;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--fixed-size {\n\t\t\t\t\t\tmin-width: 6.875rem;\n\t\t\t\t\t\tmin-height: 6.875rem;\n\t\t\t\t\t\twidth: 100%;\n\t\t\t\t\t\tpadding: 0;\n\t\t\t\t\t\theight: 100%;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb {\n\t\t\t\t\t\twidth: 100%;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb > img {\n\t\t\t\t\t\twidth: auto;\n\t\t\t\t\t\theight: 100%;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--w-full > img {\n\t\t\t\t\t\twidth: 100%;\n\t\t\t\t\t\theight: auto;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t#{options?.styles || \"\"}\n\n\t\t\t\t\t#{options?.add_styles || \"\"}\n\t\t\t\t</style>\n\t\t\t</head>\n\t\t\t<body>\n\t\t\t\t<div class=\"steedos workflow instance-print\">\n\t\t\t\t\t<div class=\"skin-green skin-admin-lte\">\n\t\t\t\t\t\t<div class=\"wrapper\">\n\t\t\t\t\t\t\t<div class=\"content-wrapper\">\n\t\t\t\t\t\t\t\t#{showTracesBtn}\n\t\t\t\t\t\t\t\t<div class=\"instance-print\">\n\t\t\t\t\t\t\t\t\t<div class=\"instance #{instance_style}\">\n\t\t\t\t\t\t\t\t\t\t<form name=\"instanceForm\">\n\t\t\t\t\t\t\t\t\t\t\t<div class=\"instance-form box #{instanceBoxStyle}\">\n\t\t\t\t\t\t\t\t\t\t\t\t#{formDescriptionHtml}\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"box-body\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"col-md-12\" style=\"box-sizing: border-box;\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class='attachments-section'>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{attachment}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{related_instances}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{related_records}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{body}\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t</form>\n\t\t\t\t\t\t\t\t\t\t#{trace}\n\t\t\t\t\t\t\t\t\t</div>\n\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</body>\n\t\t\t<script>#{openFileScript};#{onLoadScript};#{showTracesScript}</script>\n\t\t</html>\n\t\"\"\"\n\n\treturn html","var _getLocale, _getRequiredFields, _getStartStepEditableFields, _getStartStepRequiredFields, _getTemplateData, _getViewHtml, getLinkText, marked;                          \n\nmarked = require(\"marked\");\n\nInstanceReadOnlyTemplate = {};\n\nInstanceReadOnlyTemplate.instance_attachment = \"<tr>\\n\t<td class=\\\"ins-attach-view\\\">\\n\t\t<a href=\\\"{{ins_attach_download_url _id absolute}}\\\" class=\\\"ins_attach_href\\\" target=\\\"_parent\\\" data-name=\\\"{{this.name}}\\\" data-type=\\\"{{this.original.type}}\\\" data-id=\\\"{{_id}}\\\">{{this.name}}</a>\\n\t</td>\\n</tr>\";\n\nInstanceReadOnlyTemplate.afSelectUserRead = \"<div class='selectUser form-control ins_applicant'>{{value}}</div>\";\n\nInstanceReadOnlyTemplate.afFormGroupRead = \"<div class='form-group'>\\n\t{{#with getField this.name}}\\n\t\t{{#if equals type 'section'}}\\n\t\t\t\t<div class='section callout callout-default'>\\n\t\t\t\t\t<label class=\\\"control-label\\\">{{f_label this}}</label>\\n\t\t\t\t\t<p>{{{description}}}</p>\\n\t\t\t\t</div>\\n\t\t{{else}}\\n\t\t\t{{#if equals type 'table'}}\\n\t\t\t\t<div class=\\\"panel panel-default steedos-table\\\">\\n\t\t\t\t\t<div class=\\\"panel-body\\\" style=\\\"padding:0px;\\\">\\n\t\t\t\t\t\t<div class=\\\"panel-heading\\\" >\\n\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\\n\t\t\t\t\t\t\t<span class=\\\"description\\\">{{{description}}}</span>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t<div class=\\\"readonly-table\\\" style=\\\"padding:0px;overflow-x:auto;\\\">\\n\t\t\t\t\t\t\t\t<table type='table' class=\\\"table table-bordered table-condensed autoform-table\\\" style='margin-bottom:0px;' {{this.atts}} id=\\\"{{this.code}}Table\\\" name=\\\"{{this.code}}\\\" data-schema-key=\\\"{{this.name}}\\\">\\n\t\t\t\t\t\t\t\t\t<thead id=\\\"{{this.name}}Thead\\\" name=\\\"{{this.name}}Thead\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\\n\t\t\t\t\t\t\t\t\t</thead>\\n\t\t\t\t\t\t\t\t\t<tbody id=\\\"{{this.name}}Tbody\\\" name=\\\"{{this.name}}Tbody\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\\n\t\t\t\t\t\t\t\t\t</tbody>\\n\t\t\t\t\t\t\t\t</table>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t{{else}}\\n\t\t\t\t{{#if showLabel}}\\n\t\t\t\t\t<label>{{getLabel code}}</label>\\n\t\t\t\t{{/if}}\\n\t\t\t\t{{#if isTextarea this}}\\n\t\t\t\t\t<p class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</p>\\n\t\t\t\t{{else}}\\n\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\\n\t\t\t\t{{/if}}\\n\t\t\t{{/if}}\\n\t\t{{/if}}\\n\t{{/with}}\\n</div>\";\n\nInstanceReadOnlyTemplate.afFormGroup = \"\\n{{#with getField this.name}}\\n\t\t{{#if equals type 'section'}}\\n\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t<div class='section callout callout-default'>\\n\t\t\t\t\t<label class=\\\"control-label\\\">{{f_label this}}</label>\\n\t\t\t\t\t<p>{{{description}}}</p>\\n\t\t\t\t</div>\\n  \t\t\t\t</div>\\n\t\t{{else}}\\n\t\t\t{{#if equals type 'table'}}\\n\t\t\t\t<div class=\\\"panel panel-default steedos-table\\\">\\n\t\t\t\t\t<div class=\\\"panel-body\\\" style=\\\"padding:0px;\\\">\\n\t\t\t\t\t\t<div class=\\\"panel-heading\\\" >\\n\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\\n\t\t\t\t\t\t\t<span class=\\\"description\\\">{{{description}}}</span>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t<div class=\\\"readonly-table\\\" style=\\\"padding:0px;overflow-x:auto;\\\">\\n\t\t\t\t\t\t\t\t<table type='table' class=\\\"table table-bordered table-condensed autoform-table\\\" style='margin-bottom:0px;' {{this.atts}} id=\\\"{{this.code}}Table\\\" name=\\\"{{this.code}}\\\" data-schema-key=\\\"{{this.name}}\\\">\\n\t\t\t\t\t\t\t\t\t<thead id=\\\"{{this.name}}Thead\\\" name=\\\"{{this.name}}Thead\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\\n\t\t\t\t\t\t\t\t\t</thead>\\n\t\t\t\t\t\t\t\t\t<tbody id=\\\"{{this.name}}Tbody\\\" name=\\\"{{this.name}}Tbody\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\\n\t\t\t\t\t\t\t\t\t</tbody>\\n\t\t\t\t\t\t\t\t</table>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t{{else}}\\n\t\t\t\t{{#if equals type 'input'}}\\n\t\t\t\t\t<div class=\\\"form-group\\\" data-required=\\\"{{#if is_required}}true{{/if}}\\\">\\n\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t{{#if is_textarea}}\\n\t\t\t\t\t\t\t<textarea title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" {{getPermissions code}} data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\"></textarea>\\n\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t{{#unless is_textarea}}\\n\t\t\t\t\t\t\t<input type=\\\"text\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" {{getPermissions code}} data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t{{/unless}}\\n\t\t\t\t\t</div>\\n\t\t\t\t{{else}}\\n\t\t\t\t\t{{#if equals type 'number'}}\\n\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t<input type=\\\"number\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t{{#if equals type 'date'}}\\n\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t<input type=\\\"text\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-type=\\\"date\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t{{#if equals type 'dateTime'}}\\n\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t<input type=\\\"text\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-type='datetime' data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t{{#if equals type 'password'}}\\n\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t<input type=\\\"password\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t{{#if equals type 'select'}}\\n\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t<select name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<option value=\\\"{{value}}\\\">{{label}}</option>\\n\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n\t\t\t\t\t\t\t\t\t\t\t</select>\\n\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t{{#if equals type 'radio'}}\\n\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"af-radio-group\\\" data-schema-key=\\\"{{getLabel code}}\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n        \t\t\t\t\t\t\t\t\t\t\t\t<label class=\\\"radio-inline fix-indent\\\"><input type=\\\"radio\\\" value=\\\"{{value}}\\\" name=\\\"{{../code}}\\\" class=\\\"radio-inline fix-indent\\\"> {{label}}</label>\\n    \t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n    \t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'multiSelect'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"af-checkbox-group\\\" data-schema-key=\\\"{{getLabel code}}\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label class=\\\"checkbox-inline fix-indent\\\"><input type=\\\"checkbox\\\" value=\\\"{{value}}\\\" name=\\\"{{../code}}\\\" class=\\\"checkbox-inline fix-indent\\\"> {{label}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'url'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\\\"url\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'email'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\\\"email\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'checkbox'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"checkbox\\\" data-schema-key=\\\"{{getLabel code}}\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label style=\\\"width: 100%;\\\"><input type=\\\"checkbox\\\" value=\\\"true\\\" name=\\\"{{code}}\\\" class=\\\"checkbox-inline fix-indent\\\"></label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t{{/if}}\\n\t\t\t\t{{/if}}\\n\t\t\t{{/if}}\\n\t\t{{/if}}\\n\t{{/with}}\";\n\nInstanceReadOnlyTemplate.create = function(tempalteName, steedosData) {\n  var template, templateCompiled, templateRenderFunction;\n  template = InstanceReadOnlyTemplate[tempalteName];\n  templateCompiled = SpacebarsCompiler.compile(template, {\n    isBody: true\n  });\n  templateRenderFunction = eval(templateCompiled);\n  Template[tempalteName] = new Blaze.Template(tempalteName, templateRenderFunction);\n  Template[tempalteName].steedosData = steedosData;\n  return Template[tempalteName].helpers(InstanceformTemplate.helpers);\n};\n\nInstanceReadOnlyTemplate.createInstanceSignText = function(steedosData) {\n  var instanceSignTextCompiled, instanceSignTextHtml, instanceSignTextRenderFunction;\n  instanceSignTextHtml = _getViewHtml('client/views/instance/instance_sign_text.html');\n  instanceSignTextCompiled = SpacebarsCompiler.compile(instanceSignTextHtml, {\n    isBody: true\n  });\n  instanceSignTextRenderFunction = eval(instanceSignTextCompiled);\n  Template.instanceSignText = new Blaze.Template(\"instanceSignText\", instanceSignTextRenderFunction);\n  Template.instanceSignText.steedosData = steedosData;\n  return Template.instanceSignText.helpers(InstanceSignText.helpers);\n};\n\nInstanceReadOnlyTemplate.createImageSign = function(steedosData) {\n  var imageSignCompiled, imageSignHtml, imageSignRenderFunction;\n  imageSignHtml = _getViewHtml('client/views/instance/image_sign.html');\n  imageSignCompiled = SpacebarsCompiler.compile(imageSignHtml, {\n    isBody: true\n  });\n  imageSignRenderFunction = eval(imageSignCompiled);\n  Template.imageSign = new Blaze.Template(\"imageSign\", imageSignRenderFunction);\n  Template.imageSign.steedosData = steedosData;\n  return Template.imageSign.helpers(ImageSign.helpers);\n};\n\nInstanceReadOnlyTemplate.createTracesHanlder = function(steedosData) {\n  var tracesHanlderCompiled, tracesHanlderHtml, tracesHanlderRenderFunction;\n  tracesHanlderHtml = _getViewHtml('client/views/instance/traces_handler.html');\n  tracesHanlderCompiled = SpacebarsCompiler.compile(tracesHanlderHtml, {\n    isBody: true\n  });\n  tracesHanlderRenderFunction = eval(tracesHanlderCompiled);\n  Template.instance_traces_handler = new Blaze.Template(\"instance_traces_handler\", tracesHanlderRenderFunction);\n  Template.instance_traces_handler.steedosData = steedosData;\n  return Template.instance_traces_handler.helpers(TracesHandler.helpers);\n};\n\nInstanceReadOnlyTemplate.init = function(steedosData) {\n  InstanceReadOnlyTemplate.create(\"afSelectUserRead\", steedosData);\n  if (Meteor.isServer) {\n    InstanceReadOnlyTemplate.create(\"afFormGroup\", steedosData);\n  }\n  InstanceReadOnlyTemplate.create(\"afFormGroupRead\", steedosData);\n  if (Meteor.isServer) {\n    InstanceReadOnlyTemplate.create(\"instance_attachment\", {\n      absolute: steedosData.absolute\n    });\n    InstanceReadOnlyTemplate.createImageSign(steedosData);\n    InstanceReadOnlyTemplate.createTracesHanlder(steedosData);\n    return InstanceReadOnlyTemplate.createInstanceSignText(steedosData);\n  }\n};\n\ngetLinkText = function(item, label, detail_url) {\n  if (detail_url) {\n    detail_url = detail_url.replace(\"{_id}\", item._id);\n    if (!/^http(s?):\\/\\//.test(detail_url)) {\n      detail_url = Steedos.absoluteUrl(detail_url);\n    }\n    return '<a href=\"' + detail_url + '\" target=\"_blank\">' + label + '</a>';\n  } else {\n    return label;\n  }\n};\n\nInstanceReadOnlyTemplate.getValue = function(value, field, locale, utcOffset) {\n  var date, detail_url, e, fieldOptions, hours, month, nameField, records, res, seconds, selectedOption, selectedOptions, splitedValues, t, t0, t1, uiSchema, year;\n  if (!value && value !== false) {\n    return '';\n  }\n  if ([\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1) {\n    fieldOptions = field.options.split(\"\\n\").map(function(n) {\n      var itemSplits;\n      itemSplits = n.split(\":\");\n      return {\n        label: itemSplits[0],\n        value: itemSplits[1] || n\n      };\n    });\n  }\n  switch (field.type) {\n    case 'email':\n      value = value ? '<a href=\\'mailto:' + value + '\\'>' + value + '</a>' : '';\n      break;\n    case 'url':\n      if (value) {\n        if (value.indexOf(\"http\") === 0) {\n          try {\n            value = \"<a href='\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n          } catch (error) {\n            e = error;\n            value = \"<a href='' target='_blank'>\" + value + \"</a>\";\n          }\n        } else {\n          value = \"<a href='http://\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n        }\n      } else {\n        value = '';\n      }\n      break;\n    case 'group':\n      if (field.is_multiselect) {\n        value = value != null ? value.getProperty(\"fullname\").toString() : void 0;\n      } else {\n        value = value != null ? value.fullname : void 0;\n      }\n      break;\n    case 'user':\n      if (field.is_multiselect) {\n        value = value != null ? value.getProperty(\"name\").toString() : void 0;\n      } else {\n        value = value != null ? value.name : void 0;\n      }\n      break;\n    case 'password':\n      value = '******';\n      break;\n    case 'checkbox':\n      if (value && value !== 'false') {\n        value = TAPi18n.__(\"form_field_checkbox_yes\", {}, locale);\n      } else {\n        value = TAPi18n.__(\"form_field_checkbox_no\", {}, locale);\n      }\n      break;\n    case 'dateTime':\n      if (value && value.length === 16) {\n        t = value.split(\"T\");\n        t0 = t[0].split(\"-\");\n        t1 = t[1].split(\":\");\n        year = t0[0];\n        month = t0[1];\n        date = t0[2];\n        hours = t1[0];\n        seconds = t1[1];\n        value = new Date(year, month - 1, date, hours, seconds);\n      } else {\n        value = new Date(value);\n      }\n      value = InstanceReadOnlyTemplate.formatDate(value, utcOffset);\n      break;\n    case 'time':\n      if (value && value.length === 16) {\n        t = value.split(\"T\");\n        t0 = t[0].split(\"-\");\n        t1 = t[1].split(\":\");\n        year = t0[0];\n        month = t0[1];\n        date = t0[2];\n        hours = t1[0];\n        seconds = t1[1];\n        value = new Date(year, month - 1, date, hours, seconds);\n      } else {\n        value = new Date(value);\n      }\n      value = InstanceReadOnlyTemplate.formatTime(value);\n      break;\n    case 'input':\n      if (field.is_textarea) {\n        value = value;\n      }\n      break;\n    case 'select':\n      selectedOption = fieldOptions.find(function(item) {\n        return item.value === value;\n      });\n      if (selectedOption) {\n        value = selectedOption.label;\n      }\n      break;\n    case 'radio':\n      selectedOption = fieldOptions.find(function(item) {\n        return item.value === value;\n      });\n      if (selectedOption) {\n        value = selectedOption.label;\n      }\n      break;\n    case 'multiSelect':\n      splitedValues = value.split(\",\");\n      selectedOptions = fieldOptions.filter(function(item) {\n        return splitedValues.indexOf(item.value) > -1;\n      });\n      if (selectedOptions.length) {\n        value = selectedOptions.map(function(item) {\n          return item.label;\n        }).join(\",\");\n      }\n      break;\n    case 'number':\n      if (value || value === 0) {\n        if (field.is_percent) {\n          value = Steedos.numberToPercentString(value, field.digits);\n        } else {\n          value = Steedos.numberToString(value, field.digits);\n        }\n      }\n      break;\n    case 'odata':\n      detail_url = field.detail_url;\n      if (field.is_multiselect) {\n        value = _.map(value, function(item) {\n          return getLinkText(item, item['@label'], detail_url);\n        });\n      } else {\n        value = getLinkText(value, value['@label'], detail_url);\n      }\n      break;\n    case 'image':\n      if (field.is_multiselect) {\n        value = _.map(value, function(item) {\n          return '<div class=\"antd-ImageControl-item is-uploaded\"> <div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\"> <div class=\"antd-Image-thumbWrap\"> <div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\" src=\"/api/files/images/' + item + '\"></div> </div> </div> </div>';\n        });\n        value = value.join(\"\");\n      } else {\n        value = '<div class=\"antd-ImageControl-item is-uploaded\"> <div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\"> <div class=\"antd-Image-thumbWrap\"> <div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\" src=\"/api/files/images/' + value + '\"></div> </div> </div> </div>';\n      }\n      break;\n    case 'file':\n      if (value) {\n        if (!field.is_multiselect) {\n          value = [value];\n        }\n        if (Meteor.isClient) {\n          res = Steedos.authRequest('/api/v1/cfs_files_filerecord?filters=[[\"_id\",\"in\", ' + JSON.stringify(value) + ']]&fields=[\"_id\",\"original\"]', {\n            async: false\n          });\n          records = res.data.items;\n        } else if (Meteor.isServer) {\n          records = Steedos.objectFind(\"cfs_files_filerecord\", {\n            filters: [[\"_id\", 'in', value]],\n            fields: [\"_id\", \"original\"]\n          });\n        }\n        value = _.map(records, function(item) {\n          var fileName, filePreviewHtml, fileUrl;\n          fileName = item.original.name;\n          fileUrl = Steedos.absoluteUrl('/api/files/files/' + item._id);\n          filePreviewHtml = '';\n          if ([\".pdf\", \".jpg\", \".jpeg\", \".png\", \".gif\"].indexOf(fileName.slice(-4)) > -1) {\n            filePreviewHtml = \"&ensp;<a href='\" + fileUrl + \"' target='_blank' class='antd-Link'><span class='antd-TplField'><span>预览</span></span></a>\";\n          }\n          return \"<div><a href='\" + (fileUrl + '?download=true') + \"' target='_blank'>\" + fileName + \"</a> \" + (filePreviewHtml != null ? filePreviewHtml : {\n            filePreviewHtml: ''\n          }) + \"</div>\";\n        });\n        value = value.join(\"\");\n      }\n      break;\n    case 'lookup':\n      if (value) {\n        if (!field.is_multiselect) {\n          value = [value];\n        }\n        if (Meteor.isClient) {\n          uiSchema = Creator.getObject(field.reference_to);\n          nameField = (uiSchema != null ? uiSchema.NAME_FIELD_KEY : void 0) || 'name';\n          res = Steedos.authRequest('/api/v1/' + field.reference_to + '?filters=[[\"' + (field.reference_to_field || '_id') + '\",\"in\", ' + JSON.stringify(value) + ']]&fields=[\"_id\",\"' + nameField + '\"]', {\n            async: false\n          });\n          records = res.data.items;\n        } else if (Meteor.isServer) {\n          nameField = Steedos.getObjectNameFieldKey(field.reference_to);\n          records = Steedos.objectFind(field.reference_to, {\n            filters: [[field.reference_to_field || '_id', 'in', value]],\n            fields: [\"_id\", nameField]\n          });\n        }\n        value = _.map(records, function(item) {\n          return \"<a href='\" + (Steedos.absoluteUrl('/app/-/' + field.reference_to + '/view/' + item._id)) + \"' target='_blank'>\" + item[nameField] + \"</a>\";\n        });\n        value = value.join(\" , \");\n      }\n      break;\n    case 'html':\n      value = value ? \"<div class=\\\"steedos-html\\\">\" + value + \"</div>\" : '';\n  }\n  return value;\n};\n\nInstanceReadOnlyTemplate.getLabel = function(fields, code) {\n  var field;\n  field = fields.findPropertyByPK(\"code\", code);\n  if (field) {\n    if (field.name) {\n      return field.name;\n    } else {\n      return field.code;\n    }\n  }\n};\n\nInstanceReadOnlyTemplate.getInstanceFormVersion = function(instance) {\n  var form, form_fields, form_version;\n  form = db.forms.findOne(instance.form);\n  form_version = {};\n  form_fields = [];\n  if (form.current._id === instance.form_version) {\n    form_version = form.current;\n  } else {\n    form_version = _.where(form.historys, {\n      _id: instance.form_version\n    })[0];\n  }\n  form_version.fields.forEach(function(field) {\n    if (field.type === 'section') {\n      form_fields.push(field);\n      if (field.fields) {\n        return field.fields.forEach(function(f) {\n          return form_fields.push(f);\n        });\n      }\n    } else if (field.type === 'table') {\n      field['sfields'] = field['fields'];\n      delete field['fields'];\n      return form_fields.push(field);\n    } else {\n      return form_fields.push(field);\n    }\n  });\n  form_version.fields = form_fields;\n  return form_version;\n};\n\nInstanceReadOnlyTemplate.getFlowVersion = function(instance) {\n  var flow, flow_version;\n  flow = db.flows.findOne(instance.flow);\n  flow_version = {};\n  if (flow.current._id === instance.flow_version) {\n    flow_version = flow.current;\n  } else {\n    flow_version = _.where(flow.historys, {\n      _id: instance.flow_version\n    })[0];\n  }\n  return flow_version;\n};\n\n_getViewHtml = function(path) {\n  var viewHtml;\n  viewHtml = Assets.getText(path);\n  if (viewHtml) {\n    viewHtml = viewHtml.replace(/<template[\\w\\s\\\"\\=']+>/i, \"\").replace(/<\\/template>/i, \"\");\n  }\n  return viewHtml;\n};\n\n_getLocale = function(user) {\n  var locale, ref, ref1;\n  if ((user != null ? (ref = user.locale) != null ? ref.toLocaleLowerCase() : void 0 : void 0) === 'zh-cn') {\n    locale = \"zh-CN\";\n  } else if ((user != null ? (ref1 = user.locale) != null ? ref1.toLocaleLowerCase() : void 0 : void 0) === 'en-us') {\n    locale = \"en\";\n  } else {\n    locale = \"zh-CN\";\n  }\n  return locale;\n};\n\n_getRequiredFields = function(fields, rev) {\n  if (!rev) {\n    rev = [];\n  }\n  fields.forEach(function(field) {\n    if (field.type === 'section') {\n      return _getRequiredFields(field.fields, rev);\n    } else if (field.type === 'table') {\n\n    } else {\n      if (field.is_required) {\n        return rev.push(field.code);\n      }\n    }\n  });\n  return rev;\n};\n\n_getStartStepEditableFields = function(fields, steps) {\n  var editableCode, startStep;\n  startStep = steps.findPropertyByPK(\"step_type\", \"start\");\n  editableCode = [];\n  _.keys(startStep.permissions).forEach(function(key) {\n    if (startStep.permissions[key] === 'editable') {\n      return editableCode.push(key);\n    }\n  });\n  return editableCode;\n};\n\n_getStartStepRequiredFields = function(fields, steps) {\n  var editableCode, requiredFields;\n  requiredFields = _getRequiredFields(fields);\n  editableCode = _getStartStepEditableFields(fields, steps);\n  return _.intersection(requiredFields, editableCode);\n};\n\n_getTemplateData = function(user, space, instance, options) {\n  var flow, form, form_version, locale, steedosData;\n  if (Meteor.isServer) {\n    form_version = InstanceReadOnlyTemplate.getInstanceFormVersion(instance);\n  } else {\n    form_version = WorkflowManager.getInstanceFormVersion(instance);\n  }\n  locale = _getLocale(user);\n  steedosData = {};\n  if (Meteor.isClient) {\n    steedosData = _.clone(WorkflowManager_format.getAutoformSchemaValues());\n    steedosData.insname = instance.name;\n    steedosData.ins_state = instance.state;\n    steedosData.ins_final_decision = instance.ins_final_decision;\n    steedosData.ins_code = instance.code;\n    steedosData.ins_is_archived = instance.is_archived;\n    steedosData.ins_is_deleted = instance.ins_is_deleted;\n    steedosData.applicant_name = instance.applicant_name;\n    steedosData.applicantContext = instance.applicant_name;\n  }\n  steedosData.instance = instance;\n  steedosData.form_version = form_version;\n  steedosData.locale = locale;\n  steedosData.utcOffset = user.utcOffset;\n  steedosData.space = instance.space;\n  steedosData.sessionUserId = user._id;\n  if (Meteor.isServer) {\n    if (options != null ? options.editable : void 0) {\n      form = db.forms.findOne({\n        _id: instance.form\n      });\n      flow = db.flows.findOne({\n        _id: instance.flow\n      });\n      steedosData.startStepEditableFields = _getStartStepEditableFields(form.current.fields, flow.current.steps);\n    }\n  }\n  return steedosData;\n};\n\nInstanceReadOnlyTemplate.formatDate = function(date, utcOffset) {\n  var passing;\n  if (Meteor.isServer) {\n    passing = false;\n  } else {\n    passing = true;\n  }\n  if (!utcOffset && utcOffset !== 0) {\n    utcOffset = 8;\n  }\n  return moment(date).utcOffset(utcOffset, passing).format(\"YYYY-MM-DD HH:mm\");\n};\n\nInstanceReadOnlyTemplate.formatTime = function(date) {\n  var utcOffset;\n  utcOffset = 0;\n  return moment(date).utcOffset(utcOffset).format(\"HH:mm\");\n};\n\nInstanceReadOnlyTemplate.getInstanceView = function(user, space, instance, options) {\n  var body, instanceCompiled, instanceRenderFunction, instanceTemplate, steedosData;\n  steedosData = _getTemplateData(user, space, instance, options);\n  steedosData.absolute = false;\n  if (options != null ? options.absolute : void 0) {\n    steedosData.absolute = true;\n  }\n  instanceTemplate = TemplateManager.getTemplate(instance, options != null ? options.templateName : void 0);\n  instanceTemplate = instanceTemplate.replace(/afSelectUser/g, \"afSelectUserRead\");\n  if (!(options != null ? options.editable : void 0)) {\n    instanceTemplate = instanceTemplate.replace(/afFormGroup/g, \"afFormGroupRead\");\n  }\n  instanceCompiled = SpacebarsCompiler.compile(instanceTemplate, {\n    isBody: true\n  });\n  instanceRenderFunction = eval(instanceCompiled);\n  Template.instance_readonly_view = new Blaze.Template(\"instance_readonly_view\", instanceRenderFunction);\n  Template.instance_readonly_view.steedosData = steedosData;\n  Template.instance_readonly_view.helpers(InstanceformTemplate.helpers);\n  InstanceReadOnlyTemplate.init(steedosData);\n  body = Blaze.toHTMLWithData(Template.instance_readonly_view, steedosData);\n  return \"<div id='instanceform' >\\n\t\" + body + \"\\n</div>\";\n};\n\nInstanceReadOnlyTemplate.getTracesView = function(user, space, instance, options) {\n  var body, form, steedosData, traceCompiled, traceRenderFunction, tracesHtml;\n  steedosData = _getTemplateData(user, space, instance);\n  form = db.forms.findOne(instance.form);\n  if (form.instance_style === \"table\" || (options != null ? options.templateName : void 0) === \"table\") {\n    tracesHtml = _getViewHtml('client/views/instance/traces_table.html');\n  } else {\n    tracesHtml = _getViewHtml('client/views/instance/traces.html');\n  }\n  traceCompiled = SpacebarsCompiler.compile(tracesHtml, {\n    isBody: true\n  });\n  traceRenderFunction = eval(traceCompiled);\n  Template.trace_readonly_view = new Blaze.Template(\"trace_readonly_view\", traceRenderFunction);\n  Template.trace_readonly_view.steedosData = steedosData;\n  Template.trace_readonly_view.helpers(TracesTemplate.helpers);\n  body = Blaze.toHTMLWithData(Template.trace_readonly_view, instance.traces);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getAttachmentView = function(user, space, instance) {\n  var attachmentCompiled, attachmentHtml, attachmentRenderFunction, body, steedosData;\n  steedosData = _getTemplateData(user, space, instance);\n  attachmentHtml = _getViewHtml('client/views/instance/instance_attachments.html');\n  attachmentCompiled = SpacebarsCompiler.compile(attachmentHtml, {\n    isBody: true\n  });\n  attachmentRenderFunction = eval(attachmentCompiled);\n  Template.attachments_readonly_view = new Blaze.Template(\"attachments_readonly_view\", attachmentRenderFunction);\n  Template.attachments_readonly_view.steedosData = steedosData;\n  Template.attachments_readonly_view.helpers(InstanceAttachmentTemplate.helpers);\n  body = Blaze.toHTMLWithData(Template.attachments_readonly_view);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getRelatedInstancesView = function(user, space, instance, options) {\n  var body, relatedInstancesCompiled, relatedInstancesHtml, relatedInstancesRenderFunction, steedosData;\n  steedosData = _getTemplateData(user, space, instance);\n  steedosData.absolute = false;\n  if (options != null ? options.absolute : void 0) {\n    steedosData.absolute = true;\n  }\n  relatedInstancesHtml = _getViewHtml('client/views/instance/related_instances.html');\n  relatedInstancesCompiled = SpacebarsCompiler.compile(relatedInstancesHtml, {\n    isBody: true\n  });\n  relatedInstancesRenderFunction = eval(relatedInstancesCompiled);\n  Template.related_instances_view = new Blaze.Template(\"related_instances_view\", relatedInstancesRenderFunction);\n  Template.related_instances_view.steedosData = steedosData;\n  Template.related_instances_view.helpers(RelatedInstances.helpers);\n  body = Blaze.toHTMLWithData(Template.related_instances_view, steedosData);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getRelatedRecordsView = function(user, space, instance, options) {\n  var body, relatedRecordsCompiled, relatedRecordsHtml, relatedRecordsRenderFunction, steedosData;\n  steedosData = _getTemplateData(user, space, instance);\n  steedosData.absolute = false;\n  if (options != null ? options.absolute : void 0) {\n    steedosData.absolute = true;\n  }\n  relatedRecordsHtml = _getViewHtml('client/views/instance/related_records.html');\n  relatedRecordsCompiled = SpacebarsCompiler.compile(relatedRecordsHtml, {\n    isBody: true\n  });\n  relatedRecordsRenderFunction = eval(relatedRecordsCompiled);\n  Template.related_records_view = new Blaze.Template(\"related_records_view\", relatedRecordsRenderFunction);\n  Template.related_records_view.steedosData = steedosData;\n  Template.related_records_view.helpers(RelatedRecords.helpers);\n  body = Blaze.toHTMLWithData(Template.related_records_view, steedosData);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getOnLoadScript = function(instance) {\n  var form_script, form_version;\n  form_version = WorkflowManager.getFormVersion(instance.form, instance.form_version);\n  form_script = form_version.form_script;\n  if (form_script && form_script.replace(/\\n/g, \"\").replace(/\\s/g, \"\").length > 0) {\n    form_script = \"CoreForm = {};CoreForm.instanceform = {};\" + form_script;\n    return form_script += \";if(CoreForm.form_OnLoad){window.onload = CoreForm.form_OnLoad();}\";\n  } else {\n    return form_script = \"\";\n  }\n};\n\nInstanceReadOnlyTemplate.getInstanceHtml = function(user, space, instance, options) {\n  var allCssLink, attachment, body, creatorService, cssHref, form, formDescription, formDescriptionHtml, html, ins_record_ids, instanceBoxStyle, instance_style, jqHref, locale, onLoadScript, openFileScript, ref, ref1, related_instances, related_records, showTracesBtn, showTracesScript, trace, traceCheck, width;\n  body = InstanceReadOnlyTemplate.getInstanceView(user, space, instance, options);\n  onLoadScript = InstanceReadOnlyTemplate.getOnLoadScript(instance);\n  creatorService = (ref = Meteor.settings[\"public\"].webservices) != null ? (ref1 = ref.creator) != null ? ref1.url : void 0 : void 0;\n  ins_record_ids = instance.record_ids;\n  locale = _getLocale(user);\n  openFileScript = \"if(window.isNode && isNode()){\\n\tattachs = document.getElementsByClassName(\\\"ins_attach_href\\\");\\n\tfor(var i = 0; i < attachs.length; i++){\\n\t\tattach = attachs[i];\\n\t\tattach.addEventListener(\\\"click\\\", function(e){\\n\t\t\tif(isImage(this.dataset.type) || isHtml(this.dataset.type)){\\n\t\t\t\te.preventDefault();\\n\t\t\t\topenWindow(\\\"/api/files/instances/\\\" + this.dataset.id);\\n\t\t\t}else if(nw_core.canOpenFile(this.dataset.name)){\\n\t\t\t\te.preventDefault();\\n\t\t\t\tnw_core.openFile(this.href, this.dataset.name)\\n\t\t\t}\\n\t\t});\\n\t}\\n}\\n\\nvar flow = \\\"\" + instance.flow + \"\\\";\\nvar space = \\\"\" + instance.space + \"\\\";\\n\\nfunction getCookie(name){\\n\tlet pattern = RegExp(name + \\\"=.[^;]*\\\")\\n\tlet matched = document.cookie.match(pattern)\\n\tif(matched){\\n\t\tlet cookie = matched[0].split('=')\\n\t\treturn cookie[1]\\n\t}\\n\treturn ''\\n}\\n\\nvar records = document.getElementsByClassName(\\\"ins-related-records\\\");\\nfor(var i = 0; i < records.length; i++){\\n\t\tvar record = records[i];\\n\t\trecord.addEventListener(\\\"click\\\", function(e){\\n\t\t\tvar creatorService = \\\"\" + creatorService + \"\\\"\\n\t\t\tvar ins_record_ids = \" + (JSON.stringify(ins_record_ids)) + \"\\n\t\t\tif(creatorService && ins_record_ids && ins_record_ids.length > 0){\\n\t\t\t\tvar objcetName = ins_record_ids[0].o\\n\t\t\t\tvar id = ins_record_ids[0].ids[0]\\n\t\t\t\tvar uobj = {};\\n\t\t\t\tuobj[\\\"X-User-Id\\\"] = getCookie(\\\"X-User-Id\\\");\\n\t\t\t\tuobj[\\\"X-Auth-Token\\\"] = getCookie(\\\"X-Auth-Token\\\");\\n\t\t\t\tredirectUrl = creatorService + \\\"app/-/\\\" + objcetName + \\\"/view/\\\" + id + \\\"?\\\" + $.param(uobj);\\n\t\t\t\topenWindow(redirectUrl);\\n\t\t\t}\\n\t\t});\\n\t}\\n\";\n  if (!Steedos.isMobile()) {\n    form = db.forms.findOne(instance.form);\n    if ((form != null ? form.instance_style : void 0) === 'table') {\n      instance_style = \"instance-table\";\n    }\n  }\n  if ((options != null ? options.templateName : void 0) === 'table') {\n    instance_style = \"instance-table\";\n  }\n  if (options != null ? options.instance_style : void 0) {\n    instance_style = options.instance_style;\n  }\n  if (!options || options.showTrace === true) {\n    trace = InstanceReadOnlyTemplate.getTracesView(user, space, instance);\n  } else {\n    trace = \"\";\n  }\n  instanceBoxStyle = \"\";\n  if (instance && instance.final_decision) {\n    if (instance.final_decision === \"approved\") {\n      instanceBoxStyle = \"box-success\";\n    } else if (instance.final_decision === \"rejected\") {\n      instanceBoxStyle = \"box-danger\";\n    }\n  }\n  if (!options || options.showAttachments === true) {\n    attachment = InstanceReadOnlyTemplate.getAttachmentView(user, space, instance);\n    related_instances = InstanceReadOnlyTemplate.getRelatedInstancesView(user, space, instance, options);\n    related_records = InstanceReadOnlyTemplate.getRelatedRecordsView(user, space, instance, options);\n  } else {\n    attachment = \"\";\n    related_instances = \"\";\n    related_records = \"\";\n  }\n  width = \"960px\";\n  if (options != null ? options.width : void 0) {\n    width = \"\";\n  }\n  cssHref = Meteor.absoluteUrl(\"steedos-css\");\n  jqHref = Meteor.absoluteUrl(\"website/libs/jquery.min.js\");\n  allCssLink = \"<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" class=\\\"__meteor-css__\\\" href=\\\"\" + cssHref + \"\\\">\";\n  traceCheck = \"\";\n  if (!_.isEmpty(trace)) {\n    traceCheck = \"checked\";\n  }\n  if ((options != null ? options.tagger : void 0) === 'email' || (options != null ? options.editable : void 0)) {\n    showTracesBtn = \"\";\n  } else {\n    showTracesBtn = \"<div class=\\\"navigation-bar btn-group no-print\\\" style=\\\"min-width: 600px; z-index: 999; box-sizing: border-box;\\\">\\n\t<div class=\\\"print-tool\\\">\\n\t\t<label class=\\\"cbx-label\\\"><input type=\\\"checkbox\\\" class=\\\"cbx-print cbx-print-attachments\\\" id=\\\"cbx-print-attachments\\\" checked=\\\"checked\\\"><span>\" + (TAPi18n.__('instance_attachment', {}, locale)) + \"</span></label>\\n\t\t<label class=\\\"cbx-label\\\"><input type=\\\"checkbox\\\" class=\\\"cbx-print cbx-print-traces\\\" id=\\\"cbx-print-traces\\\" checked=\\\"\" + traceCheck + \"\\\"><span>\" + (TAPi18n.__('instance_approval_history', {}, locale)) + \"</span></label>\\n\t</div>\\n</div>\";\n  }\n  showTracesScript = \"$( document ).ready(function(){\\n\tvar b = document.getElementById('cbx-print-traces');\\n\tvar t = document.getElementsByClassName('instance-traces')[0];\\n\tif (b && b.checked && t){\\n\t\tt.style = 'display: block;'\\n\t} else if(t){\\n\t\tt.style = 'display: none;'\\n\t}\\n\tif(b){\\n\t\tb.addEventListener('change', function(e){\\n\t\t\tif (e.target.checked){\\n\t\t\t\tt.style = 'display: block;'\\n\t\t\t} else {\\n\t\t\t\tt.style = 'display: none;'\\n\t\t\t}\\n\t\t});\\n\t}\\n\\n\\n\tvar attachmentsCheckbox = document.getElementById('cbx-print-attachments');\\n\tvar attachmentsView = document.getElementsByClassName('attachments-section')[0];\\n\tif (attachmentsCheckbox && attachmentsCheckbox.checked && attachmentsView){\\n\t\tattachmentsView.style = 'display: block;'\\n\t} else if(attachmentsView){\\n\t\tattachmentsView.style = 'display: none;'\\n\t}\\n\tif(attachmentsCheckbox){\\n\t\tattachmentsCheckbox.addEventListener('change', function(e){\\n\t\t\tif (e.target.checked){\\n\t\t\t\tattachmentsView.style = 'display: block;'\\n\t\t\t} else {\\n\t\t\t\tattachmentsView.style = 'display: none;'\\n\t\t\t}\\n\t\t});\\n\t}\\n});\\n\";\n  if (options != null ? options.styles : void 0) {\n    allCssLink = \"\";\n  }\n  form = db.forms.findOne({\n    _id: instance.form\n  });\n  formDescriptionHtml = \"\";\n  if (form) {\n    formDescription = form.description;\n    if (formDescription) {\n      formDescription = formDescription.replace(/\\n/g, \"<br/>\");\n      formDescriptionHtml = \"<div class=\\\"box-header  with-border instance-header\\\">\\n\t<div>\\n\t\t\" + formDescription + \"\\n\t</div>\\n</div>\";\n    }\n  }\n  html = \"<!DOCTYPE html>\\n<html>\\n\t<head>\\n\t\t<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; charset=UTF-8\\\"/>\\n\t\t\" + allCssLink + \"\\n\t\t<script src=\\\"\" + jqHref + \"\\\" type=\\\"text/javascript\\\"></script>\\n\t\t<script src=\\\"/js/nw_core.js\\\" type=\\\"text/javascript\\\"></script>\\n\t\t\" + (options.plugins || \"\") + \"\\n\\n\t\t<style>\\n\t\t\t.steedos{\\n\t\t\t\twidth: \" + width + \";\\n\t\t\t\tmargin-left: auto;\\n\t\t\t\tmargin-right: auto;\\n\t\t\t}\\n\\n\t\t\t.instance-view .instance-name{\\n\t\t\t\tdisplay: inline !important\\n\t\t\t}\\n\t\t\t.box-tools{\\n\t\t\t\tdisplay: none;\\n\t\t\t}\\n\t\t\t.box.collapsed-box .box-body,.box.collapsed-box .box-footer {\\n\t\t\t  display: block;\\n\t\t\t}\\n\\n\t\t\tbody{\\n\t\t\t\tbackground: azure !important;\\n\t\t\t}\\n\\n\t\t\t.instance-view .instance-traces{\\n\t\t\t\tpadding-left: 15px;\\n\t\t\t\tpadding-right: 15px;\\n\t\t\t}\\n\\n\t\t\t.antd-ImageControl-item {\\n\t\t\tborder-radius: var(--ImageControl-addBtn-borderRadius);\\n\t\t\tvertical-align: top;\\n\t\t\tpadding: var(--gap-xs);\\n\t\t\tdisplay: inline-block;\\n\t\t\tmargin-right: var(--gap-base);\\n\t\t\tmargin-bottom: var(--gap-base);\\n\t\t\tposition: relative;\\n\t\t\twidth: 7.5rem;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item.is-invalid {\\n\t\t\tpadding: 0;\\n\t\t\tborder-color: var(--FileControl-danger-color);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item svg.icon-refresh {\\n\t\t\ttransform: rotate(180deg);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-filename {\\n\t\t\tdisplay: inline-flex;\\n\t\t\tflex-direction: column;\\n\t\t\tjustify-content: center;\\n\t\t\talign-items: center;\\n\t\t\tcolor: var(--FileControl-danger-color);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-filename > svg.icon-image {\\n\t\t\tmargin-bottom: 8px;\\n\t\t\twidth: 24px;\\n\t\t\theight: 24px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-filename > span {\\n\t\t\tmax-width: 100%;\\n\t\t\toverflow: hidden;\\n\t\t\twhite-space: nowrap;\\n\t\t\ttext-overflow: ellipsis;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-image {\\n\t\t\twidth: 100%;\\n\t\t\theight: 100%;\\n\t\t\tpadding: 0;\\n\t\t\tborder: none;\\n\t\t\tdisplay: block;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemClear {\\n\t\t\tposition: absolute;\\n\t\t\tcursor: pointer;\\n\t\t\tcolor: #999;\\n\t\t\ttop: 5px;\\n\t\t\tright: 5px;\\n\t\t\tline-height: 1;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemClear > svg {\\n\t\t\ttop: 0;\\n\t\t\twidth: 10px;\\n\t\t\theight: 10px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemInfo {\\n\t\t\tdisplay: inline-flex;\\n\t\t\twidth: 110px;\\n\t\t\theight: 110px;\\n\t\t\tjustify-content: center;\\n\t\t\talign-items: center;\\n\t\t\talign-content: center;\\n\t\t\tflex-wrap: wrap;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemInfo > p {\\n\t\t\twidth: 100%;\\n\t\t\ttext-align: center;\\n\t\t\tfont-size: 12px;\\n\t\t\tmargin-bottom: 5px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-progress {\\n\t\t\twidth: 70px;\\n\t\t\theight: 5px;\\n\t\t\tbackground: #ebebeb;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-progressValue {\\n\t\t\theight: 5px;\\n\t\t\tborder-radius: var(--ImageControl-progress-borderRadius);\\n\t\t\tdisplay: block;\\n\t\t\tbackground: var(--info);\\n\t\t\tmin-width: 10%;\\n\t\t\ttransition: ease-out width var(--animation-duration);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item.is-invalid .antd-ImageControl-itemClear {\\n\t\t\tdisplay: none;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item.is-invalid:hover .antd-ImageControl-itemClear {\\n\t\t\tdisplay: block;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-errorMsg {\\n\t\t\tcolor: var(--danger);\\n\t\t\tmargin: 5px 0 0;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-uploadBtn {\\n\t\t\tmargin-top: 5px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-cropperWrapper {\\n\t\t\tposition: relative;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-cropperWrapper img {\\n\t\t\tmax-width: 100%;\\n\t\t\tmax-height: 400px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-croperToolbar {\\n\t\t\tdisplay: inline-flex;\\n\t\t\tposition: absolute;\\n\t\t\tright: 0;\\n\t\t\tbottom: 0;\\n\t\t\tflex-direction: column;\\n\t\t\talign-items: flex-end;\\n\t\t\tbackground: #fff;\\n\t\t\tborder-radius: 4px;\\n\t\t\tmargin: 0.5rem;\\n\t\t\tbox-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.1);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-croperToolbar > a {\\n\t\t\tcolor: var(--Form-item-fontColor);\\n\t\t\tpadding: 2px 5px;\\n\t\t\tcursor: pointer;\\n\t\t\tfont-size: 18px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-croperToolbar > a:hover {\\n\t\t\tcolor: var(--link-color);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-acceptTip {\\n\t\t\theight: 120px;\\n\t\t\tcolor: #999;\\n\t\t\tborder: 2px dashed var(--borderColor);\\n\t\t\tborder-color: var(--info);\\n\t\t\tbackground: #f3f9fe;\\n\t\t\tborder-radius: var(--borderRadius);\\n\t\t\tline-height: 120px;\\n\t\t\ttext-align: center;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-fixed-size {\\n\t\t\twidth: 100%;\\n\t\t\theight: 100%;\\n\t\t\tpadding: 0;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-fixed-size .antd-ImageControl-itemOverlay {\\n\t\t\twidth: 100%;\\n\t\t\theight: 100%;\\n\t\t\t}\\n\\n\t\t\t.antd-Images {\\n\t\t\t\tdisplay: flex;\\n\t\t\t\tflex-wrap: wrap;\\n\t\t\t\tmargin: calc(var(--gap-xs) * -1);\\n\t\t\t\t}\\n\t\t\t\t.antd-Images-item {\\n\t\t\t\tdisplay: flex;\\n\t\t\t\tmargin: var(--gap-xs);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image {\\n\t\t\t\tborder: var(--borderWidth) solid var(--borderColor);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image--thumb {\\n\t\t\t\tdisplay: inline-block;\\n\t\t\t\tpadding: var(--gap-xs);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumbWrap {\\n\t\t\t\tposition: relative;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-image {\\n\t\t\t\tdisplay: block;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-image--loading {\\n\t\t\t\tvisibility: hidden;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image--original .antd-Image-image {\\n\t\t\t\tmax-width: 100%;\\n\t\t\t\tmax-height: 100%;\\n\t\t\t\twidth: auto;\\n\t\t\t\tmargin: auto;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb {\\n\t\t\t\twidth: 6.875rem;\\n\t\t\t\theight: 6.875rem;\\n\t\t\t\tposition: relative;\\n\t\t\t\toverflow: hidden;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb > img {\\n\t\t\t\tposition: absolute;\\n\t\t\t\tleft: 50%;\\n\t\t\t\ttop: 50%;\\n\t\t\t\tmax-height: 100%;\\n\t\t\t\twidth: auto;\\n\t\t\t\ttransform: translate(-50%, -50%);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-info {\\n\t\t\t\tpadding: 5px 10px;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image--thumb .antd-Image-info {\\n\t\t\t\twidth: 6.875rem;\\n\t\t\t\tpadding: 0;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--4-3 {\\n\t\t\t\theight: 5.15625rem;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--16-9 {\\n\t\t\t\theight: 3.8671875rem;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--fixed-size {\\n\t\t\t\tmin-width: 6.875rem;\\n\t\t\t\tmin-height: 6.875rem;\\n\t\t\t\twidth: 100%;\\n\t\t\t\tpadding: 0;\\n\t\t\t\theight: 100%;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb {\\n\t\t\t\twidth: 100%;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb > img {\\n\t\t\t\twidth: auto;\\n\t\t\t\theight: 100%;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--w-full > img {\\n\t\t\t\twidth: 100%;\\n\t\t\t\theight: auto;\\n\t\t\t\t}\\n\\n\t\t\t\" + ((options != null ? options.styles : void 0) || \"\") + \"\\n\\n\t\t\t\" + ((options != null ? options.add_styles : void 0) || \"\") + \"\\n\t\t</style>\\n\t</head>\\n\t<body>\\n\t\t<div class=\\\"steedos workflow instance-print\\\">\\n\t\t\t<div class=\\\"skin-green skin-admin-lte\\\">\\n\t\t\t\t<div class=\\\"wrapper\\\">\\n\t\t\t\t\t<div class=\\\"content-wrapper\\\">\\n\t\t\t\t\t\t\" + showTracesBtn + \"\\n\t\t\t\t\t\t<div class=\\\"instance-print\\\">\\n\t\t\t\t\t\t\t<div class=\\\"instance \" + instance_style + \"\\\">\\n\t\t\t\t\t\t\t\t<form name=\\\"instanceForm\\\">\\n\t\t\t\t\t\t\t\t\t<div class=\\\"instance-form box \" + instanceBoxStyle + \"\\\">\\n\t\t\t\t\t\t\t\t\t\t\" + formDescriptionHtml + \"\\n\t\t\t\t\t\t\t\t\t\t<div class=\\\"box-body\\\">\\n\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"col-md-12\\\" style=\\\"box-sizing: border-box;\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t<div class='attachments-section'>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + attachment + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + related_instances + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + related_records + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\" + body + \"\\n\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t</form>\\n\t\t\t\t\t\t\t\t\" + trace + \"\\n\t\t\t\t\t\t\t</div>\\n\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t</div>\\n\t\t</div>\\n\t</body>\\n\t<script>\" + openFileScript + \";\" + onLoadScript + \";\" + showTracesScript + \"</script>\\n</html>\";\n  return html;\n};\n","TemplateManager = {};\n\nformId = 'instanceform';\n\n\nTemplateManager.instance_title = ()->\n\tpageTitle = \"\"\"\n\t\t{{instance.name}}\n\t\"\"\"\n\n\tpageTitleTrClass = \"instance-name\"\n\n\tif CoreForm?.pageTitleFieldName\n\t\tpageTitle = \"\"\"\n\t\t\t\t{{> afFormGroup name=\"#{CoreForm.pageTitleFieldName}\" label=false}}\n\t\t\"\"\"\n\t\tpageTitleTrClass = \"\"\n\n\tif CoreForm?.pageTitle\n\t\tpageTitle = \"\"\"\n\t\t\t#{CoreForm.pageTitle}\n\t\t\"\"\"\n\t\tpageTitleTrClass = \"\"\n\n\tval =\n\t\tpageTitle: pageTitle\n\t\tpageTitleTrClass: pageTitleTrClass\n\n\treturn val\n\nTemplateManager.handleTableTemplate = (instance, _export) ->\n\n\ttemplate = \"\"\"\n\t<div class='instance-template'>\n\t\t<table class=\"table-page-title form-table no-border text-align-center\" style=\"width: 100%;display: inline-table;\">\n\t\t\t<tr class=\"#{this.instance_title().pageTitleTrClass}\">\n\t\t\t\t<td class=\"instance-table-name-td page-title\">\n\t\t\t\t\t#{this.instance_title().pageTitle}\n\t\t\t\t</td>\n\t\t\t</tr>\n\n\t\t</table>\n\t\t<table class=\"table-page-body form-table\">\n\t\t\t\t<tr style=\"height:0px\">\n\t\t\t\t\t<th style='width: 16%'></th>\n\t\t\t\t\t<th></th>\n\t\t\t\t\t<th style='width: 16%'></th>\n\t\t\t\t\t<th></th>\n\t\t\t\t</tr>\n\t\"\"\";\n\n\ttable_fields = InstanceformTemplate.helpers.table_fields(instance)\n\n\ttable_fields && table_fields.forEach (table_field)->\n\n\t\trequired = \"\"\n\t\tif !CoreForm?.pageTitleFieldName || CoreForm?.pageTitleFieldName != table_field.code\n\t\t\tif table_field.is_required\n\t\t\t\trequired = \"is-required\"\n\n\t\t\tif _export\n\t\t\t\trequired = \"\";\n\n\t\t\tpureCode = Steedos.removeSpecialCharacter(table_field.code);\n\n\t\t\tif InstanceformTemplate.helpers.isOpinionField(table_field)\n\t\t\t\ttemplate += table_field.tr_start\n\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t<td class=\"td-title #{required}\">\n\t\t\t\t\t\t{{afFieldLabelText name=\"#{table_field.code}\"}}\n\t\t\t\t\t</td>\n\t\t\t\t\t<td class=\"td-field opinion-field opinion-field-#{pureCode} automatic\" colspan = \"#{table_field.td_colspan}\">\n\t\t\t\t\t\t{{> instanceSignText name=\"#{table_field.code}\"}}\n\t\t\t\t\t</td>\n\t\t\t\t\"\"\"\n\t\t\t\ttemplate += table_field.tr_end\n\t\t\telse\n\t\t\t\tif InstanceformTemplate.helpers.includes(table_field.type, 'section,table')\n\t\t\t\t\ttemplate += table_field.tr_start\n\t\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\t<td class=\"td-childfield td-childfield-#{pureCode}\" colspan = \"#{table_field.td_colspan}\">\n\t\t\t\t\t\t   {{> afFormGroup name=\"#{table_field.code}\" label=false}}\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\"\"\"\n\t\t\t\t\ttemplate += table_field.tr_end\n\t\t\t\telse\n\t\t\t\t\ttemplate += table_field.tr_start\n\n\t\t\t\t\tif _export\n\t\t\t\t\t\ttitle_permission = \"\"\n\t\t\t\t\t\tfield_permission = \"\"\n\t\t\t\t\telse\n\t\t\t\t\t\ttitle_permission = \"title-\" + table_field.permission\n\t\t\t\t\t\tfield_permission = \"field-\" + table_field.permission\n\n\t\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\t<td class=\"td-title td-title-#{pureCode} #{title_permission} #{required}\">\n\t\t\t\t\t\t\t{{afFieldLabelText name=\"#{table_field.code}\"}}\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\t<td class=\"td-field td-field-#{pureCode} #{field_permission}\" colspan = \"#{table_field.td_colspan}\">\n\t\t\t\t\t\t\t{{> afFormGroup name=\"#{table_field.code}\" label=false}}\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\"\"\"\n\t\t\t\t\ttemplate += table_field.tr_end\n\n\ttemplate += \"\"\"\n\t\t</table>\n\n\t\t<table class=\"table-page-footer form-table no-border\">\n\t\t\t<tr class=\"applicant-wrapper\">\n\t\t\t\t<td class=\"nowrap\">\n\t\t\t\t\t<div class='inline-left'>\n\t\t\t\t\t\t<label class=\"control-label\">{{_t \"instance_initiator\"}}：</label>\n\t\t\t\t\t</div>\n\t\t\t\t\t<div class='instance-table-wrapper-td inline-left'>\n\t\t\t\t\t\t{{>Template.dynamic  template=\"afSelectUser\" data=applicantContext}}\n\t\t\t\t\t</div>\n\t\t\t\t</td>\n\t\t\t\t<td class=\"nowrap\">\n\t\t\t\t\t<div class='pull-left'>\n\t\t\t\t\t\t<div class='inline-left'>\n\t\t\t\t\t\t\t<label>{{_t \"instance_submit_date\"}}：</label>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<div class='inline-right'>\n\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t{{formatDate instance.submit_date '{\"format\":\"YYYY-MM-DD\"}'}}\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t</td>\n\t\t\t</tr>\n\t\t</table>\n\t</div>\n\t\"\"\"\n\treturn template\n\n#此处模板公用与：instance 编辑、查看、打印、转发时生成附件、发送邮件body部分(table 模板)\n#如果有修改，请测试确认其他功能是否正常。\nTemplateManager._template =\n\tdefault: (instance)->\n\n\t\ttemplate = \"\"\"\n\t\t\t<div class=\"with-border col-md-12\">\n\t\t\t\t<div class=\"instance-name\">\n\t\t\t\t\t<h3 class=\"box-title\">#{TemplateManager.instance_title().pageTitle}</h3>\n\t\t\t\t\t<span class=\"help-block\"></span>\n\t\t\t\t</div>\n\t\t\t\t<span class=\"help-block\"></span>\n\t\t\t</div>\n\t\t\t{{#each steedos_form.fields}}\n\t\t\t\t{{#if isOpinionField this}}\n\t\t\t\t\t<div class=\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\">\n\t\t\t\t\t\t<div class=\"form-group automatic opinion-field-{{this.code}}\">\n\t\t\t\t\t\t\t<label class=\"control-label\">{{afFieldLabelText name=this.code}}</label>\n\n\t\t\t\t\t\t\t{{> instanceSignText name=this.code}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if includes this.type 'section,table'}}\n\t\t\t\t\t\t<div class=\"col-md-12 field-{{this.code}}\">\n\t\t\t\t\t\t\t{{> afFormGroup name=this.code label=false}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t<div class=\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\">\n\t\t\t\t\t\t{{> afFormGroup name=this.code}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/each}}\n\t\t\t<div class=\"col-md-12\">\n\t\t\t\t<div class=\"applicant-wrapper form-group form-horizontal\">\n\t\t\t\t<div class=\"input-group\">\n\t\t\t\t\t<div class=\"input-group-addon\">\n\t\t\t\t\t  {{_t \"instance_initiator\"}}&nbsp;:\n\t\t\t\t\t</div>\n\t\t\t\t\t{{>Template.dynamic  template=\"afSelectUser\" data=applicantContext}}\n\t\t\t\t  </div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\"\"\"\n\t\treturn template\n\n\ttable: (instance)->\n\t\treturn TemplateManager.handleTableTemplate(instance)\n#\ttable: '''\n#\t\t<table class=\"box-header  with-border\" style=\"width: 100%;display: inline-table;\">\n#\t\t\t<tr class=\"instance-name\">\n#\t\t\t\t<td class=\"instance-table-name-td\">\n#\t\t\t\t\t<h3 class=\"box-title\">{{instance.name}}</h3>\n#\t\t\t\t\t<span class=\"help-block\"></span>\n#\t\t\t\t</td>\n#\t\t\t</tr>\n#            <tr class=\"applicant-wrapper\">\n#\t\t\t\t<td class=\"instance-table-wrapper-td\">\n#\t\t\t\t\t<label class=\"control-label\">{{_t \"instance_initiator\"}}&nbsp;:</label>\n#\t\t\t\t\t{{>Template.dynamic  template=\"afSelectUser\" data=applicantContext}}\n#\t\t\t\t</td>\n#\t\t\t</tr>\n#        </table>\n#\t\t<table class=\"form-table\">\n#\t\t    {{#each table_fields}}\n#\t\t\t\t{{#if isOpinionField this}}\n#\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t<td class=\"td-title {{#if is_required}}is-required{{/if}}\">\n#\t\t\t\t\t\t\t{{afFieldLabelText name=this.code}}\n#\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t<td class=\"td-field opinion-field\" colspan = '{{td_colspan}}'>\n#\t\t\t\t\t\t\t{{> instanceSignText step=(getOpinionFieldStepName this) default=''}}\n#\t\t\t\t\t\t</td>\n#\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t{{else}}\n#\t\t\t\t\t{{#if includes this.type 'section,table'}}\n#\t\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\t<td class=\"td-childfield\" colspan = '{{td_colspan}}'>\n#\t\t\t\t\t\t\t   {{> afFormGroup name=this.code label=false}}\n#\t\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t\t{{else}}\n#\t\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\t<td class=\"td-title {{#if is_required}}is-required{{/if}}\">\n#\t\t\t\t\t\t\t\t{{afFieldLabelText name=this.code}}\n#\t\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t\t<td class=\"td-field {{permission}}\" colspan = '{{td_colspan}}'>\n#\t\t\t\t\t\t\t\t{{> afFormGroup name=this.code label=false}}\n#\t\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t\t{{/if}}\n#\t\t\t\t{{/if}}\n#\n#\t\t    {{/each}}\n#\t\t</table>\n#\t'''\n\nTemplateManager._templateHelps =\n\tapplicantContext: ->\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {\n\t\t\t\tname: 'ins_applicant',\n\t\t\t\tid: 'ins_applicant',\n\t\t\t\tclass: 'selectUser form-control',\n\t\t\t\tstyle: 'padding:6px 12px;width:140px;display:inline'\n\t\t\t}\n\t\t}\n#\t\tif not steedos_instance || steedos_instance.state != \"draft\"\n\t\tdata.atts.disabled = true\n\t\treturn data;\n\ninstanceId: ->\n\treturn 'instanceform';#\"instance_\" + Session.get(\"instanceId\");\n\nform_types: ->\n\tif ApproveManager.isReadOnly()\n\t\treturn 'disabled';\n\telse\n\t\treturn 'method';\n\nsteedos_form: ->\n\tform_version = WorkflowManager.getInstanceFormVersion();\n\tif form_version\n\t\treturn form_version\n\ninnersubformContext: (obj)->\n\tdoc_values = WorkflowManager_format.getAutoformSchemaValues();\n\tobj[\"tableValues\"] = if doc_values then doc_values[obj.code] else []\n\tobj[\"formId\"] = formId;\n\treturn obj;\n\ninstance: ->\n\tSession.get(\"change_date\")\n\tif (Session.get(\"instanceId\"))\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\treturn steedos_instance;\n\nequals: (a, b) ->\n\treturn (a == b)\n\nincludes: (a, b) ->\n\treturn b.split(',').includes(a);\n\nfields: ->\n\tform_version = WorkflowManager.getInstanceFormVersion();\n\tif form_version\n\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\ndoc_values: ->\n\tWorkflowManager_format.getAutoformSchemaValues();\n\ninstance_box_style: ->\n\tbox = Session.get(\"box\")\n\tif box == \"inbox\" || box == \"draft\"\n\t\tjudge = Session.get(\"judge\")\n\t\tif judge\n\t\t\tif (judge == \"approved\")\n\t\t\t\treturn \"box-success\"\n\t\t\telse if (judge == \"rejected\")\n\t\t\t\treturn \"box-danger\"\n\tins = WorkflowManager.getInstance();\n\tif ins && ins.final_decision\n\t\tif ins.final_decision == \"approved\"\n\t\t\treturn \"box-success\"\n\t\telse if (ins.final_decision == \"rejected\")\n\t\t\treturn \"box-danger\"\n\n\nTemplateManager.getTemplate = (instance, templateName) ->\n\tflow = db.flows.findOne(instance.flow);\n\tform = db.forms.findOne(instance.form);\n\n\tif templateName\n\t\tif templateName == 'table'\n\t\t\treturn TemplateManager._template.table(instance)\n\t\treturn TemplateManager._template.default(instance)\n\n\tif Session?.get(\"instancePrint\")\n\t\tif flow?.print_template\n\t\t\treturn \"<div class='instance-template'>\" + flow.print_template + \"</div>\"\n\t\telse\n\t\t\tif flow?.instance_template\n\t\t\t\treturn \"<div class='instance-template'>\" + flow.instance_template + \"</div>\"\n\t\t\telse\n\t\t\t\treturn TemplateManager._template.table(instance)\n\telse\n\t\tif Steedos.isMobile()\n\t\t\treturn TemplateManager._template.default(instance)\n\n\t\tif flow?.instance_template\n\t\t\treturn \"<div class='instance-template'>\" + flow.instance_template + \"</div>\"\n\n\t\tif form?.instance_style\n\t\t\tif form.instance_style == 'table'\n\t\t\t\treturn TemplateManager._template.table(instance)\n\t\t\treturn TemplateManager._template.default(instance)\n\t\telse\n\t\t\treturn TemplateManager._template.default(instance)\n\n#TemplateManager.exportTemplate = (flowId) ->\n#\ttemplate = TemplateManager.getTemplate(flowId);\n#\n#\tflow = WorkflowManager.getFlow(flowId);\n#\n#\tif flow?.instance_template\n#\t\treturn template;\n#\n#\treturn template;\n\n","var formId;                 \n\nTemplateManager = {};\n\nformId = 'instanceform';\n\nTemplateManager.instance_title = function() {\n  var pageTitle, pageTitleTrClass, val;\n  pageTitle = \"{{instance.name}}\";\n  pageTitleTrClass = \"instance-name\";\n  if (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) {\n    pageTitle = \"{{> afFormGroup name=\\\"\" + CoreForm.pageTitleFieldName + \"\\\" label=false}}\";\n    pageTitleTrClass = \"\";\n  }\n  if (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitle : void 0) {\n    pageTitle = \"\" + CoreForm.pageTitle;\n    pageTitleTrClass = \"\";\n  }\n  val = {\n    pageTitle: pageTitle,\n    pageTitleTrClass: pageTitleTrClass\n  };\n  return val;\n};\n\nTemplateManager.handleTableTemplate = function(instance, _export) {\n  var table_fields, template;\n  template = \"<div class='instance-template'>\\n\t<table class=\\\"table-page-title form-table no-border text-align-center\\\" style=\\\"width: 100%;display: inline-table;\\\">\\n\t\t<tr class=\\\"\" + (this.instance_title().pageTitleTrClass) + \"\\\">\\n\t\t\t<td class=\\\"instance-table-name-td page-title\\\">\\n\t\t\t\t\" + (this.instance_title().pageTitle) + \"\\n\t\t\t</td>\\n\t\t</tr>\\n\\n\t</table>\\n\t<table class=\\\"table-page-body form-table\\\">\\n\t\t\t<tr style=\\\"height:0px\\\">\\n\t\t\t\t<th style='width: 16%'></th>\\n\t\t\t\t<th></th>\\n\t\t\t\t<th style='width: 16%'></th>\\n\t\t\t\t<th></th>\\n\t\t\t</tr>\";\n  table_fields = InstanceformTemplate.helpers.table_fields(instance);\n  table_fields && table_fields.forEach(function(table_field) {\n    var field_permission, pureCode, required, title_permission;\n    required = \"\";\n    if (!(typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) || (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) !== table_field.code) {\n      if (table_field.is_required) {\n        required = \"is-required\";\n      }\n      if (_export) {\n        required = \"\";\n      }\n      pureCode = Steedos.removeSpecialCharacter(table_field.code);\n      if (InstanceformTemplate.helpers.isOpinionField(table_field)) {\n        template += table_field.tr_start;\n        template += \"<td class=\\\"td-title \" + required + \"\\\">\\n\t{{afFieldLabelText name=\\\"\" + table_field.code + \"\\\"}}\\n</td>\\n<td class=\\\"td-field opinion-field opinion-field-\" + pureCode + \" automatic\\\" colspan = \\\"\" + table_field.td_colspan + \"\\\">\\n\t{{> instanceSignText name=\\\"\" + table_field.code + \"\\\"}}\\n</td>\";\n        return template += table_field.tr_end;\n      } else {\n        if (InstanceformTemplate.helpers.includes(table_field.type, 'section,table')) {\n          template += table_field.tr_start;\n          template += \"<td class=\\\"td-childfield td-childfield-\" + pureCode + \"\\\" colspan = \\\"\" + table_field.td_colspan + \"\\\">\\n   {{> afFormGroup name=\\\"\" + table_field.code + \"\\\" label=false}}\\n</td>\";\n          return template += table_field.tr_end;\n        } else {\n          template += table_field.tr_start;\n          if (_export) {\n            title_permission = \"\";\n            field_permission = \"\";\n          } else {\n            title_permission = \"title-\" + table_field.permission;\n            field_permission = \"field-\" + table_field.permission;\n          }\n          template += \"<td class=\\\"td-title td-title-\" + pureCode + \" \" + title_permission + \" \" + required + \"\\\">\\n\t{{afFieldLabelText name=\\\"\" + table_field.code + \"\\\"}}\\n</td>\\n<td class=\\\"td-field td-field-\" + pureCode + \" \" + field_permission + \"\\\" colspan = \\\"\" + table_field.td_colspan + \"\\\">\\n\t{{> afFormGroup name=\\\"\" + table_field.code + \"\\\" label=false}}\\n</td>\";\n          return template += table_field.tr_end;\n        }\n      }\n    }\n  });\n  template += \"\t</table>\\n\\n\t<table class=\\\"table-page-footer form-table no-border\\\">\\n\t\t<tr class=\\\"applicant-wrapper\\\">\\n\t\t\t<td class=\\\"nowrap\\\">\\n\t\t\t\t<div class='inline-left'>\\n\t\t\t\t\t<label class=\\\"control-label\\\">{{_t \\\"instance_initiator\\\"}}：</label>\\n\t\t\t\t</div>\\n\t\t\t\t<div class='instance-table-wrapper-td inline-left'>\\n\t\t\t\t\t{{>Template.dynamic  template=\\\"afSelectUser\\\" data=applicantContext}}\\n\t\t\t\t</div>\\n\t\t\t</td>\\n\t\t\t<td class=\\\"nowrap\\\">\\n\t\t\t\t<div class='pull-left'>\\n\t\t\t\t\t<div class='inline-left'>\\n\t\t\t\t\t\t<label>{{_t \\\"instance_submit_date\\\"}}：</label>\\n\t\t\t\t\t</div>\\n\t\t\t\t\t<div class='inline-right'>\\n\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t{{formatDate instance.submit_date '{\\\"format\\\":\\\"YYYY-MM-DD\\\"}'}}\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t</td>\\n\t\t</tr>\\n\t</table>\\n</div>\";\n  return template;\n};\n\nTemplateManager._template = {\n  \"default\": function(instance) {\n    var template;\n    template = \"<div class=\\\"with-border col-md-12\\\">\\n\t<div class=\\\"instance-name\\\">\\n\t\t<h3 class=\\\"box-title\\\">\" + (TemplateManager.instance_title().pageTitle) + \"</h3>\\n\t\t<span class=\\\"help-block\\\"></span>\\n\t</div>\\n\t<span class=\\\"help-block\\\"></span>\\n</div>\\n{{#each steedos_form.fields}}\\n\t{{#if isOpinionField this}}\\n\t\t<div class=\\\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\\\">\\n\t\t\t<div class=\\\"form-group automatic opinion-field-{{this.code}}\\\">\\n\t\t\t\t<label class=\\\"control-label\\\">{{afFieldLabelText name=this.code}}</label>\\n\\n\t\t\t\t{{> instanceSignText name=this.code}}\\n\t\t\t</div>\\n\t\t</div>\\n\t{{else}}\\n\t\t{{#if includes this.type 'section,table'}}\\n\t\t\t<div class=\\\"col-md-12 field-{{this.code}}\\\">\\n\t\t\t\t{{> afFormGroup name=this.code label=false}}\\n\t\t\t</div>\\n\t\t{{else}}\\n\t\t\t<div class=\\\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\\\">\\n\t\t\t{{> afFormGroup name=this.code}}\\n\t\t\t</div>\\n\t\t{{/if}}\\n\t{{/if}}\\n{{/each}}\\n<div class=\\\"col-md-12\\\">\\n\t<div class=\\\"applicant-wrapper form-group form-horizontal\\\">\\n\t<div class=\\\"input-group\\\">\\n\t\t<div class=\\\"input-group-addon\\\">\\n\t\t  {{_t \\\"instance_initiator\\\"}}&nbsp;:\\n\t\t</div>\\n\t\t{{>Template.dynamic  template=\\\"afSelectUser\\\" data=applicantContext}}\\n\t  </div>\\n\t</div>\\n</div>\";\n    return template;\n  },\n  table: function(instance) {\n    return TemplateManager.handleTableTemplate(instance);\n  }\n};\n\nTemplateManager._templateHelps = {\n  applicantContext: function() {\n    var data, steedos_instance;\n    steedos_instance = WorkflowManager.getInstance();\n    data = {\n      name: 'ins_applicant',\n      atts: {\n        name: 'ins_applicant',\n        id: 'ins_applicant',\n        \"class\": 'selectUser form-control',\n        style: 'padding:6px 12px;width:140px;display:inline'\n      }\n    };\n    data.atts.disabled = true;\n    return data;\n  }\n};\n\n({\n  instanceId: function() {\n    return 'instanceform';\n  },\n  form_types: function() {\n    if (ApproveManager.isReadOnly()) {\n      return 'disabled';\n    } else {\n      return 'method';\n    }\n  },\n  steedos_form: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return form_version;\n    }\n  },\n  innersubformContext: function(obj) {\n    var doc_values;\n    doc_values = WorkflowManager_format.getAutoformSchemaValues();\n    obj[\"tableValues\"] = doc_values ? doc_values[obj.code] : [];\n    obj[\"formId\"] = formId;\n    return obj;\n  },\n  instance: function() {\n    var steedos_instance;\n    Session.get(\"change_date\");\n    if (Session.get(\"instanceId\")) {\n      steedos_instance = WorkflowManager.getInstance();\n      return steedos_instance;\n    }\n  },\n  equals: function(a, b) {\n    return a === b;\n  },\n  includes: function(a, b) {\n    return b.split(',').includes(a);\n  },\n  fields: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n    }\n  },\n  doc_values: function() {\n    return WorkflowManager_format.getAutoformSchemaValues();\n  },\n  instance_box_style: function() {\n    var box, ins, judge;\n    box = Session.get(\"box\");\n    if (box === \"inbox\" || box === \"draft\") {\n      judge = Session.get(\"judge\");\n      if (judge) {\n        if (judge === \"approved\") {\n          return \"box-success\";\n        } else if (judge === \"rejected\") {\n          return \"box-danger\";\n        }\n      }\n    }\n    ins = WorkflowManager.getInstance();\n    if (ins && ins.final_decision) {\n      if (ins.final_decision === \"approved\") {\n        return \"box-success\";\n      } else if (ins.final_decision === \"rejected\") {\n        return \"box-danger\";\n      }\n    }\n  }\n});\n\nTemplateManager.getTemplate = function(instance, templateName) {\n  var flow, form;\n  flow = db.flows.findOne(instance.flow);\n  form = db.forms.findOne(instance.form);\n  if (templateName) {\n    if (templateName === 'table') {\n      return TemplateManager._template.table(instance);\n    }\n    return TemplateManager._template[\"default\"](instance);\n  }\n  if (typeof Session !== \"undefined\" && Session !== null ? Session.get(\"instancePrint\") : void 0) {\n    if (flow != null ? flow.print_template : void 0) {\n      return \"<div class='instance-template'>\" + flow.print_template + \"</div>\";\n    } else {\n      if (flow != null ? flow.instance_template : void 0) {\n        return \"<div class='instance-template'>\" + flow.instance_template + \"</div>\";\n      } else {\n        return TemplateManager._template.table(instance);\n      }\n    }\n  } else {\n    if (Steedos.isMobile()) {\n      return TemplateManager._template[\"default\"](instance);\n    }\n    if (flow != null ? flow.instance_template : void 0) {\n      return \"<div class='instance-template'>\" + flow.instance_template + \"</div>\";\n    }\n    if (form != null ? form.instance_style : void 0) {\n      if (form.instance_style === 'table') {\n        return TemplateManager._template.table(instance);\n      }\n      return TemplateManager._template[\"default\"](instance);\n    } else {\n      return TemplateManager._template[\"default\"](instance);\n    }\n  }\n};\n","SteedosTable = {};\n\nSteedosTable.formId = \"instanceform\";\n\nSteedosTable.checkItem = function (field, item_index) {\n    var fieldObj = SteedosTable.getField(field);\n\n    var fieldVal = SteedosTable.getItemModalValue(field, item_index);\n\n    var sf_name = '';\n    var rev = true;\n    fieldObj.sfields.forEach(function (sf) {\n        if (sf.permission == 'editable') {\n            sf_name = fieldObj.code + \".\" + sf.code;\n            if (!InstanceManager.checkFormFieldValue($(\"[name='\" + sf_name + \"']\")[0], sf_name, fieldVal[sf.code])) {\n                rev = false;\n            }\n        }\n    });\n\n    return rev;\n}\n\nSteedosTable.setTableItemValue = function (field, item_index, item_value) {\n\n    var tableValue = SteedosTable.getTableValue(field);\n    tableValue[item_index] = item_value;\n}\n\nSteedosTable.getTableItemValue = function (field, item_index) {\n    return SteedosTable.getTableValue(field)[item_index];\n}\n\nSteedosTable.removeTableItem = function (field, item_index) {\n    var item_value = SteedosTable.getTableItemValue(field, item_index);\n    item_value.removed = true;\n}\n\nSteedosTable.setTableValue = function (field, value) {\n    $(\"table[name='\" + field + \"']\").val({\n        val: value\n    });\n}\n\nSteedosTable.getTableValue = function (field) {\n    return $(\"table[name='\" + field + \"']\").val().val;\n}\n\nSteedosTable.getValidValue = function (field) {\n    var value = SteedosTable.getTableValue(field);\n\n    if (!value) {\n        return\n    }\n\n    var validValue = [];\n\n    value.forEach(function (v) {\n        if (!v.removed) {\n            validValue.push(v);\n        }\n    });\n    return validValue;\n}\n\n\nSteedosTable.handleData = function (field, values) {\n\n    if (!values || !(values instanceof Array)) {\n        return values;\n    }\n\n    var fieldObj = SteedosTable.getField(field);\n\n    values.forEach(function (v) {\n        fieldObj.sfields.forEach(function (f) {\n            if (f.type == 'user' || f.type == 'group') {\n                var value = v[f.code]\n                if (f.is_multiselect) {\n                    if (value && value.length > 0 && typeof (value[0]) == 'object') {\n                        v[f.code] = v[f.code].getProperty(\"id\");\n                    }\n                } else {\n                    if (value && typeof (value) == 'object') {\n                        v[f.code] = v[f.code].id;\n                    }\n                }\n            } else if (f.type == 'dateTime') {\n                var value = v[f.code]\n                if (value) {\n                    if (value.length == 16) {\n                        var t = value.split(\"T\");\n                        var t0 = t[0].split(\"-\");\n                        var t1 = t[1].split(\":\");\n\n                        year = t0[0];\n                        month = t0[1];\n                        date = t0[2];\n                        hours = t1[0];\n                        seconds = t1[1];\n                        value = new Date(year, month - 1, date, hours, seconds);\n                        v[f.code] = value;\n                    }\n\n                }\n            }\n        });\n    });\n    return values;\n}\n\nSteedosTable.getField = function (field) {\n    var instanceFields = WorkflowManager.getInstanceFields();\n    if (!instanceFields)\n        return;\n\n    var fieldObj = instanceFields.findPropertyByPK(\"code\", field);\n\n    return fieldObj;\n}\n\n\nSteedosTable.getModalData = function (field, index) {\n\n    var data = {};\n\n    var fieldObj = SteedosTable.getField(field);\n\n    if (!fieldObj) {\n        return;\n    }\n\n    data.field = fieldObj;\n\n    data.field.formula = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", fieldObj.sfields);\n\n    data.value = {};\n\n    data.value[field] = SteedosTable.getTableItemValue(field, index);\n\n    data.index = index;\n\n    return data;\n}\n\n\n\nSteedosTable.getItemModalValue = function (field, item_index) {\n\n    if (!AutoForm.getFormValues(\"steedos_table_modal_\" + field + \"_\" + item_index)) {\n        return {}\n    }\n\n    var item_value = AutoForm.getFormValues(\"steedos_table_modal_\" + field + \"_\" + item_index).insertDoc[field];\n    return item_value;\n}\n\n\nSteedosTable.addItem = function (field, index, _item_value) {\n    var keys = SteedosTable.getKeys(field);\n    var item_value = _item_value || SteedosTable.getItemModalValue(field, index);\n    $(\"tbody[name='\" + field + \"Tbody']\").append(SteedosTable.getTr(keys, item_value, index, field, true))\n\n}\n\nSteedosTable.updateItem = function (field, index, _item_value) {\n\n    var item = $(\"tr[name='\" + field + \"_item_\" + index + \"']\");\n\n    var item_value = _item_value || SteedosTable.getItemModalValue(field, index);\n\n    if (item && item.length > 0) {\n        var keys = SteedosTable.getKeys(field);\n        var tds = SteedosTable.getRemoveTd(field, index);\n\n        var sfields = SteedosTable.getField(field).sfields;\n\n        keys.forEach(function (key) {\n            var sfield = sfields.findPropertyByPK(\"code\", key);\n\n            var value = item_value[key];\n\n            tds = tds + SteedosTable.getTd(sfield, index, value);\n\n        });\n\n        item.empty();\n\n        item.append(tds);\n\n    } else {\n\n        SteedosTable.addItem(field, index);\n    }\n\n    if (SteedosTable.getTableValue(field)) {\n\n        SteedosTable.setTableItemValue(field, index, item_value);\n\n        //SteedosTable.valueHash[field][index] = item_value;\n\n    } else {\n        //SteedosTable.valueHash[field] = [item_value];\n\n        SteedosTable.setTableValue(field, [item_value])\n\n    }\n\n    //执行主表公式计算\n    InstanceManager.runFormula(field);\n\n}\n\nSteedosTable.removeItem = function (field, index) {\n\n    $(\"tr[name='\" + field + \"_item_\" + index + \"']\").hide();\n\n    SteedosTable.removeTableItem(field, index);\n\n    InstanceManager.runFormula(field);\n}\n\nSteedosTable.showModal = function (field, index, method) {\n\n\n    var modalData = SteedosTable.getModalData(field, index);\n\n    modalData.method = method;\n    setTimeout(function(){\n        Modal.show(\"steedosTableModal\", modalData);\n    }, 300)\n}\n\nSteedosTable.getKeys = function (field) {\n    if (!AutoForm.getCurrentDataForForm(SteedosTable.formId)) {\n        return [];\n    }\n\n    var ss = AutoForm.getFormSchema(SteedosTable.formId);\n\n    var keys = [];\n\n    if (ss.schema(field + \".$\").type === Object) {\n        keys = ss.objectKeys(SimpleSchema._makeGeneric(field) + '.$')\n    }\n\n    return keys;\n\n}\n\nSteedosTable.getThead = function (field, editable) {\n\n    var fieldObj = field;\n    if (!_.isObject(field))\n        fieldObj = SteedosTable.getField(field);\n\n    if (!fieldObj) {\n        return '';\n    }\n\n    var thead = '',\n        trs = '',\n        label = '',\n        width = 100;\n\n    if (editable) {\n        // trs = \"<th class='removed'></th>\"\n        trs = \"\"\n    }\n\n    var sfields = fieldObj.sfields;\n\n    if (!sfields) {\n        return thead;\n    }\n\n    var sf_length = sfields.length;\n\n    if (sf_length > 0) {\n        var wide_fields = sfields.filterProperty(\"is_wide\", true);\n\n        width = 100 / (sf_length + wide_fields.length);\n    }\n\n    sfields.forEach(function (sf, index) {\n\n        label = (sf.name != null && sf.name.length > 0) ? sf.name : sf.code;\n\n        trs = trs + \"<td \"; // nowrap='nowrap'\n\n        trs = trs + \" class='title \" + sf.type + \"'\";\n\n        if (index != (sf_length - 1)) {\n            if (sf.is_wide) {\n                trs = trs + \"style='width:\" + width * 2 + \"%'\"\n            } else {\n                trs = trs + \"style='width:\" + width + \"%'\"\n            }\n        }\n\n        trs = trs + \">\" + label + \"</td>\"\n    });\n\n    thead = '<tr>' + trs + '</tr>';\n\n    return thead;\n}\n\nSteedosTable.getTbody = function (keys, field, values, editable, sfieldsEditable) {\n    var tbody = \"\";\n\n    if (values instanceof Array) {\n        values.forEach(function (value, index) {\n            tbody = tbody + SteedosTable.getTr(keys, value, index, field, editable, sfieldsEditable);\n        });\n    }\n\n    return tbody;\n}\n\nSteedosTable.getTr = function (keys, item_value, index, field, editable, sfieldsEditable) {\n\n    var fieldObj = field;\n    if (!_.isObject(field))\n        fieldObj = SteedosTable.getField(field);\n\n    var tr = \"<tr id='\" + fieldObj.code + \"_item_\" + index + \"' name='\" + fieldObj.code + \"_item_\" + index + \"' data-index='\" + index + \"'\"\n\n    if (editable || sfieldsEditable) {\n        tr = tr + \"' class='item edit'\"\n    } else {\n        if (Steedos.isMobile()) {\n            tr = tr + \" class='item item-readonly'\"\n        } else {\n            tr = tr + \" class='item '\"\n        }\n    }\n\n    if (item_value.removed) {\n        tr = tr + \" style='display:none' \";\n    }\n\n    tr = tr + \"'>\";\n\n    var tds = \"\";\n\n    if (editable) {\n        tds = SteedosTable.getRemoveTd(fieldObj.code, index);\n    }\n\n    var sfields = fieldObj.sfields;\n\n    keys.forEach(function (key) {\n        var sfield = sfields.findPropertyByPK(\"code\", key);\n\n        var value = item_value[key];\n\n        tds = tds + SteedosTable.getTd(sfield, index, value);\n\n    });\n\n    tr = tr + tds + \"</tr>\";\n    return tr;\n}\n\nSteedosTable.getRemoveTd = function (field, index) {\n    // return \"<td class='steedosTable-item-remove removed' data-index='\" + index + \"'><i class='fa fa-times' aria-hidden='true'></td>\";\n    return \"\"\n}\n\nSteedosTable.getTd = function (field, index, value) {\n    var td = \"<td \";\n\n    td = td + \" class='steedosTable-item-field \" + field.type + \"' \";\n\n    var td_value = \"\";\n\n    if (Meteor.isClient) {\n        td_value = SteedosTable.getTDValue(field, value)\n    } else {\n        locale = Template.instance().view.template.steedosData.locale\n\n        utcOffset = Template.instance().view.template.steedosData.utcOffset\n\n        td_value = InstanceReadOnlyTemplate.getValue(value, field, locale, utcOffset)\n    }\n\n    td = td + \" data-index='\" + index + \"'>\" + td_value + \"</td>\"\n\n    return td;\n}\n\n\nSteedosTable.getTDValue = function (field, value) {\n    var td_value = \"\";\n    if (!field) {\n        return td_value\n    }\n    try {\n        var fieldOptions = [];\n        if([\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1){\n            fieldOptions = field.options.split(\"\\n\").map(function(n){\n                var itemSplits = n.split(\":\")\n                return {\n                    label: itemSplits[0],\n                    value: itemSplits[1] || n\n                }\n            });\n        }\n\n        switch (field.type) {\n            case 'user':\n                if (value) {\n                    if (field.is_multiselect) {\n                        if (value.length > 0) {\n                            if (\"string\" == typeof (value[0])) {\n                                td_value = CFDataManager.getFormulaSpaceUsers(value).getProperty(\"name\").toString();\n                            } else {\n                                td_value = value.getProperty(\"name\").toString();\n                            }\n                        }\n                    } else {\n                        if (\"string\" == typeof (value)) {\n                            var u = CFDataManager.getFormulaSpaceUsers(value);\n                            td_value = u ? u.name : '';\n                        } else {\n                            td_value = value.name;\n                        }\n                    }\n                }\n                break;\n            case 'group':\n                if (value) {\n                    if (field.is_multiselect) {\n                        if (value.length > 0) {\n                            if (\"string\" == typeof (value[0])) {\n                                td_value = CFDataManager.getFormulaOrganizations(value).getProperty(\"name\").toString();\n                            } else {\n                                td_value = value.getProperty(\"name\").toString();\n                            }\n                        }\n                    } else {\n                        if (\"string\" == typeof (value)) {\n                            var o = CFDataManager.getFormulaOrganization(value);\n                            td_value = o ? o.name : '';\n                        } else {\n                            td_value = value.name;\n                        }\n                    }\n                }\n                break;\n            case 'checkbox':\n                if (value === true || value == 'true') {\n                    td_value = TAPi18n.__(\"form_field_checkbox_yes\");\n                } else {\n                    td_value = TAPi18n.__(\"form_field_checkbox_no\");\n                }\n                break;\n            case 'email':\n                td_value = value ? \"<a href='mailto:\" + value + \"'>\" + value + \"</a>\" : \"\";\n                break;\n            case 'url':\n                if (value) {\n                    if (value.indexOf(\"http\") == 0) {\n                        try {\n                            td_value = \"<a href='\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n                        } catch (e) {\n                            td_value = \"<a href='' target='_blank'>\" + value + \"</a>\";\n                        }\n\n                    } else {\n                        td_value = \"<a href='http://\" + encodeURI(value) + \"' target='_blank'>http://\" + value + \"</a>\";\n                    }\n                } else {\n                    td_value = \"\";\n                }\n                break;\n            case 'password':\n                td_value = '******';\n                break;\n            case 'date':\n                if (value) {\n                    if (value.length == 10) {\n                        var t = value.split(\"-\");\n                        year = t[0];\n                        month = t[1];\n                        date = t[2];\n                        value = new Date(year, month - 1, date);\n                    } else {\n                        value = new Date(value)\n                    }\n                    td_value = $.format.date(value, 'yyyy-MM-dd');\n                }\n                break;\n            case 'dateTime':\n                if (value) {\n                    if (value.length == 16) {\n                        var t = value.split(\"T\");\n                        var t0 = t[0].split(\"-\");\n                        var t1 = t[1].split(\":\");\n\n                        year = t0[0];\n                        month = t0[1];\n                        date = t0[2];\n                        hours = t1[0];\n                        seconds = t1[1];\n\n                        value = new Date(year, month - 1, date, hours, seconds);\n\n                    } else {\n\n                        value = new Date(value)\n                    }\n                    td_value = $.format.date(value, 'yyyy-MM-dd HH:mm');\n                }\n                break;\n            case 'select':\n                var selectedOption = fieldOptions.find(function(item){ return item.value == value; })\n                if(selectedOption){\n                    td_value = selectedOption.label\n                }\n                break;\n            case 'radio':\n                var selectedOption = fieldOptions.find(function(item){ return item.value == value; })\n                if(selectedOption){\n                    td_value = selectedOption.label\n                }\n                break;\n            case 'multiSelect':\n                var splitedValues = value.split(\",\");\n                var selectedOptions = fieldOptions.filter(function(item){ return splitedValues.indexOf(item.value) > -1; });\n                if(selectedOptions.length){\n                    td_value = selectedOptions.map(function(item){ return item.label; }).join(\",\");\n                }\n                break;\n            case 'number':\n                if (value || value == 0) {\n                    if (field.is_percent) {\n                        td_value = Steedos.numberToPercentString(value, field.digits);\n                    } else {\n                        td_value = Steedos.numberToString(value, field.digits);\n                    }\n                }\n                break;\n            case 'odata':\n                if (value) {\n                    if (field.is_multiselect) {\n                        td_value = _.pluck(value, '@label').toString()\n                    } else {\n                        td_value = value['@label']\n                    }\n                }\n                break;\n            case 'file':\n            case 'lookup':\n            case 'image':\n            case 'time':\n                td_value = InstanceReadOnlyTemplate.getValue(value, field);\n                break\n            default:\n                td_value = value ? value : '';\n                break;\n        }\n    } catch (e) {\n        e;\n\n        return '';\n    }\n    return td_value;\n};\n\nif (Meteor.isClient) {\n    AutoForm.addInputType(\"table\", {\n        template: \"afTable\",\n        valueOut: function () {\n            var name = this.data(\"schemaKey\");\n            return SteedosTable.getValidValue(name);\n        },\n        valueConverters: {\n            \"stringArray\": AutoForm.valueConverters.stringToStringArray,\n            \"number\": AutoForm.valueConverters.stringToNumber,\n            \"numerArray\": AutoForm.valueConverters.stringToNumberArray,\n            \"boolean\": AutoForm.valueConverters.stringToBoolean,\n            \"booleanArray\": AutoForm.valueConverters.stringToBooleanArray,\n            \"date\": AutoForm.valueConverters.stringToDate,\n            \"dateArray\": AutoForm.valueConverters.stringToDateArray\n        },\n        contextAdjust: function (context) {\n            if (typeof context.atts.maxlength === 'undefined' && typeof context.max === 'number') {\n                context.atts.maxlength = context.max;\n            }\n            return context;\n        }\n    });\n\n    Template.afTable.events({\n        'tap .steedos-table .steedosTable-item-add,.add-item-tr': function (event, template) {\n            var name = template.data.name;\n\n            var tableValue = SteedosTable.getTableValue(name);\n\n            var new_item_index = tableValue ? tableValue.length : 0;\n\n            SteedosTable.showModal(name, new_item_index, \"add\");\n        },\n\n        'tap .steedos-table .steedosTable-item-field': function (event, template) {\n            if (template.data.atts.editable || template.data.atts.sfieldsEditable) {\n                var field = template.data.name;\n                var index = event.currentTarget.dataset.index;\n                SteedosTable.showModal(field, index, \"edit\");\n            }\n        },\n\n        'tap .steedos-table .steedosTable-item-remove': function (event, template) {\n            var field = template.data.name;\n            var item_index = event.currentTarget.dataset.index;\n            Session.set(\"instance_change\", true);\n            SteedosTable.removeItem(field, item_index);\n        },\n\n        'tap .steedos-table .item-readonly': function (event, template) {\n            if (!template.data.atts.editable) {\n                var field = template.data.name;\n                var index = event.currentTarget.dataset.index;\n                SteedosTable.showModal(field, index, \"read\");\n            }\n        }\n    });\n\n\n\n    Template.afTable.rendered = function () {\n\n        var field = this.data.name;\n\n        var sfieldsEditable = this.data.atts.sfieldsEditable;\n\n        var keys = SteedosTable.getKeys(field);\n        var validValue = SteedosTable.handleData(field, this.data.value);\n        SteedosTable.setTableValue(field, validValue);\n\n        $(\"thead[name='\" + field + \"Thead']\").html(SteedosTable.getThead(field, this.data.atts.editable));\n\n        $(\"tbody[name='\" + field + \"Tbody']\").html(SteedosTable.getTbody(keys, field, SteedosTable.getTableValue(field), this.data.atts.editable, sfieldsEditable));\n\n        str = t(\"steedos_table_add_item\");\n        addItemTr = \"<tr class='add-item-tr'><td colspan='\" + keys.length + \"'><i class='ion ion-plus-round'></i>\" + str + \"</td></tr>\";\n\n        if (this.data.atts.editable) {\n            $(\"tfoot[name='\" + field + \"Tfoot']\").append(addItemTr);\n        }\n\n        var c = InstanceManager.getCurrentStep();\n        if (c.step_type == 'counterSign' || InstanceManager.ccHasEditPermission()) {\n            this.autorun(function () {\n                var data = Template.currentData();\n                var field = data.name;\n                var keys = SteedosTable.getKeys(field);\n                var validValue = SteedosTable.handleData(field, data.value);\n                SteedosTable.setTableValue(field, validValue);\n                $(\"tbody[name='\" + field + \"Tbody']\").html(SteedosTable.getTbody(keys, field, SteedosTable.getTableValue(field), data.atts.editable, sfieldsEditable));\n            })\n        }\n\n    };\n}","ImageSign.helpers =\n\tspaceUserSign: (userId)->\n\t\tspace = \"\"\n\n\t\tif Meteor.isServer\n\t\t\tspace = Template.instance().view.template.steedosData.space\n\t\telse\n\t\t\tspace = Session.get(\"spaceId\")\n\n\t\tspaceUserSign = db.space_user_signs.findOne({space: space, user: userId});\n\t\treturn spaceUserSign\n\n\timageURL: (userId)->\n\n\t\tspaceUserSign = ImageSign.helpers.spaceUserSign(userId);\n\n\t\tabsolute = false\n\n\t\tif Meteor.isServer\n\t\t\tabsolute = Template.instance().view.template.steedosData.absolute\n\n\t\tif spaceUserSign?.sign\n\t\t\tif absolute\n\t\t\t\treturn Meteor.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n\t\t\telse\n\t\t\t\treturn Steedos.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n","ImageSign.helpers = {\n  spaceUserSign: function(userId) {\n    var space, spaceUserSign;\n    space = \"\";\n    if (Meteor.isServer) {\n      space = Template.instance().view.template.steedosData.space;\n    } else {\n      space = Session.get(\"spaceId\");\n    }\n    spaceUserSign = db.space_user_signs.findOne({\n      space: space,\n      user: userId\n    });\n    return spaceUserSign;\n  },\n  imageURL: function(userId) {\n    var absolute, spaceUserSign;\n    spaceUserSign = ImageSign.helpers.spaceUserSign(userId);\n    absolute = false;\n    if (Meteor.isServer) {\n      absolute = Template.instance().view.template.steedosData.absolute;\n    }\n    if (spaceUserSign != null ? spaceUserSign.sign : void 0) {\n      if (absolute) {\n        return Meteor.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n      } else {\n        return Steedos.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n      }\n    }\n  }\n};\n","TracesHandler.helpers =\n\tshowSignImage: (handler, is_finished, judge, traceShowSignImage) ->\n\t\tif traceShowSignImage == false\n\t\t\treturn false\n\t\tif !is_finished\n\t\t\treturn false\n\t\tif ['returned', 'terminated', 'retrieved'].includes(judge)\n\t\t\treturn false\n\t\tspaceUserSign = ImageSign.helpers.spaceUserSign(handler)\n\n\t\tif spaceUserSign?.sign\n\t\t\treturn true\n\t\telse\n\t\t\treturn false\n\n\tobjectUrl: (object_name, record_id, app_id)->\n\t\treturn Creator.getObjectUrl(object_name, record_id, app_id)","TracesHandler.helpers = {\n  showSignImage: function(handler, is_finished, judge, traceShowSignImage) {\n    var spaceUserSign;\n    if (traceShowSignImage === false) {\n      return false;\n    }\n    if (!is_finished) {\n      return false;\n    }\n    if (['returned', 'terminated', 'retrieved'].includes(judge)) {\n      return false;\n    }\n    spaceUserSign = ImageSign.helpers.spaceUserSign(handler);\n    if (spaceUserSign != null ? spaceUserSign.sign : void 0) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  objectUrl: function(object_name, record_id, app_id) {\n    return Creator.getObjectUrl(object_name, record_id, app_id);\n  }\n};\n","marked = require(\"marked\")\nInstanceformTemplate.helpers =\n\tapplicantContext: ->\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {name: 'ins_applicant', id: 'ins_applicant', class: 'selectUser form-control ins_applicant'},\n\t\t\tvalue: steedos_instance.applicant_name\n\t\t}\n\t\tif not steedos_instance || steedos_instance.state != \"draft\"\n\t\t\tdata.atts.disabled = true\n\t\treturn data;\n\n\tinstanceId: ->\n\t\treturn 'instanceform';#\"instance_\" + Session.get(\"instanceId\");\n\n\tform_types: ->\n\t\tif ApproveManager.isReadOnly()\n\t\t\treturn 'disabled';\n\t\telse\n\t\t\treturn 'method';\n\n\tsteedos_form: ->\n\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\t\tif form_version\n\t\t\treturn form_version\n\n\tinnersubformContext: (obj)->\n\t\tdoc_values = WorkflowManager_format.getAutoformSchemaValues();\n\t\tobj[\"tableValues\"] = if doc_values then doc_values[obj.code] else []\n\t\tobj[\"formId\"] = \"instanceform\";\n\t\treturn obj;\n\n\tinstance: ->\n\t\tSession.get(\"change_date\")\n\t\tif (Session.get(\"instanceId\"))\n\t\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\t\treturn steedos_instance;\n\n\tempty: (val) ->\n\t\tif val\n\t\t\treturn false\n\t\telse\n\t\t\treturn true;\n\n\tunempty: (val) ->\n\t\tif val\n\t\t\treturn true;\n\t\telse\n\t\t\treturn false;\n\n\tequals: (a, b) ->\n\t\treturn (a == b)\n\n\tunequals: (a, b) ->\n\t\treturn !(a == b)\n\n\tincludes: (a, b) ->\n\t\treturn b.split(',').includes(a);\n\n\tinclude: (a, b) ->\n\t\treturn b.split(',').includes(a);\n\n\tfields: ->\n\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\t\tif form_version\n\t\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\n\tformatDate: (date, options)->\n\t\tif !date\n\t\t\treturn \"\";\n\t\tif options && typeof(options) == 'string'\n\t\t\toptions = JSON.parse(options);\n\n\t\tif !options.format\n\t\t\toptions = {format: \"YYYY-MM-DD HH:mm\"}\n\n\t\treturn moment(date).format(options.format);\n\n\ttraces: ->\n\t\tif Meteor.isServer\n\t\t\tsteedosData = Template.instance()?.view?.template?.steedosData\n\t\t\tinstance = steedosData?.instance\n\t\t\tflow = InstanceReadOnlyTemplate.getFlowVersion(instance);\n\t\t\tlocale = steedosData?.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tinstance = WorkflowManager.getInstance();\n\n\t\t\tflow = WorkflowManager.getInstanceFlowVersion()\n\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\n\t\tif !instance || !flow\n\t\t\treturn {};\n\n\t\tsteps = flow.steps;\n\n\t\ttraces = {};\n\n\t\tinstance.traces?.forEach (trace)->\n\t\t\tstep = steps.findPropertyByPK(\"_id\", trace.step)\n\n\t\t\tapproves = []\n\n\t\t\ttrace.approves?.forEach (approve) ->\n\t\t\t\tif trace.is_finished == true\n# 已结束的显示为核准/驳回/取消申请\n\t\t\t\t\tif approve.judge == 'approved'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State approved\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'rejected'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State rejected\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'terminated'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State terminated\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'reassigned'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State reassigned\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'relocated'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State relocated\", {}, locale)\n\t\t\t\t\telse if approve.judge == ''\n\t\t\t\t\t\tjudge_name = \"\"\n\t\t\t\t\telse\n\t\t\t\t\t\tjudge_name = \"\"\n\n\t\t\t\telse\n\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State pending\", {}, locale)\n\n\t\t\t\tapproves.push\n\t\t\t\t\t_id: approve._id\n\t\t\t\t\thandler: approve.user\n\t\t\t\t\thandler_name: approve.handler_name\n\t\t\t\t\thandler_organization_name: approve.handler_organization_name\n\t\t\t\t\thandler_organization_fullname: approve.handler_organization_fullname\n\t\t\t\t\tfinish_date: approve.finish_date\n\t\t\t\t\tjudge: approve.judge\n\t\t\t\t\tjudge_name: judge_name\n\t\t\t\t\tdescription: approve.description\n\t\t\t\t\tis_finished: approve.is_finished\n\t\t\t\t\ttype: approve.type\n\t\t\t\t\topinion_fields_code: approve.opinion_fields_code\n\t\t\t\t\tsign_field_code: approve.sign_field_code\n\t\t\t\t\tis_read: approve.is_read\n\t\t\t\t\tsign_show: approve.sign_show\n\n\n\t\t\tif step\n\t\t\t\tif step.name of traces\n\t\t\t\t\ttraces[step.name] = traces[step.name].concat(approves)\n\t\t\t\telse\n\t\t\t\t\ttraces[step.name] = approves\n\n\t\treturn traces;\n\n\n\n\tdoc_values: ->\n\t\tWorkflowManager_format.getAutoformSchemaValues();\n\n\tinstance_box_style: ->\n\t\tbox = Session.get(\"box\")\n\t\tif box == \"inbox\" || box == \"draft\"\n\t\t\tjudge = Session.get(\"judge\")\n\t\t\tif judge\n\t\t\t\tif (judge == \"approved\")\n\t\t\t\t\treturn \"box-success\"\n\t\t\t\telse if (judge == \"rejected\")\n\t\t\t\t\treturn \"box-danger\"\n\t\tins = WorkflowManager.getInstance();\n\t\tif ins && ins.final_decision\n\t\t\tif ins.final_decision == \"approved\"\n\t\t\t\treturn \"box-success\"\n\t\t\telse if (ins.final_decision == \"rejected\")\n\t\t\t\treturn \"box-danger\"\n\n#is_disabled: ->\n#    ins = WorkflowManager.getInstance();\n#    if !ins\n#        return;\n#    if ins.state!=\"draft\"\n#        return \"disabled\";\n#    return;\n\n\ttable_fields: (instance)->\n\t\tif Meteor.isClient\n\t\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\t\telse\n\t\t\tform_version = WorkflowManager.getFormVersion(instance.form, instance.form_version)\n\t\tif form_version\n\t\t\tfields = _.clone(form_version.fields);\n\n\t\t\tfields.forEach (field, index) ->\n\t\t\t\tfield.tr_start = \"\";\n\t\t\t\tfield.tr_end = \"\";\n\t\t\t\ttd_colspan = 1;\n#\t\t\t\t强制设置标头字段为宽字段\n\t\t\t\tif CoreForm?.pageTitleFieldName == field.code\n\t\t\t\t\tfield.is_wide = true\n\n\t\t\t\tif field.formula && field.type != 'odata'\n\t\t\t\t\tfield.permission = \"readonly\";\n\n\t\t\t\tif Steedos.isMobile()\n# 如果当前字段是分组、表格、宽字段\n\t\t\t\t\tif field.type == 'section' || field.type == 'table'\n\t\t\t\t\t\tfield.td_colspan = 4;\n\t\t\t\t\telse\n\t\t\t\t\t\tfield.td_colspan = 3;\n\n\t\t\t\t\tif index != 0\n\t\t\t\t\t\tfield.tr_start = \"<tr>\";\n\t\t\t\t\t\tfield.tr_end = \"</tr>\";\n\t\t\t\telse\n\t\t\t\t\tpre_fields = fields.slice(0, index);\n\n\t\t\t\t\tpre_wide_fields = pre_fields.filterProperty(\"is_wide\", true);\n\n\t\t\t\t\ttr_start = \"\";\n\n\t\t\t\t\ttr_end = \"\";\n\n\t\t\t\t\t# 先计算当前字段是否为宽字段\n\t\t\t\t\tbefore_field = null;\n\t\t\t\t\tafter_field = null;\n\n\t\t\t\t\tif index > 0\n\t\t\t\t\t\tbefore_field = fields[index - 1]\n\n\t\t\t\t\tif index < fields.length - 1\n\t\t\t\t\t\tafter_field = fields[index + 1]\n\n\t\t\t\t\t# 如果当前字段是分组、表格、宽字段\n\t\t\t\t\tif field.type == 'section' || field.type == 'table'\n\t\t\t\t\t\ttd_colspan = 4;\n\t\t\t\t\telse if field.is_wide\n\t\t\t\t\t\ttd_colspan = 3;\n\t\t\t\t\telse\n# 前后都是宽字段\n\t\t\t\t\t\tif before_field && after_field && before_field.is_wide && after_field.is_wide\n\t\t\t\t\t\t\tfield.is_wide = true;\n\t\t\t\t\t\t\ttd_colspan = 3;\n\n\t\t\t\t\t\t# 当前是tr 下的 第一个td & 后边的字段是宽字段\n\t\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 == 0 && after_field && after_field.is_wide\n\t\t\t\t\t\t\tfield.is_wide = true;\n\t\t\t\t\t\t\ttd_colspan = 3;\n\n\t\t\t\t\t\t# 当前是tr 下的 第一个td & 当前字段是最后一个字段\n\t\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 == 0 && after_field == null\n\t\t\t\t\t\t\tfield.is_wide = true;\n\t\t\t\t\t\t\ttd_colspan = 3;\n\n\t\t\t\t\tfield.td_colspan = td_colspan;\n\n\n\t\t\t\t\tif index == 0\n# tr_start = \"<tr>\"; 由于Template的编译bug，导致每次给一个tr开始时，会自动补头或补尾。因此在第一行返回一个空字符串.\n\t\t\t\t\t\ttr_start = \"<tr>\";\n\t\t\t\t\telse\n\t\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 == 0 || field.is_wide\n\t\t\t\t\t\t\tif field.type == 'table'\n\t\t\t\t\t\t\t\ttr_start = \"<tr class = \\\"tr-child-table\\\">\";\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\ttr_start = \"<tr>\";\n\n\t\t\t\t\tfield.tr_start = tr_start;\n\n\n\t\t\t\t\tif index + 1 == fields.length || field.type == 'section' || field.type == 'table' || field.is_wide\n\t\t\t\t\t\ttr_end = \"</tr>\";\n\n\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 != 0\n\t\t\t\t\t\ttr_end = \"</tr>\";\n\n\t\t\t\t\tfield.tr_end = tr_end;\n\n\t\t\treturn fields;\n\n\tsort_approve: (approves, order)->\n\t\tif !approves\n\t\t\treturn []\n\n\t\tif !approves instanceof Array\n\t\t\treturn []\n\t\telse\n\t\t\tif order == 'desc'\n\t\t\t\tapproves.sort (p1, p2) ->\n\t\t\t\t\t_p1 = 0\n\t\t\t\t\t_p2 = 0\n\n\t\t\t\t\tif p1.finish_date\n\t\t\t\t\t\t_p1 = p1.finish_date.getTime()\n\n\t\t\t\t\tif p2.finish_date\n\t\t\t\t\t\t_p2 = p2.finish_date.getTime();\n\n\t\t\t\t\treturn _p2 - _p1\n\t\t\telse\n\t\t\t\tapproves.sort (p1, p2) ->\n\t\t\t\t\t_p1 = 0\n\t\t\t\t\t_p2 = 0\n\n\t\t\t\t\tif p1.finish_date\n\t\t\t\t\t\t_p1 = p1.finish_date.getTime()\n\n\t\t\t\t\tif p2.finish_date\n\t\t\t\t\t\t_p2 = p2.finish_date.getTime();\n\n\t\t\t\t\treturn _p1 - _p2\n\t\treturn approves\n\n\t_t: (key)->\n\t\treturn TAPi18n.__(key)\n\tgetField: (code)->\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\t\tif form_version\n\t\t\treturn form_version.fields.findPropertyByPK(\"code\", code)\n\n\tgetValue: (code)->\n\t\tinstance = Template.instance().view.template.steedosData.instance\n\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\n\t\tutcOffset = Template.instance().view.template.steedosData.utcOffset\n\n\t\tvalues = instance.values || {}\n\n\t\tif Meteor.isClient\n\t\t\tvalues = WorkflowManager_format.getAutoformSchemaValues()\n\n\t\treturn InstanceReadOnlyTemplate.getValue values[code], form_version.fields.findPropertyByPK(\"code\", code), locale, utcOffset\n\n\tgetLabel: (code)->\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\t\tInstanceReadOnlyTemplate.getLabel form_version.fields, code\n\n\tisTextarea: (field)->\n\t\tif field?.type == \"input\" && field?.is_textarea\n\t\t\treturn true\n\n\tgetCfClass: (field)->\n\t\tif field?.type == \"input\" && field?.is_textarea\n\t\t\treturn \"cfTextarea\"\n\n\tgetTableThead: (field)->\n\t\treturn SteedosTable.getThead(field, false)\n\n\tgetTableBody: (field)->\n\n\t\tif Meteor.isServer\n\t\t\tinstance = Template.instance().view.template.steedosData.instance\n\t\t\tvalues = instance.values || {}\n\t\telse\n\t\t\tvalues = WorkflowManager_format.getAutoformSchemaValues()\n\n\t\ttableValue = values[field.code];\n\t\treturn SteedosTable.getTbody(field.sfields.getProperty(\"code\"), field, tableValue, false)\n\n\tshowLabel: (field)->\n\t\ttemplateData = Template.instance().data\n\t\tif templateData.label == false\n\t\t\treturn false\n\t\treturn true\n\n#\tafFieldLabelText: (op)->\n#\t\tif !Template.instance().view.template.steedosData\n#\t\t\treturn AutoForm.getLabelForField(op.name)\n#\t\telse\n#\t\t\tform_version = Template.instance().view.template.steedosData.form_version\n#\t\t\tInstanceReadOnlyTemplate.getLabel form_version.fields, op?.hash?.name\n\n\tisOpinionField: (field)->\n\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field.formula)\n\n\tisOpinionField_from_string: (field_formula)->\n\t\treturn InstanceSignText.isOpinionField_from_string(field_formula)\n\n\tincludesOpinionField: (form, form_version)->\n\n\t\tfield_formulas = new Array();\n\n\t\tfields = db.form_versions.findOne({_id: form_version, form: form})?.fields || []\n\n\t\tfields.forEach (f)->\n\t\t\tif f.type == 'table'\n\t\t\t\tconsole.log 'ignore opinion field in table'\n\t\t\telse if f.type == 'section'\n\t\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\t\tfield_formulas.push f1.formula\n\t\t\telse\n\t\t\t\tfield_formulas.push f.formula\n\n\t\t_.some field_formulas, (field_formula)->\n\t\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\n\tgetOpinionFieldStepsName: (field_formula, top_keywords)->\n\n\t\topinionFields = new Array();\n#\t\tconsole.log(\"field_formula\", field_formula)\n\t\tif InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\t\t\tif field_formula\n\n#\t\t\t\tfoo1 = field_formula.split(\",\")\n\t\t\t\tfoo1 = field_formula.split(\";\")\n\n#\t\t\t\tif top_keywords\n#\t\t\t\t\tfoo1 = field_formula.split(\";\")\n\n\t\t\t\tfoo1.forEach (foo)->\n\t\t\t\t\tjson_formula = {}\n\n\t\t\t\t\ttry\n\t\t\t\t\t\tjson_formula = eval(\"(\" + foo + \")\")\n\t\t\t\t\tcatch\n\t\t\t\t\t\tjson_formula = {}\n\n\t\t\t\t\tif json_formula?.yijianlan\n\t\t\t\t\t\tsf = {}\n\n\t\t\t\t\t\tsf.stepName = json_formula.yijianlan.step\n\n\t\t\t\t\t\tsf.image_sign = json_formula.yijianlan.image_sign || false\n\n\t\t\t\t\t\tsf.only_cc_opinion = json_formula.yijianlan.only_cc || false\n\n\t\t\t\t\t\tsf.default_description = json_formula.yijianlan.default\n\n\t\t\t\t\t\tsf.only_handler = json_formula.yijianlan.only_handler\n\n\t\t\t\t\t\tsf.top_keywords = json_formula.yijianlan.top_keywords || top_keywords\n\n\t\t\t\t\t\topinionFields.push(sf);\n\n\t\t\t\t\telse if(field_formula?.indexOf(\"{traces.\") > -1 || field_formula?.indexOf(\"{signature.traces.\") > -1)\n\n\t\t\t\t\t\tsf = {only_cc_opinion: false, image_sign: false, top_keywords: top_keywords}\n\n\t\t\t\t\t\tif foo.indexOf(\"{signature.\") > -1\n\t\t\t\t\t\t\tsf.image_sign = true\n\t\t\t\t\t\t\tfoo = foo.replace(\"{signature.\",\"\");\n\n\t\t\t\t\t\ts1 = foo.replace(\"{\",\"\").replace(\"}\",\"\")\n\t\t\t\t\t\tif s1.split(\".\").length > 1\n\t\t\t\t\t\t\tsf.stepName = s1.split(\".\")[1]\n\t\t\t\t\t\t\tif opinionFields.filterProperty(\"stepName\",sf.stepName).length > 0\n\t\t\t\t\t\t\t\topinionFields.findPropertyByPK(\"stepName\", sf.stepName)?.only_cc_opinion = true\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tif s1.split(\".\").length > 2\n\t\t\t\t\t\t\t\t\tif s1.split(\".\")[2]?.toLocaleLowerCase() == 'cc'\n\t\t\t\t\t\t\t\t\t\tsf.only_cc_opinion = true\n\t\t\t\t\t\topinionFields.push(sf);\n\n\t\treturn opinionFields\n\n\tshowCCOpinion: (field)->\n\t\tif field.formula?.indexOf(\"{traces.\") > -1 || field.formula?.indexOf(\"{signature.traces.\") > -1\n\t\t\ts1 = field.formula.replace(\"{signature.\",\"\").replace(\"{\",\"\").replace(\"}\",\"\")\n\t\t\tif s1.split(\".\").length > 2\n\t\t\t\tif s1.split(\".\")[2]?.toLocaleLowerCase() == 'cc'\n\t\t\t\t\treturn true\n\t\treturn false\n\n\tmarkDownToHtml: (markDownString)->\n\t\tif markDownString\n\t\t\t# renderer = new Markdown.Renderer();\n\t\t\t# renderer.link = ( href, title, text ) ->\n\t\t\t# \treturn \"<a target='_blank' href='#{href}' title='#{title}'>#{text}</a>\"\n\t\t\tif Meteor.isServer\n\t\t\t\tmarked = Npm.require('marked')\n\t\t\treturn Spacebars.SafeString(marked.parse(markDownString))\n\n\tf_label: (that)->\n\t\treturn that.name || that.code\n\nif Meteor.isServer\n\tInstanceformTemplate.helpers.steedos_form = ->\n\t\treturn this.form_version\n\n\tInstanceformTemplate.helpers.isSection = (code)->\n\t\tform_version = this.form_version\n\t\treturn form_version.fields.findPropertyByPK(\"code\", code).type == 'section'\n\n\tInstanceformTemplate.helpers.doc_values = ->\n\t\tinstance = this.instance;\n\t\treturn instance.values;\n\n\tInstanceformTemplate.helpers.applicantContext = ->\n\t\tinstance = this.instance;\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {name: 'ins_applicant', id: 'ins_applicant', class: 'selectUser form-control ins_applicant'},\n\t\t\tvalue: instance.applicant_name\n\t\t}\n\n\tInstanceformTemplate.helpers.instance = ->\n\t\treturn this.instance\n\n\tInstanceformTemplate.helpers.fields = ->\n\t\tform_version = this.form_version\n\t\tif form_version\n\t\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\n\tInstanceformTemplate.helpers.form_types = ->\n\t\treturn \"disabled\"\n\n\tTemplate.registerHelper \"afFieldLabelText\", (op)->\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\t\tInstanceReadOnlyTemplate.getLabel form_version.fields, op?.hash?.name\n\n\tInstanceformTemplate.helpers._t = (key)->\n\t\tlocale = this.locale\n\n\t\treturn TAPi18n.__(key, {}, locale)\n\n\tInstanceformTemplate.helpers.ins_attach_download_url = (_id, absolute)->\n\t\tif absolute\n\t\t\treturn Meteor.absoluteUrl(\"/api/files/instances/#{_id}?download=true\");\n\t\telse\n\t\t\treturn \"/api/files/instances/#{_id}?download=true\";\n\n\tInstanceformTemplate.helpers.options = (field)->\n\t\toptions = field?.options?.split(\"\\n\")\n\t\trev = []\n\t\toptions?.forEach (item)->\n\t\t\trev.push({label: item, value: item})\n\n\t\treturn rev\n\n\tInstanceformTemplate.helpers.getPermissions = (code)->\n\t\tif !Template.instance().view.template.steedosData.startStepEditableFields?.includes(code)\n\t\t\treturn \"readonly disabled\"\n\t\treturn \"\"\n\nInstanceformTemplate.events =\n\t'change .form-control,.checkbox input,.af-radio-group input,.af-checkbox-group input': (event)->\n\t\tInstanceManager.instanceformChangeEvent(event)\n\n\t'typeahead:change .form-control': (event) ->\n\t\tInstanceManager.instanceformChangeEvent(event)\n\n\t'click .cfTextarea a': (event)->\n\t\tevent.preventDefault();\n\t\tSteedos.openWindow(event.target.href);\n\n\nInstanceformTemplate.onCreated = ()->\n\tinstance = WorkflowManager.getInstance();\n\tif !instance\n\t\treturn;\n\n\ttemplate = TemplateManager.getTemplate(instance);\n\n\ttry\n\t\tcompiled = SpacebarsCompiler.compile(template, {isBody: true});\n\tcatch e\n\t\tconsole.log \"Instance Template Error\", e\n\t\tcompiled = SpacebarsCompiler.compile(\"\", {isBody: true});\n\n\n\trenderFunction = eval(compiled);\n\n\tinstanceView = new Blaze.View(\"custom_instance_template\", renderFunction);\n\n\tinstanceCustomTemplate = new Blaze.Template(instanceView.name, renderFunction);\n\n\tTemplate.instance_custom_template = instanceCustomTemplate\n\n\tTemplate.instance_custom_template.helpers InstanceformTemplate.helpers\n\n\n\n\nInstanceformTemplate.onRendered = ()->\n\t# t = this;\n\n\t#t.subscribe \"instance_data\", Session.get(\"instanceId\"), ->\n\t#    Tracker.afterFlush ->\n\tinstance = WorkflowManager.getInstance();\n\tif !instance\n\t\treturn;\n\n\t#$(\"#ins_applicant\").select2().val(instance.applicant).trigger('change');\n\t#$(\"#ins_applicant\").val(instance.applicant);\n\tInstanceManager.setInstanceFormApplicant(instance.applicant, instance.applicant_name)\n\n\n\tApproveManager.error = {nextSteps: '', nextStepUsers: ''};\n\n\t# instance from绑定事件\n\tif Session.get(\"box\") == 'inbox' || Session.get(\"box\") == 'draft'\n\t\tInstanceEvent.initEvents(instance.flow);\n\n\tif !ApproveManager.isReadOnly()\n\n\t\tcurrentApprove = InstanceManager.getCurrentApprove();\n\n\n\t\tinstanceNumberFields = $(\"[data-formula]\", $(\"#instanceform\"))\n\n\t\tinstanceNumberFields.each ()->\n\t\t\tschemaKey = this.dataset.schemaKey\n\t\t\telement = $(this)\n\t\t\tif !$(this).val() && schemaKey && Session.get(\"instanceId\")\n\t\t\t\tMeteor.call 'getInstanceValues', Session.get(\"instanceId\"), (error, result)->\n\t\t\t\t\tif error\n\t\t\t\t\t\ttoastr.error(error.reason)\n\n\t\t\t\t\tif !result[schemaKey]\n\t\t\t\t\t\tkey = element.data(\"formula\")?.replace(\"auto_number(\", \"\").replace(\")\", \"\")\n\n\t\t\t\t\t\tkey = key.replace(/\\\"/g, \"\").replace(/\\'/g, \"\")\n\n\t\t\t\t\t\tif key.indexOf(\"{\") > -1\n\t\t\t\t\t\t\tkey = key.replace(\"{\",\"\").replace(\"}\",\"\")\n\t\t\t\t\t\t\tkey = key.trim()\n\t\t\t\t\t\t\tkey = AutoForm.getFieldValue(key, 'instanceform')\n\t\t\t\t\t\tInstanceNumberRules.instanceNumberBuilder element, key\n\t\t\t\t\telse\n\t\t\t\t\t\telement?.val(result[schemaKey]).trigger(\"change\")\n\n\t\tjudge = currentApprove.judge\n\t\tcurrentStep = InstanceManager.getCurrentStep();\n\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\n\t\tunless form_version\n\t\t\treturn\n\n\t\tunless form_version.fields\n\t\t\treturn\n\n\t\tformula_fields = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", form_version.fields);\n\t\tinsertDoc = AutoForm.getFormValues(\"instanceform\", undefined, undefined, false)\n\t\tForm_formula.run(\"\", \"\", formula_fields, insertDoc, form_version.fields);\n\t\t#在此处初始化session 中的 form_values 变量，用于触发下一步步骤计算\n\t\tSession.set(\"instance_form_values\", {instanceId: instance._id, values: insertDoc});\n\n\n\n","var marked;\n\nmarked = require(\"marked\");\n\nInstanceformTemplate.helpers = {\n  applicantContext: function() {\n    var data, steedos_instance;\n    steedos_instance = WorkflowManager.getInstance();\n    data = {\n      name: 'ins_applicant',\n      atts: {\n        name: 'ins_applicant',\n        id: 'ins_applicant',\n        \"class\": 'selectUser form-control ins_applicant'\n      },\n      value: steedos_instance.applicant_name\n    };\n    if (!steedos_instance || steedos_instance.state !== \"draft\") {\n      data.atts.disabled = true;\n    }\n    return data;\n  },\n  instanceId: function() {\n    return 'instanceform';\n  },\n  form_types: function() {\n    if (ApproveManager.isReadOnly()) {\n      return 'disabled';\n    } else {\n      return 'method';\n    }\n  },\n  steedos_form: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return form_version;\n    }\n  },\n  innersubformContext: function(obj) {\n    var doc_values;\n    doc_values = WorkflowManager_format.getAutoformSchemaValues();\n    obj[\"tableValues\"] = doc_values ? doc_values[obj.code] : [];\n    obj[\"formId\"] = \"instanceform\";\n    return obj;\n  },\n  instance: function() {\n    var steedos_instance;\n    Session.get(\"change_date\");\n    if (Session.get(\"instanceId\")) {\n      steedos_instance = WorkflowManager.getInstance();\n      return steedos_instance;\n    }\n  },\n  empty: function(val) {\n    if (val) {\n      return false;\n    } else {\n      return true;\n    }\n  },\n  unempty: function(val) {\n    if (val) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  equals: function(a, b) {\n    return a === b;\n  },\n  unequals: function(a, b) {\n    return !(a === b);\n  },\n  includes: function(a, b) {\n    return b.split(',').includes(a);\n  },\n  include: function(a, b) {\n    return b.split(',').includes(a);\n  },\n  fields: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n    }\n  },\n  formatDate: function(date, options) {\n    if (!date) {\n      return \"\";\n    }\n    if (options && typeof options === 'string') {\n      options = JSON.parse(options);\n    }\n    if (!options.format) {\n      options = {\n        format: \"YYYY-MM-DD HH:mm\"\n      };\n    }\n    return moment(date).format(options.format);\n  },\n  traces: function() {\n    var flow, instance, locale, ref, ref1, ref2, ref3, steedosData, steps, traces;\n    if (Meteor.isServer) {\n      steedosData = (ref = Template.instance()) != null ? (ref1 = ref.view) != null ? (ref2 = ref1.template) != null ? ref2.steedosData : void 0 : void 0 : void 0;\n      instance = steedosData != null ? steedosData.instance : void 0;\n      flow = InstanceReadOnlyTemplate.getFlowVersion(instance);\n      locale = steedosData != null ? steedosData.locale : void 0;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      instance = WorkflowManager.getInstance();\n      flow = WorkflowManager.getInstanceFlowVersion();\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    if (!instance || !flow) {\n      return {};\n    }\n    steps = flow.steps;\n    traces = {};\n    if ((ref3 = instance.traces) != null) {\n      ref3.forEach(function(trace) {\n        var approves, ref4, step;\n        step = steps.findPropertyByPK(\"_id\", trace.step);\n        approves = [];\n        if ((ref4 = trace.approves) != null) {\n          ref4.forEach(function(approve) {\n            var judge_name;\n            if (trace.is_finished === true) {\n              if (approve.judge === 'approved') {\n                judge_name = TAPi18n.__(\"Instance State approved\", {}, locale);\n              } else if (approve.judge === 'rejected') {\n                judge_name = TAPi18n.__(\"Instance State rejected\", {}, locale);\n              } else if (approve.judge === 'terminated') {\n                judge_name = TAPi18n.__(\"Instance State terminated\", {}, locale);\n              } else if (approve.judge === 'reassigned') {\n                judge_name = TAPi18n.__(\"Instance State reassigned\", {}, locale);\n              } else if (approve.judge === 'relocated') {\n                judge_name = TAPi18n.__(\"Instance State relocated\", {}, locale);\n              } else if (approve.judge === '') {\n                judge_name = \"\";\n              } else {\n                judge_name = \"\";\n              }\n            } else {\n              judge_name = TAPi18n.__(\"Instance State pending\", {}, locale);\n            }\n            return approves.push({\n              _id: approve._id,\n              handler: approve.user,\n              handler_name: approve.handler_name,\n              handler_organization_name: approve.handler_organization_name,\n              handler_organization_fullname: approve.handler_organization_fullname,\n              finish_date: approve.finish_date,\n              judge: approve.judge,\n              judge_name: judge_name,\n              description: approve.description,\n              is_finished: approve.is_finished,\n              type: approve.type,\n              opinion_fields_code: approve.opinion_fields_code,\n              sign_field_code: approve.sign_field_code,\n              is_read: approve.is_read,\n              sign_show: approve.sign_show\n            });\n          });\n        }\n        if (step) {\n          if (step.name in traces) {\n            return traces[step.name] = traces[step.name].concat(approves);\n          } else {\n            return traces[step.name] = approves;\n          }\n        }\n      });\n    }\n    return traces;\n  },\n  doc_values: function() {\n    return WorkflowManager_format.getAutoformSchemaValues();\n  },\n  instance_box_style: function() {\n    var box, ins, judge;\n    box = Session.get(\"box\");\n    if (box === \"inbox\" || box === \"draft\") {\n      judge = Session.get(\"judge\");\n      if (judge) {\n        if (judge === \"approved\") {\n          return \"box-success\";\n        } else if (judge === \"rejected\") {\n          return \"box-danger\";\n        }\n      }\n    }\n    ins = WorkflowManager.getInstance();\n    if (ins && ins.final_decision) {\n      if (ins.final_decision === \"approved\") {\n        return \"box-success\";\n      } else if (ins.final_decision === \"rejected\") {\n        return \"box-danger\";\n      }\n    }\n  },\n  table_fields: function(instance) {\n    var fields, form_version;\n    if (Meteor.isClient) {\n      form_version = WorkflowManager.getInstanceFormVersion();\n    } else {\n      form_version = WorkflowManager.getFormVersion(instance.form, instance.form_version);\n    }\n    if (form_version) {\n      fields = _.clone(form_version.fields);\n      fields.forEach(function(field, index) {\n        var after_field, before_field, pre_fields, pre_wide_fields, td_colspan, tr_end, tr_start;\n        field.tr_start = \"\";\n        field.tr_end = \"\";\n        td_colspan = 1;\n        if ((typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) === field.code) {\n          field.is_wide = true;\n        }\n        if (field.formula && field.type !== 'odata') {\n          field.permission = \"readonly\";\n        }\n        if (Steedos.isMobile()) {\n          if (field.type === 'section' || field.type === 'table') {\n            field.td_colspan = 4;\n          } else {\n            field.td_colspan = 3;\n          }\n          if (index !== 0) {\n            field.tr_start = \"<tr>\";\n            return field.tr_end = \"</tr>\";\n          }\n        } else {\n          pre_fields = fields.slice(0, index);\n          pre_wide_fields = pre_fields.filterProperty(\"is_wide\", true);\n          tr_start = \"\";\n          tr_end = \"\";\n          before_field = null;\n          after_field = null;\n          if (index > 0) {\n            before_field = fields[index - 1];\n          }\n          if (index < fields.length - 1) {\n            after_field = fields[index + 1];\n          }\n          if (field.type === 'section' || field.type === 'table') {\n            td_colspan = 4;\n          } else if (field.is_wide) {\n            td_colspan = 3;\n          } else {\n            if (before_field && after_field && before_field.is_wide && after_field.is_wide) {\n              field.is_wide = true;\n              td_colspan = 3;\n            }\n            if ((pre_fields.length + pre_wide_fields.length) % 2 === 0 && after_field && after_field.is_wide) {\n              field.is_wide = true;\n              td_colspan = 3;\n            }\n            if ((pre_fields.length + pre_wide_fields.length) % 2 === 0 && after_field === null) {\n              field.is_wide = true;\n              td_colspan = 3;\n            }\n          }\n          field.td_colspan = td_colspan;\n          if (index === 0) {\n            tr_start = \"<tr>\";\n          } else {\n            if ((pre_fields.length + pre_wide_fields.length) % 2 === 0 || field.is_wide) {\n              if (field.type === 'table') {\n                tr_start = \"<tr class = \\\"tr-child-table\\\">\";\n              } else {\n                tr_start = \"<tr>\";\n              }\n            }\n          }\n          field.tr_start = tr_start;\n          if (index + 1 === fields.length || field.type === 'section' || field.type === 'table' || field.is_wide) {\n            tr_end = \"</tr>\";\n          }\n          if ((pre_fields.length + pre_wide_fields.length) % 2 !== 0) {\n            tr_end = \"</tr>\";\n          }\n          return field.tr_end = tr_end;\n        }\n      });\n      return fields;\n    }\n  },\n  sort_approve: function(approves, order) {\n    if (!approves) {\n      return [];\n    }\n    if (!approves instanceof Array) {\n      return [];\n    } else {\n      if (order === 'desc') {\n        approves.sort(function(p1, p2) {\n          var _p1, _p2;\n          _p1 = 0;\n          _p2 = 0;\n          if (p1.finish_date) {\n            _p1 = p1.finish_date.getTime();\n          }\n          if (p2.finish_date) {\n            _p2 = p2.finish_date.getTime();\n          }\n          return _p2 - _p1;\n        });\n      } else {\n        approves.sort(function(p1, p2) {\n          var _p1, _p2;\n          _p1 = 0;\n          _p2 = 0;\n          if (p1.finish_date) {\n            _p1 = p1.finish_date.getTime();\n          }\n          if (p2.finish_date) {\n            _p2 = p2.finish_date.getTime();\n          }\n          return _p1 - _p2;\n        });\n      }\n    }\n    return approves;\n  },\n  _t: function(key) {\n    return TAPi18n.__(key);\n  },\n  getField: function(code) {\n    var form_version;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    if (form_version) {\n      return form_version.fields.findPropertyByPK(\"code\", code);\n    }\n  },\n  getValue: function(code) {\n    var form_version, instance, locale, utcOffset, values;\n    instance = Template.instance().view.template.steedosData.instance;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    locale = Template.instance().view.template.steedosData.locale;\n    utcOffset = Template.instance().view.template.steedosData.utcOffset;\n    values = instance.values || {};\n    if (Meteor.isClient) {\n      values = WorkflowManager_format.getAutoformSchemaValues();\n    }\n    return InstanceReadOnlyTemplate.getValue(values[code], form_version.fields.findPropertyByPK(\"code\", code), locale, utcOffset);\n  },\n  getLabel: function(code) {\n    var form_version;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    return InstanceReadOnlyTemplate.getLabel(form_version.fields, code);\n  },\n  isTextarea: function(field) {\n    if ((field != null ? field.type : void 0) === \"input\" && (field != null ? field.is_textarea : void 0)) {\n      return true;\n    }\n  },\n  getCfClass: function(field) {\n    if ((field != null ? field.type : void 0) === \"input\" && (field != null ? field.is_textarea : void 0)) {\n      return \"cfTextarea\";\n    }\n  },\n  getTableThead: function(field) {\n    return SteedosTable.getThead(field, false);\n  },\n  getTableBody: function(field) {\n    var instance, tableValue, values;\n    if (Meteor.isServer) {\n      instance = Template.instance().view.template.steedosData.instance;\n      values = instance.values || {};\n    } else {\n      values = WorkflowManager_format.getAutoformSchemaValues();\n    }\n    tableValue = values[field.code];\n    return SteedosTable.getTbody(field.sfields.getProperty(\"code\"), field, tableValue, false);\n  },\n  showLabel: function(field) {\n    var templateData;\n    templateData = Template.instance().data;\n    if (templateData.label === false) {\n      return false;\n    }\n    return true;\n  },\n  isOpinionField: function(field) {\n    return InstanceformTemplate.helpers.isOpinionField_from_string(field.formula);\n  },\n  isOpinionField_from_string: function(field_formula) {\n    return InstanceSignText.isOpinionField_from_string(field_formula);\n  },\n  includesOpinionField: function(form, form_version) {\n    var field_formulas, fields, ref;\n    field_formulas = new Array();\n    fields = ((ref = db.form_versions.findOne({\n      _id: form_version,\n      form: form\n    })) != null ? ref.fields : void 0) || [];\n    fields.forEach(function(f) {\n      var ref1;\n      if (f.type === 'table') {\n        return console.log('ignore opinion field in table');\n      } else if (f.type === 'section') {\n        return f != null ? (ref1 = f.fields) != null ? ref1.forEach(function(f1) {\n          return field_formulas.push(f1.formula);\n        }) : void 0 : void 0;\n      } else {\n        return field_formulas.push(f.formula);\n      }\n    });\n    return _.some(field_formulas, function(field_formula) {\n      return InstanceformTemplate.helpers.isOpinionField_from_string(field_formula);\n    });\n  },\n  getOpinionFieldStepsName: function(field_formula, top_keywords) {\n    var foo1, opinionFields;\n    opinionFields = new Array();\n    if (InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)) {\n      if (field_formula) {\n        foo1 = field_formula.split(\";\");\n        foo1.forEach(function(foo) {\n          var json_formula, ref, ref1, s1, sf;\n          json_formula = {};\n          try {\n            json_formula = eval(\"(\" + foo + \")\");\n          } catch (error1) {\n            json_formula = {};\n          }\n          if (json_formula != null ? json_formula.yijianlan : void 0) {\n            sf = {};\n            sf.stepName = json_formula.yijianlan.step;\n            sf.image_sign = json_formula.yijianlan.image_sign || false;\n            sf.only_cc_opinion = json_formula.yijianlan.only_cc || false;\n            sf.default_description = json_formula.yijianlan[\"default\"];\n            sf.only_handler = json_formula.yijianlan.only_handler;\n            sf.top_keywords = json_formula.yijianlan.top_keywords || top_keywords;\n            return opinionFields.push(sf);\n          } else if ((field_formula != null ? field_formula.indexOf(\"{traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{signature.traces.\") : void 0) > -1) {\n            sf = {\n              only_cc_opinion: false,\n              image_sign: false,\n              top_keywords: top_keywords\n            };\n            if (foo.indexOf(\"{signature.\") > -1) {\n              sf.image_sign = true;\n              foo = foo.replace(\"{signature.\", \"\");\n            }\n            s1 = foo.replace(\"{\", \"\").replace(\"}\", \"\");\n            if (s1.split(\".\").length > 1) {\n              sf.stepName = s1.split(\".\")[1];\n              if (opinionFields.filterProperty(\"stepName\", sf.stepName).length > 0) {\n                if ((ref = opinionFields.findPropertyByPK(\"stepName\", sf.stepName)) != null) {\n                  ref.only_cc_opinion = true;\n                }\n              } else {\n                if (s1.split(\".\").length > 2) {\n                  if (((ref1 = s1.split(\".\")[2]) != null ? ref1.toLocaleLowerCase() : void 0) === 'cc') {\n                    sf.only_cc_opinion = true;\n                  }\n                }\n              }\n            }\n            return opinionFields.push(sf);\n          }\n        });\n      }\n    }\n    return opinionFields;\n  },\n  showCCOpinion: function(field) {\n    var ref, ref1, ref2, s1;\n    if (((ref = field.formula) != null ? ref.indexOf(\"{traces.\") : void 0) > -1 || ((ref1 = field.formula) != null ? ref1.indexOf(\"{signature.traces.\") : void 0) > -1) {\n      s1 = field.formula.replace(\"{signature.\", \"\").replace(\"{\", \"\").replace(\"}\", \"\");\n      if (s1.split(\".\").length > 2) {\n        if (((ref2 = s1.split(\".\")[2]) != null ? ref2.toLocaleLowerCase() : void 0) === 'cc') {\n          return true;\n        }\n      }\n    }\n    return false;\n  },\n  markDownToHtml: function(markDownString) {\n    if (markDownString) {\n      if (Meteor.isServer) {\n        marked = Npm.require('marked');\n      }\n      return Spacebars.SafeString(marked.parse(markDownString));\n    }\n  },\n  f_label: function(that) {\n    return that.name || that.code;\n  }\n};\n\nif (Meteor.isServer) {\n  InstanceformTemplate.helpers.steedos_form = function() {\n    return this.form_version;\n  };\n  InstanceformTemplate.helpers.isSection = function(code) {\n    var form_version;\n    form_version = this.form_version;\n    return form_version.fields.findPropertyByPK(\"code\", code).type === 'section';\n  };\n  InstanceformTemplate.helpers.doc_values = function() {\n    var instance;\n    instance = this.instance;\n    return instance.values;\n  };\n  InstanceformTemplate.helpers.applicantContext = function() {\n    var data, instance;\n    instance = this.instance;\n    return data = {\n      name: 'ins_applicant',\n      atts: {\n        name: 'ins_applicant',\n        id: 'ins_applicant',\n        \"class\": 'selectUser form-control ins_applicant'\n      },\n      value: instance.applicant_name\n    };\n  };\n  InstanceformTemplate.helpers.instance = function() {\n    return this.instance;\n  };\n  InstanceformTemplate.helpers.fields = function() {\n    var form_version;\n    form_version = this.form_version;\n    if (form_version) {\n      return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n    }\n  };\n  InstanceformTemplate.helpers.form_types = function() {\n    return \"disabled\";\n  };\n  Template.registerHelper(\"afFieldLabelText\", function(op) {\n    var form_version, ref;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    return InstanceReadOnlyTemplate.getLabel(form_version.fields, op != null ? (ref = op.hash) != null ? ref.name : void 0 : void 0);\n  });\n  InstanceformTemplate.helpers._t = function(key) {\n    var locale;\n    locale = this.locale;\n    return TAPi18n.__(key, {}, locale);\n  };\n  InstanceformTemplate.helpers.ins_attach_download_url = function(_id, absolute) {\n    if (absolute) {\n      return Meteor.absoluteUrl(\"/api/files/instances/\" + _id + \"?download=true\");\n    } else {\n      return \"/api/files/instances/\" + _id + \"?download=true\";\n    }\n  };\n  InstanceformTemplate.helpers.options = function(field) {\n    var options, ref, rev;\n    options = field != null ? (ref = field.options) != null ? ref.split(\"\\n\") : void 0 : void 0;\n    rev = [];\n    if (options != null) {\n      options.forEach(function(item) {\n        return rev.push({\n          label: item,\n          value: item\n        });\n      });\n    }\n    return rev;\n  };\n  InstanceformTemplate.helpers.getPermissions = function(code) {\n    var ref;\n    if (!((ref = Template.instance().view.template.steedosData.startStepEditableFields) != null ? ref.includes(code) : void 0)) {\n      return \"readonly disabled\";\n    }\n    return \"\";\n  };\n}\n\nInstanceformTemplate.events = {\n  'change .form-control,.checkbox input,.af-radio-group input,.af-checkbox-group input': function(event) {\n    return InstanceManager.instanceformChangeEvent(event);\n  },\n  'typeahead:change .form-control': function(event) {\n    return InstanceManager.instanceformChangeEvent(event);\n  },\n  'click .cfTextarea a': function(event) {\n    event.preventDefault();\n    return Steedos.openWindow(event.target.href);\n  }\n};\n\nInstanceformTemplate.onCreated = function() {\n  var compiled, e, instance, instanceCustomTemplate, instanceView, renderFunction, template;\n  instance = WorkflowManager.getInstance();\n  if (!instance) {\n    return;\n  }\n  template = TemplateManager.getTemplate(instance);\n  try {\n    compiled = SpacebarsCompiler.compile(template, {\n      isBody: true\n    });\n  } catch (error1) {\n    e = error1;\n    console.log(\"Instance Template Error\", e);\n    compiled = SpacebarsCompiler.compile(\"\", {\n      isBody: true\n    });\n  }\n  renderFunction = eval(compiled);\n  instanceView = new Blaze.View(\"custom_instance_template\", renderFunction);\n  instanceCustomTemplate = new Blaze.Template(instanceView.name, renderFunction);\n  Template.instance_custom_template = instanceCustomTemplate;\n  return Template.instance_custom_template.helpers(InstanceformTemplate.helpers);\n};\n\nInstanceformTemplate.onRendered = function() {\n  var currentApprove, currentStep, form_version, formula_fields, insertDoc, instance, instanceNumberFields, judge;\n  instance = WorkflowManager.getInstance();\n  if (!instance) {\n    return;\n  }\n  InstanceManager.setInstanceFormApplicant(instance.applicant, instance.applicant_name);\n  ApproveManager.error = {\n    nextSteps: '',\n    nextStepUsers: ''\n  };\n  if (Session.get(\"box\") === 'inbox' || Session.get(\"box\") === 'draft') {\n    InstanceEvent.initEvents(instance.flow);\n  }\n  if (!ApproveManager.isReadOnly()) {\n    currentApprove = InstanceManager.getCurrentApprove();\n    instanceNumberFields = $(\"[data-formula]\", $(\"#instanceform\"));\n    instanceNumberFields.each(function() {\n      var element, schemaKey;\n      schemaKey = this.dataset.schemaKey;\n      element = $(this);\n      if (!$(this).val() && schemaKey && Session.get(\"instanceId\")) {\n        return Meteor.call('getInstanceValues', Session.get(\"instanceId\"), function(error, result) {\n          var key, ref;\n          if (error) {\n            toastr.error(error.reason);\n          }\n          if (!result[schemaKey]) {\n            key = (ref = element.data(\"formula\")) != null ? ref.replace(\"auto_number(\", \"\").replace(\")\", \"\") : void 0;\n            key = key.replace(/\\\"/g, \"\").replace(/\\'/g, \"\");\n            if (key.indexOf(\"{\") > -1) {\n              key = key.replace(\"{\", \"\").replace(\"}\", \"\");\n              key = key.trim();\n              key = AutoForm.getFieldValue(key, 'instanceform');\n            }\n            return InstanceNumberRules.instanceNumberBuilder(element, key);\n          } else {\n            return element != null ? element.val(result[schemaKey]).trigger(\"change\") : void 0;\n          }\n        });\n      }\n    });\n    judge = currentApprove.judge;\n    currentStep = InstanceManager.getCurrentStep();\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (!form_version) {\n      return;\n    }\n    if (!form_version.fields) {\n      return;\n    }\n    formula_fields = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", form_version.fields);\n    insertDoc = AutoForm.getFormValues(\"instanceform\", void 0, void 0, false);\n    Form_formula.run(\"\", \"\", formula_fields, insertDoc, form_version.fields);\n    return Session.set(\"instance_form_values\", {\n      instanceId: instance._id,\n      values: insertDoc\n    });\n  }\n};\n","InstanceAttachmentTemplate.helpers = {\n\n\tshowMainTitle: function() {\n\t\treturn Template.instance().workflowMainAttachTitle.get();\n\t},\n\tisClient: function() {\n\t\treturn Meteor.isClient\n\t},\n\tenabled_add_main_attachment: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tif (Session && Session.get(\"instancePrint\"))\n\t\t\treturn false\n\n\t\tif (Session.get(\"box\") != \"draft\" && Session.get(\"box\") != \"inbox\") {\n\t\t\treturn false\n\t\t}\n\n\t\t// 已经结束的单子不能改附件\n\t\tif (ins.state == \"completed\") {\n\t\t\treturn false\n\t\t}\n\n\t\tvar current_step = InstanceManager.getCurrentStep();\n\n\t\tif (!current_step)\n\t\t\treturn false;\n\n\t\t// cc的单子，只有在当前步骤才能修改附件\n\t\tvar approve = InstanceManager.getCurrentApprove();\n\t\tif (approve && approve.type == \"cc\") {\n\t\t\tvar currentTrace = InstanceManager.getCurrentTrace();\n\t\t\tif(currentTrace && currentTrace._id != approve.trace){\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\t// 分发的正文或者附件不显示转为pdf按钮\n\t\t// 如果有正文权限则为正文，否则分发为附件\n\t\t// 分发的附件不允许修改 删除 新增版本\n\t\tvar main_attach_count = cfs.instances.find({\n\t\t\t'metadata.instance': ins._id,\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': true\n\t\t}).count();\n\n\t\tvar distribute_main_attach_count = 0;\n\n\t\tif (ins.distribute_from_instance) {\n\t\t\tvar start_step = InstanceManager.getStartStep();\n\t\t\tif (start_step.can_edit_main_attach) {\n\t\t\t\tvar distribute_main_attach_count = cfs.instances.find({\n\t\t\t\t\t'metadata.instance': ins.distribute_from_instance,\n\t\t\t\t\t'metadata.current': true,\n\t\t\t\t\t'metadata.main': true\n\t\t\t\t}).count();\n\t\t\t}\n\t\t}\n\n\t\tif (current_step.can_edit_main_attach == true && main_attach_count < 1 && distribute_main_attach_count < 1) {\n\t\t\treturn true\n\t\t}\n\n\t\t// 正文最多只能有一个\n\t\tif (main_attach_count >= 1 || distribute_main_attach_count >= 1) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// 开始节点并且设置了可以上传正文才显示上传正文的按钮\n\t\tvar current_step = InstanceManager.getCurrentStep();\n\t\tif (current_step && current_step.step_type == \"start\" && current_step.can_edit_main_attach == true)\n\t\t\treturn true\n\n\t\treturn false\n\t},\n\n\tenabled_edit_normal_attachment: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tif (Session && Session.get(\"instancePrint\"))\n\t\t\treturn false\n\n\t\tvar flow = WorkflowManager.getFlow(ins.flow);\n\t\tif (!flow)\n\t\t\treturn false\n\n\n\t\t// 分发后的 附件，不可以编辑/删除，也不让上传新的附件, 流程列表：添加属性 ‘被分发后是否允许上传附件’ #1837\n\t\tif (ins.distribute_from_instance && !flow.upload_after_being_distributed)\n\t\t\treturn false\n\n\t\tif (Session.get(\"box\") != \"draft\" && Session.get(\"box\") != \"inbox\") {\n\t\t\treturn false\n\t\t}\n\n\t\t// 已经结束的单子不能改附件\n\t\tif (ins.state == \"completed\") {\n\t\t\treturn false\n\t\t}\n\n\t\t// cc的单子，只有在当前步骤才能修改附件\n\t\tvar approve = InstanceManager.getCurrentApprove();\n\t\tif (approve && approve.type == \"cc\") {\n\t\t\tvar currentTrace = InstanceManager.getCurrentTrace();\n\t\t\tif(currentTrace && currentTrace._id != approve.trace){\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tif (InstanceManager.isCC(ins)) {\n\t\t\tvar step = InstanceManager.getCCStep();\n\t\t\tif (step && (step.can_edit_normal_attach == true || step.can_edit_normal_attach == undefined))\n\t\t\t\treturn true\n\t\t} else {\n\t\t\tvar current_step = InstanceManager.getCurrentStep();\n\t\t\tif (current_step && (current_step.can_edit_normal_attach == true || current_step.can_edit_normal_attach == undefined))\n\t\t\t\treturn true\n\t\t}\n\n\t\treturn false\n\t},\n\n\tmain_attachment: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tvar start_step = InstanceManager.getStartStep();\n\n\t\t// 如果是被分发的申请单并且有修改正文的权限，则优先显示原申请单文件\n\t\tvar main_attach = null;\n\t\tif (ins.distribute_from_instance && start_step.can_edit_main_attach == true) {\n\t\t\tmain_attach = cfs.instances.findOne({\n\t\t\t\t'metadata.instance': ins.distribute_from_instance,\n\t\t\t\t'metadata.current': true,\n\t\t\t\t'metadata.main': true\n\t\t\t});\n\t\t}\n\n\t\tif (!main_attach) {\n\t\t\tmain_attach = cfs.instances.findOne({\n\t\t\t\t'metadata.instance': ins._id,\n\t\t\t\t'metadata.current': true,\n\t\t\t\t'metadata.main': true\n\t\t\t});\n\t\t}\n\n\t\treturn main_attach;\n\t},\n\n\tnormal_attachments: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tvar selector = {\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': {\n\t\t\t\t$ne: true\n\t\t\t},\n\t\t};\n\n\t\tvar atts = new Array();\n\n\t\tif (ins.distribute_from_instance) {\n\t\t\t// 如果是被分发的申请单，则显示原申请单文件, 如果选择了将原表单存储为附件也要显示, 同时也要显示新上传的附件\n\t\t\tvar dfis = _.clone(ins.distribute_from_instances) || [];\n\t\t\tdfis.push(ins._id);\n\t\t\tselector['metadata.instance'] = {\n\t\t\t\t$in: dfis\n\t\t\t};\n\n\n\t\t\tselector[\"$or\"] = [{\n\t\t\t\t\"metadata.instance\": ins._id\n\t\t\t}, {\n\t\t\t\t\"metadata.instance\": {\n\t\t\t\t\t$in: ins.distribute_from_instances\n\t\t\t\t},\n\t\t\t\t\"metadata.is_private\": {\n\t\t\t\t\t$ne: true\n\t\t\t\t}\n\t\t\t}]\n\n\t\t\t// 如果原申请单有正文但是分发后没有正文权限，则原申请单正文显示在附件栏\n\t\t\tvar start_step = InstanceManager.getStartStep();\n\t\t\tif (start_step && start_step.can_edit_main_attach != true) {\n\t\t\t\tvar distribute_main = cfs.instances.findOne({\n\t\t\t\t\t'metadata.instance': {\n\t\t\t\t\t\t$in: ins.distribute_from_instances\n\t\t\t\t\t},\n\t\t\t\t\t'metadata.current': true,\n\t\t\t\t\t'metadata.main': true,\n\t\t\t\t});\n\t\t\t\tif (distribute_main) {\n\t\t\t\t\tvar firstVersionMain = cfs.instances.findOne(distribute_main.metadata.parent);\n\t\t\t\t\tdistribute_main.attachmentUploadedAt = firstVersionMain ? firstVersionMain.uploadedAt : distribute_main.uploadedAt;\n\t\t\t\t\tatts.push(distribute_main);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tselector['metadata.instance'] = ins._id;\n\t\t}\n\n\t\tcfs.instances.find(selector).forEach(function(c) {\n\t\t\tvar firstVersion = cfs.instances.findOne(c.metadata.parent);\n\t\t\tc.attachmentUploadedAt = firstVersion ? firstVersion.uploadedAt : c.uploadedAt;\n\t\t\tatts.push(c);\n\t\t})\n\n\t\treturn _.sortBy(atts, 'attachmentUploadedAt');\n\t},\n\n\tshowAttachments: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false;\n\n\t\t// 如果是被分发的申请单，则显示原申请单文件 和分发后申请单文件\n\t\tvar instanceIds = _.clone(ins.distribute_from_instances) || [];\n\t\tinstanceIds.push(ins._id);\n\t\tvar attachments_count = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true\n\t\t}).count();\n\n\t\tif (Session && Session.get(\"instancePrint\") && attachments_count < 1)\n\t\t\treturn false\n\n\t\tif (Session.get(\"box\") == \"draft\" || Session.get(\"box\") == \"inbox\" || attachments_count > 0)\n\t\t\treturn true;\n\t\telse\n\t\t\treturn false;\n\t},\n\n\t_t: function(key) {\n\t\treturn TAPi18n.__(key)\n\t},\n\n\t_: function(key) {\n\t\tvar locale;\n\t\tif (Meteor.isClient) {\n\t\t\treturn TAPi18n.__(key);\n\t\t} else {\n\t\t\tlocale = Template.instance().view.template.steedosData.locale;\n\t\t\treturn TAPi18n.__(key, {}, locale);\n\t\t}\n\t},\n\n\tflow_files: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false;\n\t\treturn cfs.files.find({ 'metadata.space': ins.space, 'metadata.object_name': 'flows', 'metadata.record_id': ins.flow });\n\t},\n\n\tisDraftAndFlowfilesExist: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false;\n\t\treturn (Session.get('box') == 'draft') && !!cfs.files.find({ 'metadata.space': ins.space, 'metadata.object_name': 'flows', 'metadata.record_id': ins.flow }).count();\n\t}\n\n\n}\n\nif (Meteor.isServer) {\n\tInstanceAttachmentTemplate.helpers._t = function(key) {\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\treturn TAPi18n.__(key, {}, locale)\n\t}\n\tInstanceAttachmentTemplate.helpers.enabled_add_main_attachment = function() {\n\t\treturn false\n\t};\n\tInstanceAttachmentTemplate.helpers.enabled_edit_normal_attachment = function() {\n\t\treturn false\n\t};\n\n\tInstanceAttachmentTemplate.helpers.main_attachment = function() {\n\t\tvar instance = Template.instance().view.template.steedosData.instance;\n\t\tvar instanceIds = _.compact([instance.distribute_from_instance, instance._id]);\n\t\tvar attachment = cfs.instances.findOne({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': true\n\t\t});\n\n\t\treturn attachment;\n\t};\n\n\tInstanceAttachmentTemplate.helpers.normal_attachments = function() {\n\t\tvar steedosData = Template.instance().view.template.steedosData\n\t\tvar instance = steedosData.instance;\n\t\tvar instanceIds = _.clone(instance.distribute_from_instances) || [];\n\t\tinstanceIds.push(instance._id);\n\t\tvar attachments = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': {\n\t\t\t\t$ne: true\n\t\t\t},\n\t\t\t$or: [{\n\t\t\t\t'metadata.is_private': {\n\t\t\t\t\t$ne: true\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\t'metadata.is_private': true,\n\t\t\t\t\"metadata.owner\": steedosData.sessionUserId || steedosData.userId || '-1' // 防止数据异常时,显示了私有附件\n\t\t\t}]\n\t\t}).fetch();\n\n\t\treturn attachments;\n\t};\n\n\tInstanceAttachmentTemplate.helpers.showAttachments = function() {\n\t\tvar instance = Template.instance().view.template.steedosData.instance;\n\t\tvar instanceIds = _.clone(instance.distribute_from_instances) || [];\n\t\tinstanceIds.push(instance._id);\n\n\t\tvar attachments = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true\n\t\t}).fetch();\n\n\t\tif (attachments && attachments.length > 0) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\n\tInstanceAttachmentTemplate.helpers.showMainTitle = function() {\n\t\tvar instance = Template.instance().view.template.steedosData.instance;\n\t\tvar instanceIds = _.compact([instance.distribute_from_instance, instance._id]);\n\t\tvar main_attach_count = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': true\n\t\t}).count();\n\n\t\treturn main_attach_count > 0\n\t}\n}\n","marked = require(\"marked\")\nInstanceSignText.helpers =\n\tshow: (stepName)->\n\t\tif Meteor.isClient\n\t\t\tif Session.get('instancePrint')\n\t\t\t\treturn false\n\t\t\tif InstanceManager.isInbox()\n\t\t\t\tmyApprove = InstanceManager.getCurrentApprove()\n\t\t\t\tif myApprove\n\t\t\t\t\tinstance = WorkflowManager.getInstance();\n\t\t\t\t\tmyTrace = instance?.traces?.findPropertyByPK(\"_id\", myApprove.trace)\n\t\t\t\t\treturn myTrace?.name == stepName\n\t\treturn false\n\n\tdefaultDescription: ()->\n#\t\treturn Template.instance().data.default_description || TAPi18n.__(\"instance_default_opinion\")\n\t\treturn Template.instance().data.default_description\n\n\ttraces: ()->\n\t\tInstanceformTemplate.helpers.traces()\n\n\ttrace: (stepName, only_cc_opinion, image_sign, top_keywords)->\n\t\tinstance = InstanceformTemplate.helpers.instance()\n\n\t\tis_completed = instance?.state == \"completed\"\n\n\t\tcompleted_date = if is_completed then _.last(instance.traces)?.finish_date?.getTime() else 0\n\n\t\tif is_completed && instance.finish_date\n\t\t\tcompleted_date = instance.finish_date?.getTime()\n\n\t\ttraces = InstanceformTemplate.helpers.traces()\n\n\t\tapproves = _.clone(traces[stepName])\n\n\t\tapprove_sort = (approves, top_keywords)->\n\n#对Approves排序， 按照提交时间排倒序，如果没有提交则显示在最上边\n\t\t\tapproves_sorted = _.sortBy approves, (approve)->\n\t\t\t\treturn -(approve.finish_date || new Date()).getTime()\n\n\t\t\t#通过关键字排序\n\t\t\tif top_keywords\n\t\t\t\ttop_approves = new Array()\n\n\t\t\t\ttop_keywords.split(\",\").forEach (key) ->\n\t\t\t\t\ttop_approves = _.union top_approves, _.filter(approves_sorted, (approve)->\n\t\t\t\t\t\treturn approve?.handler_name?.indexOf(key) > -1\n\t\t\t\t\t)\n\t\t\t\t# 对置顶意见按照处理事件排倒序\n\t\t\t\ttop_approves = _.sortBy top_approves, (top_approve)->\n\t\t\t\t\treturn -(top_approve.finish_date || new Date()).getTime()\n\n\t\t\t\tapproves_sorted = _.union top_approves, approves_sorted\n\t\t\treturn approves_sorted || []\n\n\t\tapproves = _.filter approves, (a)->\n\t\t\treturn a.type isnt \"forward\" and a.type isnt \"distribute\" and a.type isnt \"terminated\"\n\n\t\tif only_cc_opinion\n\t\t\tapproves = approves?.filterProperty(\"type\", \"cc\")\n\n\t\tapproves_sorted = approve_sort(approves, top_keywords)\n\n\t\tapprovesGroup = _.groupBy(approves, \"handler\");\n\n\t\thasNext = (approve, approvesGroup) ->\n\t\t\thandlerApproves = approvesGroup[approve.handler]\n\t\t\treturn _.indexOf(handlerApproves, approve) + 1 < handlerApproves.length\n\n\t\thaveDescriptionApprove = (approve, approvesGroup) ->\n\t\t\thandlerApproves = approvesGroup[approve.handler]\n\n\t\t\tdescriptionApproves = _.filter handlerApproves, (a)->\n\t\t\t\tif a.description\n\t\t\t\t\treturn true\n\t\t\t\treturn false\n\n\t\t\tif descriptionApproves.length == 0\n\t\t\t\treturn false\n\n\t\t\treturn true\n\n\n\t\tapproves_sorted.forEach (approve) ->\n#\t\t\t有输入意见 或 最新一条并且用户没有输入过意见\n#\t\t\tif !approve.is_finished || approve.description || (!hasNext(approve, approvesGroup) && !haveDescriptionApprove(approve, approvesGroup))\n#\t\t\tif !hasNext(approve, approvesGroup)\n\t\t\tif approve.sign_show != false && (approve.description || (!approve.description && !hasNext(approve, approvesGroup) && !approve.is_finished) || Meteor.settings.public.workflow?.showBlankApproveDescription)\n\t\t\t\tif approve.judge isnt 'terminated'\n\t\t\t\t\tapprove._display = true\n\n\t\tapproves_sorted = _.filter approves_sorted, (a) ->\n\t\t\tif is_completed\n\t\t\t\treturn a._display == true && a.is_finished && a.finish_date?.getTime() <= completed_date\n\t\t\telse\n\t\t\t\treturn a._display == true\n\t\treturn approves_sorted\n\n\tinclude: (a, b) ->\n\t\treturn InstanceformTemplate.helpers.include(a, b)\n\n\tunempty: (val)->\n\t\treturn InstanceformTemplate.helpers.unempty(val) || Meteor.settings.public.workflow?.showBlankApproveDescription\n\n\tformatDate: (date, options)->\n\t\tif !options\n\t\t\toptions = {\"format\": \"YYYY-MM-DD\"}\n\n\t\treturn InstanceformTemplate.helpers.formatDate(date, options)\n\n\tisMyApprove: (approve, only_cc_opinion) ->\n\t\tif Meteor.isClient\n\t\t\tif Session.get(\"box\") != 'inbox'\n\t\t\t\treturn false;\n\t\t\tins = WorkflowManager.getInstance();\n\n\t\t\tcurrentApprove = InstanceManager.getCurrentApprove()\n\n\t\t\tif !approve?._id\n\t\t\t\tapprove = currentApprove\n\n\t\t\tif approve._id == currentApprove?._id && currentApprove?.type == 'cc' && Template.instance().data.name\n\t\t\t\tif _.indexOf(currentApprove?.opinion_fields_code, Template.instance().data.name) > -1\n\t\t\t\t\treturn true\n\t\t\t\telse\n\t\t\t\t\treturn false\n\n\t\t\tif !(currentApprove?.type == 'cc') && only_cc_opinion\n\t\t\t\treturn false\n\n\t\t\tif currentApprove && approve._id == currentApprove._id\n\t\t\t\treturn true\n\t\treturn false\n\n\tmyApproveDescription: (approveId)->\n\t\tif Meteor.isClient\n\t\t\tif Session.get(\"box\") == 'inbox'\n\t\t\t\tmyApprove = Template.instance()?.myApprove?.get()\n\t\t\t\tif myApprove && myApprove.id == approveId\n\t\t\t\t\tif !myApprove.sign_field_code || myApprove.sign_field_code == Template.instance()?.data?.name\n\t\t\t\t\t\tif !Session.get(\"instance_my_approve_description\")\n\t\t\t\t\t\t\treturn myApprove?.description || \"\"\n\t\t\t\t\t\treturn Session.get(\"instance_my_approve_description\")\n\n\tnow: ()->\n\t\treturn new Date();\n\n\tisReadOnly: ()->\n\t\tif Meteor.isClient\n\t\t\treturn ApproveManager.isReadOnly()\n\t\treturn false\n\n\tisOpinionOfField: (approve)->\n\t\tif approve.type == \"cc\" && Template.instance().data.name\n\t\t\tif Template.instance().data.name == approve.sign_field_code\n\t\t\t\treturn true\n\t\t\telse\n\t\t\t\treturn false\n\t\telse\n\t\t\treturn true;\n\n\tmarkDownToHtml: (markDownString)->\n\t\tif markDownString\n\t\t\t# renderer = new Markdown.Renderer();\n\t\t\t# renderer.link = (href, title, text) ->\n\t\t\t# \treturn \"<a target='_blank' href='#{href}' title='#{title}'>#{text}</a>\"\n\t\t\tif Meteor.isServer\n\t\t\t\tmarked = Npm.require('marked')\n\t\t\treturn Spacebars.SafeString(marked.parse(markDownString))\n\n\tsteps: (field_formula, step, only_cc_opinion, image_sign)->\n\t\tsteps = []\n\t\tif !step\n\t\t\tif !field_formula\n\t\t\t\tfield_formula = WorkflowManager.getInstanceFormVersion()?.fields?.findPropertyByPK(\"code\", this.name).formula\n\t\t\tsteps = InstanceformTemplate.helpers.getOpinionFieldStepsName(field_formula, Template.instance()?.data.top_keywords)\n\t\telse\n\t\t\tsteps = [{stepName: step, only_cc_opinion: only_cc_opinion, image_sign: image_sign}]\n\t\treturn steps\n\n\timageSignData: (handler) ->\n\t\treturn {user: handler}\n\n\tshowSignImage: (handler, image_sign, judge) ->\n\t\tif ['returned', 'terminated', 'retrieved'].includes(judge)\n\t\t\treturn false\n\t\tspaceUserSign = ImageSign.helpers.spaceUserSign(handler)\n\n\t\tif spaceUserSign?.sign && image_sign\n\t\t\treturn true\n\t\telse\n\t\t\treturn false\n\n\tgetLastSignApprove: ()->\n\t\tins = WorkflowManager.getInstance();\n\n\t\treturn _.last(TracesManager.getHandlerSignShowApproves ins, Meteor.userId())\n\n\n\tlastMyApproveDescription: ()->\n\t\ttraces = InstanceformTemplate.helpers.traces()\n\t\tcurrentStep = InstanceManager.getCurrentStep();\n\t\tapproves = _.clone(traces[currentStep.name])\n\n\t\tapproves = approves.filterProperty(\"handler\", Meteor.userId())\n\n\t\tif approves.length > 1\n\t\t\treturn approves[approves.length - 2]?.description\n\n\t\treturn \"\";\n\n\tshowApprove: (approve)->\n\t\tif !approve.sign_field_code || approve.sign_field_code == Template.instance()?.data?.name\n\t\t\tif approve?.is_read\n\t\t\t\tif approve.is_finished\n\t\t\t\t\treturn [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(approve.judge)\n\t\treturn false;\n\n\tjudge_description: (judge)->\n\t\treturn t(judge + \"_description\")\n\n\tis_approved: (judge)->\n\t\treturn \"approved\" == judge\n\n\tis_rejected: (judge)->\n\t\treturn \"rejected\" == judge\n\n\tis_readed: (judge)->\n\t\treturn [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(judge)\n\n\taddClass: ()->\n\t\tname = Template.instance()?.data?.name\n\t\tsetTimeout () ->\n\t\t\ttry\n\t\t\t\telement = $(\".automatic.opinion-field-\" + name)\n\t\t\t\tif element.length > 0\n\t\t\t\t\tif element?.is(\"td\")\n\t\t\t\t\t\telement.addClass('field-editable')\n\t\t\t\t\telse\n\t\t\t\t\t\t$(\".instance-sign\", element).addClass('field-editable')\n\t\t\tcatch e\n\t\t\t\tconsole.log e\n\t\t, 1\n\t\treturn ''\n\nif Meteor.isServer\n\tInstanceSignText.helpers.defaultDescription = ->\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\treturn Template.instance().data.default_description || TAPi18n.__(\"instance_default_opinion\", {}, locale)","var marked;\n\nmarked = require(\"marked\");\n\nInstanceSignText.helpers = {\n  show: function(stepName) {\n    var instance, myApprove, myTrace, ref;\n    if (Meteor.isClient) {\n      if (Session.get('instancePrint')) {\n        return false;\n      }\n      if (InstanceManager.isInbox()) {\n        myApprove = InstanceManager.getCurrentApprove();\n        if (myApprove) {\n          instance = WorkflowManager.getInstance();\n          myTrace = instance != null ? (ref = instance.traces) != null ? ref.findPropertyByPK(\"_id\", myApprove.trace) : void 0 : void 0;\n          return (myTrace != null ? myTrace.name : void 0) === stepName;\n        }\n      }\n    }\n    return false;\n  },\n  defaultDescription: function() {\n    return Template.instance().data.default_description;\n  },\n  traces: function() {\n    return InstanceformTemplate.helpers.traces();\n  },\n  trace: function(stepName, only_cc_opinion, image_sign, top_keywords) {\n    var approve_sort, approves, approvesGroup, approves_sorted, completed_date, hasNext, haveDescriptionApprove, instance, is_completed, ref, ref1, ref2, traces;\n    instance = InstanceformTemplate.helpers.instance();\n    is_completed = (instance != null ? instance.state : void 0) === \"completed\";\n    completed_date = is_completed ? (ref = _.last(instance.traces)) != null ? (ref1 = ref.finish_date) != null ? ref1.getTime() : void 0 : void 0 : 0;\n    if (is_completed && instance.finish_date) {\n      completed_date = (ref2 = instance.finish_date) != null ? ref2.getTime() : void 0;\n    }\n    traces = InstanceformTemplate.helpers.traces();\n    approves = _.clone(traces[stepName]);\n    approve_sort = function(approves, top_keywords) {\n      var approves_sorted, top_approves;\n      approves_sorted = _.sortBy(approves, function(approve) {\n        return -(approve.finish_date || new Date()).getTime();\n      });\n      if (top_keywords) {\n        top_approves = new Array();\n        top_keywords.split(\",\").forEach(function(key) {\n          return top_approves = _.union(top_approves, _.filter(approves_sorted, function(approve) {\n            var ref3;\n            return (approve != null ? (ref3 = approve.handler_name) != null ? ref3.indexOf(key) : void 0 : void 0) > -1;\n          }));\n        });\n        top_approves = _.sortBy(top_approves, function(top_approve) {\n          return -(top_approve.finish_date || new Date()).getTime();\n        });\n        approves_sorted = _.union(top_approves, approves_sorted);\n      }\n      return approves_sorted || [];\n    };\n    approves = _.filter(approves, function(a) {\n      return a.type !== \"forward\" && a.type !== \"distribute\" && a.type !== \"terminated\";\n    });\n    if (only_cc_opinion) {\n      approves = approves != null ? approves.filterProperty(\"type\", \"cc\") : void 0;\n    }\n    approves_sorted = approve_sort(approves, top_keywords);\n    approvesGroup = _.groupBy(approves, \"handler\");\n    hasNext = function(approve, approvesGroup) {\n      var handlerApproves;\n      handlerApproves = approvesGroup[approve.handler];\n      return _.indexOf(handlerApproves, approve) + 1 < handlerApproves.length;\n    };\n    haveDescriptionApprove = function(approve, approvesGroup) {\n      var descriptionApproves, handlerApproves;\n      handlerApproves = approvesGroup[approve.handler];\n      descriptionApproves = _.filter(handlerApproves, function(a) {\n        if (a.description) {\n          return true;\n        }\n        return false;\n      });\n      if (descriptionApproves.length === 0) {\n        return false;\n      }\n      return true;\n    };\n    approves_sorted.forEach(function(approve) {\n      var ref3;\n      if (approve.sign_show !== false && (approve.description || (!approve.description && !hasNext(approve, approvesGroup) && !approve.is_finished) || ((ref3 = Meteor.settings[\"public\"].workflow) != null ? ref3.showBlankApproveDescription : void 0))) {\n        if (approve.judge !== 'terminated') {\n          return approve._display = true;\n        }\n      }\n    });\n    approves_sorted = _.filter(approves_sorted, function(a) {\n      var ref3;\n      if (is_completed) {\n        return a._display === true && a.is_finished && ((ref3 = a.finish_date) != null ? ref3.getTime() : void 0) <= completed_date;\n      } else {\n        return a._display === true;\n      }\n    });\n    return approves_sorted;\n  },\n  include: function(a, b) {\n    return InstanceformTemplate.helpers.include(a, b);\n  },\n  unempty: function(val) {\n    var ref;\n    return InstanceformTemplate.helpers.unempty(val) || ((ref = Meteor.settings[\"public\"].workflow) != null ? ref.showBlankApproveDescription : void 0);\n  },\n  formatDate: function(date, options) {\n    if (!options) {\n      options = {\n        \"format\": \"YYYY-MM-DD\"\n      };\n    }\n    return InstanceformTemplate.helpers.formatDate(date, options);\n  },\n  isMyApprove: function(approve, only_cc_opinion) {\n    var currentApprove, ins;\n    if (Meteor.isClient) {\n      if (Session.get(\"box\") !== 'inbox') {\n        return false;\n      }\n      ins = WorkflowManager.getInstance();\n      currentApprove = InstanceManager.getCurrentApprove();\n      if (!(approve != null ? approve._id : void 0)) {\n        approve = currentApprove;\n      }\n      if (approve._id === (currentApprove != null ? currentApprove._id : void 0) && (currentApprove != null ? currentApprove.type : void 0) === 'cc' && Template.instance().data.name) {\n        if (_.indexOf(currentApprove != null ? currentApprove.opinion_fields_code : void 0, Template.instance().data.name) > -1) {\n          return true;\n        } else {\n          return false;\n        }\n      }\n      if (!((currentApprove != null ? currentApprove.type : void 0) === 'cc') && only_cc_opinion) {\n        return false;\n      }\n      if (currentApprove && approve._id === currentApprove._id) {\n        return true;\n      }\n    }\n    return false;\n  },\n  myApproveDescription: function(approveId) {\n    var myApprove, ref, ref1, ref2, ref3;\n    if (Meteor.isClient) {\n      if (Session.get(\"box\") === 'inbox') {\n        myApprove = (ref = Template.instance()) != null ? (ref1 = ref.myApprove) != null ? ref1.get() : void 0 : void 0;\n        if (myApprove && myApprove.id === approveId) {\n          if (!myApprove.sign_field_code || myApprove.sign_field_code === ((ref2 = Template.instance()) != null ? (ref3 = ref2.data) != null ? ref3.name : void 0 : void 0)) {\n            if (!Session.get(\"instance_my_approve_description\")) {\n              return (myApprove != null ? myApprove.description : void 0) || \"\";\n            }\n            return Session.get(\"instance_my_approve_description\");\n          }\n        }\n      }\n    }\n  },\n  now: function() {\n    return new Date();\n  },\n  isReadOnly: function() {\n    if (Meteor.isClient) {\n      return ApproveManager.isReadOnly();\n    }\n    return false;\n  },\n  isOpinionOfField: function(approve) {\n    if (approve.type === \"cc\" && Template.instance().data.name) {\n      if (Template.instance().data.name === approve.sign_field_code) {\n        return true;\n      } else {\n        return false;\n      }\n    } else {\n      return true;\n    }\n  },\n  markDownToHtml: function(markDownString) {\n    if (markDownString) {\n      if (Meteor.isServer) {\n        marked = Npm.require('marked');\n      }\n      return Spacebars.SafeString(marked.parse(markDownString));\n    }\n  },\n  steps: function(field_formula, step, only_cc_opinion, image_sign) {\n    var ref, ref1, ref2, steps;\n    steps = [];\n    if (!step) {\n      if (!field_formula) {\n        field_formula = (ref = WorkflowManager.getInstanceFormVersion()) != null ? (ref1 = ref.fields) != null ? ref1.findPropertyByPK(\"code\", this.name).formula : void 0 : void 0;\n      }\n      steps = InstanceformTemplate.helpers.getOpinionFieldStepsName(field_formula, (ref2 = Template.instance()) != null ? ref2.data.top_keywords : void 0);\n    } else {\n      steps = [\n        {\n          stepName: step,\n          only_cc_opinion: only_cc_opinion,\n          image_sign: image_sign\n        }\n      ];\n    }\n    return steps;\n  },\n  imageSignData: function(handler) {\n    return {\n      user: handler\n    };\n  },\n  showSignImage: function(handler, image_sign, judge) {\n    var spaceUserSign;\n    if (['returned', 'terminated', 'retrieved'].includes(judge)) {\n      return false;\n    }\n    spaceUserSign = ImageSign.helpers.spaceUserSign(handler);\n    if ((spaceUserSign != null ? spaceUserSign.sign : void 0) && image_sign) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  getLastSignApprove: function() {\n    var ins;\n    ins = WorkflowManager.getInstance();\n    return _.last(TracesManager.getHandlerSignShowApproves(ins, Meteor.userId()));\n  },\n  lastMyApproveDescription: function() {\n    var approves, currentStep, ref, traces;\n    traces = InstanceformTemplate.helpers.traces();\n    currentStep = InstanceManager.getCurrentStep();\n    approves = _.clone(traces[currentStep.name]);\n    approves = approves.filterProperty(\"handler\", Meteor.userId());\n    if (approves.length > 1) {\n      return (ref = approves[approves.length - 2]) != null ? ref.description : void 0;\n    }\n    return \"\";\n  },\n  showApprove: function(approve) {\n    var ref, ref1;\n    if (!approve.sign_field_code || approve.sign_field_code === ((ref = Template.instance()) != null ? (ref1 = ref.data) != null ? ref1.name : void 0 : void 0)) {\n      if (approve != null ? approve.is_read : void 0) {\n        if (approve.is_finished) {\n          return [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(approve.judge);\n        }\n      }\n    }\n    return false;\n  },\n  judge_description: function(judge) {\n    return t(judge + \"_description\");\n  },\n  is_approved: function(judge) {\n    return \"approved\" === judge;\n  },\n  is_rejected: function(judge) {\n    return \"rejected\" === judge;\n  },\n  is_readed: function(judge) {\n    return [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(judge);\n  },\n  addClass: function() {\n    var name, ref, ref1;\n    name = (ref = Template.instance()) != null ? (ref1 = ref.data) != null ? ref1.name : void 0 : void 0;\n    setTimeout(function() {\n      var e, element;\n      try {\n        element = $(\".automatic.opinion-field-\" + name);\n        if (element.length > 0) {\n          if (element != null ? element.is(\"td\") : void 0) {\n            return element.addClass('field-editable');\n          } else {\n            return $(\".instance-sign\", element).addClass('field-editable');\n          }\n        }\n      } catch (error) {\n        e = error;\n        return console.log(e);\n      }\n    }, 1);\n    return '';\n  }\n};\n\nif (Meteor.isServer) {\n  InstanceSignText.helpers.defaultDescription = function() {\n    var locale;\n    locale = Template.instance().view.template.steedosData.locale;\n    return Template.instance().data.default_description || TAPi18n.__(\"instance_default_opinion\", {}, locale);\n  };\n}\n","marked = require(\"marked\")\nTracesTemplate.helpers =\n\ttraceShowSignImage: ()->\n\t\treturn Meteor.settings.public.workflow.traceShowSignImage != false && Meteor.settings.public.workflow.traceShowSignImage != 'false'\n\tequals: (a, b) ->\n\t\ta == b\n\tempty: (a) ->\n\t\tif a\n\t\t\ta.toString().trim().length < 1\n\t\telse\n\t\t\ttrue\n\tunempty: (a) ->\n\t\tif a\n\t\t\ta.toString().trim().length > 0\n\t\telse\n\t\t\tfalse\n\n\tappend: (a, b) ->\n\t\ta + b\n\n\tdateFormat: (date) ->\n\t\t\tif Steedos.isMobile() && date?.getFullYear() == (new Date).getFullYear()\n\t\t\t\treturn moment(date).format('MM-DD HH:mm');\n\t\t\telse\n\t\t\t\treturn moment(date).format('YYYY-MM-DD HH:mm');\n\n\tgetStepName: (stepId) ->\n\t\tstep = WorkflowManager.getInstanceStep(stepId)\n\t\tif step\n\t\t\treturn step.name\n\t\tnull\n\tshowDeleteButton: (approved) ->\n\t\tif approved and approved.type == 'cc' and approved.from_user == Meteor.userId() and approved.is_finished != true and !Session.get(\"instancePrint\")\n\t\t\treturn true\n\t\tfalse\n\tisShowModificationButton: (approved) ->\n\t\tapprove_admins = Meteor.settings?.public?.workflow?.approve_admins\n\t\tif approve_admins?.length\n\t\t\tisShow = approve_admins?.contains Meteor.userId()\n\t\tunless isShow\n\t\t\treturn false\n\t\treturn approved.handler == Meteor.userId()\n\tisEditing: () ->\n\t\t return Template.instance().is_editing?.get()\n\tisShowDescription: (approved)->\n\t\t# debugger\n\t\tif TracesTemplate.helpers.isShowModificationButton approved\n\t\t\treturn true\n\t\treturn approved.description?.toString().trim().length > 0\n\tisCC: (approved) ->\n\t\tif approved and approved.type == 'cc'\n\t\t\treturn true\n\t\tfalse\n\tgetApproveStatusIcon: (approveJudge, autoSubmitted) ->\n\t\tif autoSubmitted == true\n\t\t\treturn 'ion ion-android-alarm-clock'\n\t\t#已结束的显示为核准/驳回/取消申请，并显示处理状态图标\n\t\tapproveStatusIcon = undefined\n\t\tswitch approveJudge\n\t\t\twhen 'approved'\n\t\t\t\t# 已核准\n\t\t\t\tapproveStatusIcon = 'ion ion-checkmark-round'\n\t\t\twhen 'rejected'\n\t\t\t\t# 已驳回\n\t\t\t\tapproveStatusIcon = 'ion ion-close-round'\n\t\t\twhen 'terminated'\n\t\t\t\t# 已取消\n\t\t\t\tapproveStatusIcon = 'fa fa-ban'\n\t\t\twhen 'reassigned'\n\t\t\t\t# 转签核\n\t\t\t\tapproveStatusIcon = 'ion ion-android-contact'\n\t\t\twhen 'relocated'\n\t\t\t\t# 重定位\n\t\t\t\tapproveStatusIcon = 'ion ion-arrow-shrink'\n\t\t\twhen 'retrieved'\n\t\t\t\t# 已取回\n\t\t\t\tapproveStatusIcon = 'fa fa-undo'\n\t\t\telse\n\t\t\t\tapproveStatusIcon = ''\n\t\t\t\tbreak\n\t\tapproveStatusIcon\n\tgetApproveStatusText: (approveJudge, autoSubmitted) ->\n\t\tif Meteor.isServer\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\t\t#已结束的显示为核准/驳回/取消申请，并显示处理状态图标\n\t\tif autoSubmitted == true\n\t\t\treturn TAPi18n.__('instance_approve_timeout_auto_submitted', {}, locale)\n\t\tapproveStatusText = undefined\n\t\tswitch approveJudge\n\t\t\twhen 'approved'\n\t\t\t\t# 已核准\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State approved', {}, locale)\n\t\t\twhen 'rejected'\n\t\t\t\t# 已驳回\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State rejected', {}, locale)\n\t\t\twhen 'terminated'\n\t\t\t\t# 已取消\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State terminated', {}, locale)\n\t\t\twhen 'reassigned'\n\t\t\t\t# 转签核\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State reassigned', {}, locale)\n\t\t\twhen 'relocated'\n\t\t\t\t# 重定位\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State relocated', {}, locale)\n\t\t\twhen 'retrieved'\n\t\t\t\t# 已取回\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State retrieved', {}, locale)\n\t\t\twhen 'returned'\n\t\t\t\t# 已退回\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State returned', {}, locale)\n\t\t\twhen 'readed'\n\t\t\t\t# 已阅\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State readed', {}, locale)\n\t\t\telse\n\t\t\t\tapproveStatusText = ''\n\t\t\t\tbreak\n\t\tapproveStatusText\n\t\n\tgetApproveJudgeClass: (approveJudge, autoSubmitted) ->\n\t\tif autoSubmitted == true\n\t\t\treturn 'autoSubmitted'\n\t\treturn approveJudge\n\n\t_t: (key)->\n\t\treturn TAPi18n.__(key)\n\n\tmyApproveDescription: (approveId)->\n\t\tif Meteor.isClient\n\t\t\tif Session.get(\"box\") == 'inbox'\n\t\t\t\tmyApprove = Template.instance()?.myApprove?.get()\n\t\t\t\tif myApprove && myApprove.id == approveId\n\t\t\t\t\tif !Session.get(\"instance_my_approve_description\")\n\t\t\t\t\t\treturn myApprove?.description || \"\"\n\t\t\t\t\treturn Session.get(\"instance_my_approve_description\")\n\tisForward: (approved) ->\n\t\tif approved and approved.type == 'forward'\n\t\t\treturn true\n\t\tfalse\n\tshowForwardDeleteButton: (approve) ->\n\t\tif db.instances.find(approve.forward_instance).count() is 0\n\t\t\treturn false\n\t\tif approve and approve.type == 'forward' and approve.from_user == Meteor.userId() and !Session.get(\"instancePrint\") and approve.judge isnt 'terminated'\n\t\t\treturn true\n\t\tfalse\n\tmarkDownToHtml: (markDownString)->\n\t\tif markDownString\n\t\t\t# renderer = new Markdown.Renderer();\n\t\t\t# renderer.link = ( href, title, text ) ->\n\t\t\t# \treturn \"<a target='_blank' href='#{href}' title='#{title}'>#{text}</a>\"\n\t\t\tif Meteor.isServer\n\t\t\t\tmarked = Npm.require('marked')\n\t\t\treturn Spacebars.SafeString(marked.parse(markDownString))\n\tisDistribute: (approve) ->\n\t\tif approve and approve.type == 'distribute'\n\t\t\treturn true\n\t\tfalse\n\tshowDistributeDeleteButton: (approve) ->\n\t\tif db.instances.find(approve.forward_instance).count() is 0\n\t\t\treturn false\n\n\t\tif approve and approve.type == 'distribute' and !Session.get(\"instancePrint\") and approve.judge isnt 'terminated'\n\t\t\t# 流程管理员和系统管理员，可以执行任何情况下的文件取消分发\n\t\t\tins = db.instances.findOne({_id: approve.instance}, {fields: {flow: 1, space: 1}})\n\t\t\tif ins and ins.flow and ins.space\n\t\t\t\tif WorkflowManager.hasFlowAdminPermission(ins.flow, ins.space, Meteor.userId())\n\t\t\t\t\treturn true\n\n\t\t\tif approve.from_user == Meteor.userId()\n\t\t\t\treturn true\n\n\t\tfalse\n\n\tfinishDateSchema: () ->\n\t\tif Steedos.isAndroidOrIOS()\n\t\t\treturn new SimpleSchema({\n\t\t\t\tfinish_date: {\n\t\t\t\t\tautoform: {\n\t\t\t\t\t\ttype: \"datetime-local\"\n\t\t\t\t\t},\n\t\t\t\t\toptional: false,\n\t\t\t\t\ttype: Date\n\t\t\t\t}\n\t\t\t})\n\t\telse\n\t\t\treturn new SimpleSchema({\n\t\t\t\tfinish_date: {\n\t\t\t\t\tautoform: {\n\t\t\t\t\t\ttype: \"bootstrap-datetimepicker\"\n\t\t\t\t\t\treadonly: true\n\t\t\t\t\t\tdateTimePickerOptions:{\n\t\t\t\t\t\t\tformat: \"YYYY-MM-DD HH:mm\",\n\t\t\t\t\t\t\tignoreReadonly:true,\n\t\t\t\t\t\t\tlocale: Session.get(\"TAPi18n::loaded_lang\"),\n\t\t\t\t\t\t\twidgetPositioning:{\n\t\t\t\t\t\t\t\thorizontal: 'right'\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\toptional: false,\n\t\t\t\t\ttype: Date\n\t\t\t\t}\n\t\t\t})\n\n\tfinishDateValues: () ->\n\t\treturn {\n\t\t\tfinish_date:this.finish_date\n\t\t};\n\n\t###\n    \t此函数用于控制是否显示traces view\n    \ttrue: 显示traces view,签核历程按钮点击后是直接定位到traces view\n    \tfalse: 不显示traces view，签核历程按钮点击后,以Modal 方式显示traces view\n\t###\n\tshowTracesView: (form, form_version)->\n#\t\treturn !(InstanceManager.isTableStyle(form) && InstanceformTemplate.helpers.includesOpinionField(form, form_version))\n\n\t\tshow_modal_traces_list = db.space_settings.findOne({space: Session.get(\"spaceId\"), key: \"show_modal_traces_list\"})?.values || false\n\n\t\treturn !show_modal_traces_list\n\n\tgetInstanceStateText: (instance_id)->\n\t\tif Meteor.isServer\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\n\t\tins = db.instances.findOne({_id: instance_id}, {fields: {state: 1, is_read: 1}})\n\t\tif not ins\n\t\t\treturn TAPi18n.__('instance_deleted', {}, locale)\n\n\t\ttext = ''\n\t\tif ins.state is 'completed'\n\t\t\ttext = TAPi18n.__('completed', {}, locale)\n\t\telse if ins.state is 'pending'\n\t\t\ttext = TAPi18n.__('pending', {}, locale)\n\t\telse if ins.state is 'draft'\n\t\t\tif ins.is_read\n\t\t\t\ttext = TAPi18n.__('instance_approve_read', {}, locale)\n\t\t\telse\n\t\t\t\ttext = TAPi18n.__('instance_approve_not_yet_handled', {}, locale)\n\n\t\treturn text\n\n\tgetInstanceStateColor: (instance_id)->\n\t\tins = db.instances.findOne({_id: instance_id}, {fields: {state: 1, is_read: 1}})\n\t\tif not ins\n\t\t\treturn \"\"\n\n\t\tcla = ''\n\t\tif ins.state is 'draft'\n\t\t\tif ins.is_read\n\t\t\t\tcla = 'blue'\n\t\t\telse\n\t\t\t\tcla = 'red'\n\t\treturn cla\n\n\tfirstTrace: (index)->\n\t\treturn index is 0\n\n\tlast_distribute_from: (instance_id)->\n\t\tins = db.instances.findOne({_id: instance_id, distribute_from_instance: {$exists: true}},{fields:{created: 1, created_by: 1}})\n\t\tif ins\n\t\t\tdis_info = {}\n\t\t\tuser = {}\n\t\t\tif Meteor.isClient\n\t\t\t\tuser = UUflow_api.getNameForUser(ins.created_by)\n\t\t\telse if Meteor.isServer\n\t\t\t\tuser = db.users.findOne({_id: ins.created_by}, {fields: {name: 1}})\n\n\t\t\tif user.name\n\t\t\t\tdis_info.from_user = user._id\n\t\t\t\tdis_info.from_user_name = user.name\n\t\t\t\tdis_info.created = ins.created\n\n\t\t\tif not _.isEmpty(dis_info)\n\t\t\t\treturn dis_info\n\t\treturn\n\n\tisCCOrDistributeOrForwardTerminated: (approve)->\n\t\tif (approve.type is 'cc' or approve.type is 'distribute' or approve.type is 'forward') and approve.judge is 'terminated'\n\t\t\treturn true\n\t\treturn false\n\n\tjudgeTerminated: (judge)->\n\t\treturn judge is 'terminated'\n\n\tinstanceExists: (instance_id)->\n\t\treturn !!db.instances.find(instance_id).count()\n\n\tagentDescription: (userName)->\n\t\tif Meteor.isServer\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\n\t\treturn TAPi18n.__('process_delegation_rules_description', {userName: userName}, locale)\n\t\n\ttraceName: (instance_id, traceId)->\n\t\treturn _.find(db.instances.findOne(instance_id, {fields: {traces: 1}})?.traces, (trace)->\n\t\t\t\t\treturn trace._id ==  traceId\n\t\t)?.name\n\n\tobjectUrl: (object_name, record_id, app_id)->\n\t\treturn Creator.getObjectUrl(object_name, record_id, app_id)\n\n\thandlerDoc: (handlerId)->\n\t\tusers_can_read_cc_handler_detail_info = Meteor.settings.public?.workflow?.users_can_read_cc_handler_detail_info\n\t\tif !users_can_read_cc_handler_detail_info or !users_can_read_cc_handler_detail_info.includes(Meteor.userId())\n\t\t\treturn\n\t\tif Meteor.isClient\n\t\t\treturn UUflow_api.getContactInfoForUser(handlerId, Session.get('spaceId'))\n\t\telse if Meteor.isServer\n\t\t\treturn db.users.findOne(handlerId)\n\nif Meteor.isServer\n\tTracesTemplate.helpers.dateFormat = (date)->\n\t\tif date\n\t\t\tutcOffset = Template.instance().view.template.steedosData.utcOffset\n\t\t\treturn InstanceReadOnlyTemplate.formatDate(date, utcOffset);\n\n\tTracesTemplate.helpers._t = (key)->\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\treturn TAPi18n.__(key, {}, locale)\n\n\tTracesTemplate.helpers.showDeleteButton = (approved) ->\n\t\treturn false;\n\nTracesTemplate.events =\n\t'click .cc-approve-remove': (event, template) ->\n\t\tevent.stopPropagation()\n\t\tif event.currentTarget.dataset.calling * 1 != 1\n\t\t\tevent.currentTarget.dataset.calling = 1\n\t\t\t$(\"i\",event.currentTarget).addClass(\"fa-spin\")\n\t\t\tinstanceId = Session.get('instanceId')\n\t\t\tapproveId = event.target.dataset.approve\n\t\t\t# CALL 删除approve函数。\n\t\t\t$(\"body\").addClass(\"loading\")\n\t\t\tMeteor.call 'cc_remove', instanceId, approveId, (err, result) ->\n\t\t\t\t$(\"body\").removeClass(\"loading\")\n\t\t\t\tif err\n\t\t\t\t\ttoastr.error err\n\t\t\t\t\tevent.currentTarget.dataset.calling = 0\n\t\t\t\t\t$(\"i\",event.currentTarget).removeClass(\"fa-spin\")\n\t\t\t\tif result == true\n\t\t\t\t\ttoastr.success(TAPi18n.__(\"remove_cc_approve\"));\n\t\t\t\t\tif $(\".instance-trace-detail-modal\").length\n\t\t\t\t\t\tModal.hide \"instance_trace_detail_modal\"\n\t\t\t\treturn\n\t\t\treturn\n\n\t'click .instance-trace-detail-modal .btn-cc-approve-remove': (event, template) ->\n\t\tinstanceId = Session.get('instanceId')\n\t\tapproveId = event.target.dataset.approve\n\t\t# # CALL 删除approve函数。\n\t\t# $(\"body\").addClass(\"loading\")\n\t\t# Meteor.call 'cc_remove', instanceId, approveId, (err, result) ->\n\t\t# \t$(\"body\").removeClass(\"loading\")\n\t\t# \tif err\n\t\t# \t\ttoastr.error err\n\t\t# \tif result == true\n\t\t# \t\ttoastr.success(TAPi18n.__(\"remove_cc_approve\"));\n\t\t# \t\tModal.hide \"instance_trace_detail_modal\"\n\t\t# \treturn\n\t\t# return\n\t\tModal.allowMultiple = true\n\t\tModal.show 'cancel_cc_modal'\n\n\t'click .approve-item,.approve-description': (event, template) ->\n\t\t# PC上链接允许直接点开，不再打开签批历程详细\n\t\tunless $(event.target).closest(\"a.btn-link\").length\n\t\t\tModal.show \"instance_trace_detail_modal\", this\n\n\t'taphold .approve-item,.approve-description': (event, template) ->\n\t\t# 手机上长按打开签批历程详细，如果是链接长按打开后一放手窗口就又关掉了，所以不让链接打开签批历程详细\n\t\tunless $(event.target).closest(\"a.btn-link\").length\n\t\t\tModal.show \"instance_trace_detail_modal\", this\n\n\t'click .approve-item a.btn-link,.approve-description a.btn-link,.approve-item-distribute a.btn-link': (event, template) ->\n\t\t# 手机上点击链接，弹出新窗口，不支持，因为android上会弹出登录界面\n\t\tif Steedos.isMobile()\n\t\t\tuserId = event.target.dataset?.target_user_id\n\t\t\tCreator.openSafeObjectUrl('users', userId)\n\n\t'tapend .approve-item,.approve-description': (event, template) ->\n\t\t# 上述长按打开approve详细窗口的事件taphold会触发打开窗口后的touchend事件，造成长按打开窗口后一放手窗口就又关掉了\n\t\t# 这里只能通过阻止tapend事件(不可以用touchend事件，因为会影响taphold功能，造成没有长按效果时也会触发taphold事件)冒泡来避免问题。\n\t\t# 链接允许直接点开\n\t\tunless $(event.target).closest(\"a.btn-link\").length\n\t\t\tevent.stopPropagation()\n\t\t\tevent.preventDefault()\n\t\t\treturn false\n\n\t'click .instance-trace-detail-modal .btn-forward-approve-remove': (event, template) ->\n\t\tinstanceId = Session.get('instanceId')\n\t\tapproveId = event.target.dataset.approve\n\t\ttraceId = event.target.dataset.trace\n\t\t# CALL 删除approve函数。\n\t\t$(\"body\").addClass(\"loading\")\n\t\tMeteor.call 'forward_remove', instanceId, traceId, approveId, (err, result) ->\n\t\t\t$(\"body\").removeClass(\"loading\")\n\t\t\tif err\n\t\t\t\ttoastr.error TAPi18n.__(err.reason)\n\t\t\tif result == true\n\t\t\t\ttoastr.success(TAPi18n.__(\"instance_approve_forward_remove_success\"));\n\t\t\t\tModal.hide \"instance_trace_detail_modal\"\n\t\t\treturn\n\t\treturn\n\n\t'click .instance-trace-detail-modal .btn-forward-instance-look': (event, template) ->\n\t\tforward_space = event.target.dataset.forwardspace\n\t\tforward_instance = event.target.dataset.forwardinstance\n\t\tSteedos.openWindow(Steedos.absoluteUrl(\"workflow/space/\" + forward_space + \"/view/readonly/\" + forward_instance))\n\n\t'click .btn-modification'\t: (event, template) ->\n\t\ttemplate.is_editing.set(!template.is_editing.get());\n\t\tunless Steedos.isAndroidOrIOS()\n\t\t\tTracker.afterFlush ->\n\t\t\t\t# 显示日志的时候把滚动条往下移点，让日期控件显示出一部分，以避免用户看不到日期控件\n\t\t\t\t$(\"#instance_trace_detail_modal #finish_input\").on \"dp.show\", () ->\n\t\t\t\t\t$(\".modal-body\").scrollTop(100)\n\n\t'click .btn-cancelBut' : (event, template) ->\n\n\t\ttemplate.is_editing.set(!template.is_editing.get());\n\n\t'click .btn-saveBut' : (event, template) ->\n\t\t# template.is_editing.set(!template.is_editing.get())\n\n\t\tinstanceId = Session.get('instanceId')\n\t\tapproveId = event.target.dataset.approve\n\t\ttraceId = event.target.dataset.trace\n\t\topinion_input = $('#opinion_input').val()\n\t\tfinish_input = AutoForm.getFieldValue(\"finish_date\", \"finishDateAutoForm\")\n\n\t\t$(\"body\").addClass(\"loading\")\n\t\tMeteor.call 'change_approve_info', instanceId, traceId, approveId, opinion_input, finish_input, (err, result)->\n\t\t\t$(\"body\").removeClass(\"loading\")\n\t\t\tif err\n\t\t\t\ttoastr.error TAPi18n.__(err.reason)\n\t\t\tif result == true\n\t\t\t\ttoastr.success(t(\"instance_approve_modal_modificationsave\"))\n\t\t\t\tModal.hide \"instance_trace_detail_modal\"\n\t\t\treturn\n\n\t'click .instance-trace-detail-modal .btn-distribute-approve-remove': (event, template) ->\n\t\tModal.allowMultiple = true\n\t\tModal.show 'cancel_distribute_modal'\n","var marked;\n\nmarked = require(\"marked\");\n\nTracesTemplate.helpers = {\n  traceShowSignImage: function() {\n    return Meteor.settings[\"public\"].workflow.traceShowSignImage !== false && Meteor.settings[\"public\"].workflow.traceShowSignImage !== 'false';\n  },\n  equals: function(a, b) {\n    return a === b;\n  },\n  empty: function(a) {\n    if (a) {\n      return a.toString().trim().length < 1;\n    } else {\n      return true;\n    }\n  },\n  unempty: function(a) {\n    if (a) {\n      return a.toString().trim().length > 0;\n    } else {\n      return false;\n    }\n  },\n  append: function(a, b) {\n    return a + b;\n  },\n  dateFormat: function(date) {\n    if (Steedos.isMobile() && (date != null ? date.getFullYear() : void 0) === (new Date).getFullYear()) {\n      return moment(date).format('MM-DD HH:mm');\n    } else {\n      return moment(date).format('YYYY-MM-DD HH:mm');\n    }\n  },\n  getStepName: function(stepId) {\n    var step;\n    step = WorkflowManager.getInstanceStep(stepId);\n    if (step) {\n      return step.name;\n    }\n    return null;\n  },\n  showDeleteButton: function(approved) {\n    if (approved && approved.type === 'cc' && approved.from_user === Meteor.userId() && approved.is_finished !== true && !Session.get(\"instancePrint\")) {\n      return true;\n    }\n    return false;\n  },\n  isShowModificationButton: function(approved) {\n    var approve_admins, isShow, ref, ref1, ref2;\n    approve_admins = (ref = Meteor.settings) != null ? (ref1 = ref[\"public\"]) != null ? (ref2 = ref1.workflow) != null ? ref2.approve_admins : void 0 : void 0 : void 0;\n    if (approve_admins != null ? approve_admins.length : void 0) {\n      isShow = approve_admins != null ? approve_admins.contains(Meteor.userId()) : void 0;\n    }\n    if (!isShow) {\n      return false;\n    }\n    return approved.handler === Meteor.userId();\n  },\n  isEditing: function() {\n    var ref;\n    return (ref = Template.instance().is_editing) != null ? ref.get() : void 0;\n  },\n  isShowDescription: function(approved) {\n    var ref;\n    if (TracesTemplate.helpers.isShowModificationButton(approved)) {\n      return true;\n    }\n    return ((ref = approved.description) != null ? ref.toString().trim().length : void 0) > 0;\n  },\n  isCC: function(approved) {\n    if (approved && approved.type === 'cc') {\n      return true;\n    }\n    return false;\n  },\n  getApproveStatusIcon: function(approveJudge, autoSubmitted) {\n    var approveStatusIcon;\n    if (autoSubmitted === true) {\n      return 'ion ion-android-alarm-clock';\n    }\n    approveStatusIcon = void 0;\n    switch (approveJudge) {\n      case 'approved':\n        approveStatusIcon = 'ion ion-checkmark-round';\n        break;\n      case 'rejected':\n        approveStatusIcon = 'ion ion-close-round';\n        break;\n      case 'terminated':\n        approveStatusIcon = 'fa fa-ban';\n        break;\n      case 'reassigned':\n        approveStatusIcon = 'ion ion-android-contact';\n        break;\n      case 'relocated':\n        approveStatusIcon = 'ion ion-arrow-shrink';\n        break;\n      case 'retrieved':\n        approveStatusIcon = 'fa fa-undo';\n        break;\n      default:\n        approveStatusIcon = '';\n        break;\n    }\n    return approveStatusIcon;\n  },\n  getApproveStatusText: function(approveJudge, autoSubmitted) {\n    var approveStatusText, locale;\n    if (Meteor.isServer) {\n      locale = Template.instance().view.template.steedosData.locale;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    if (autoSubmitted === true) {\n      return TAPi18n.__('instance_approve_timeout_auto_submitted', {}, locale);\n    }\n    approveStatusText = void 0;\n    switch (approveJudge) {\n      case 'approved':\n        approveStatusText = TAPi18n.__('Instance State approved', {}, locale);\n        break;\n      case 'rejected':\n        approveStatusText = TAPi18n.__('Instance State rejected', {}, locale);\n        break;\n      case 'terminated':\n        approveStatusText = TAPi18n.__('Instance State terminated', {}, locale);\n        break;\n      case 'reassigned':\n        approveStatusText = TAPi18n.__('Instance State reassigned', {}, locale);\n        break;\n      case 'relocated':\n        approveStatusText = TAPi18n.__('Instance State relocated', {}, locale);\n        break;\n      case 'retrieved':\n        approveStatusText = TAPi18n.__('Instance State retrieved', {}, locale);\n        break;\n      case 'returned':\n        approveStatusText = TAPi18n.__('Instance State returned', {}, locale);\n        break;\n      case 'readed':\n        approveStatusText = TAPi18n.__('Instance State readed', {}, locale);\n        break;\n      default:\n        approveStatusText = '';\n        break;\n    }\n    return approveStatusText;\n  },\n  getApproveJudgeClass: function(approveJudge, autoSubmitted) {\n    if (autoSubmitted === true) {\n      return 'autoSubmitted';\n    }\n    return approveJudge;\n  },\n  _t: function(key) {\n    return TAPi18n.__(key);\n  },\n  myApproveDescription: function(approveId) {\n    var myApprove, ref, ref1;\n    if (Meteor.isClient) {\n      if (Session.get(\"box\") === 'inbox') {\n        myApprove = (ref = Template.instance()) != null ? (ref1 = ref.myApprove) != null ? ref1.get() : void 0 : void 0;\n        if (myApprove && myApprove.id === approveId) {\n          if (!Session.get(\"instance_my_approve_description\")) {\n            return (myApprove != null ? myApprove.description : void 0) || \"\";\n          }\n          return Session.get(\"instance_my_approve_description\");\n        }\n      }\n    }\n  },\n  isForward: function(approved) {\n    if (approved && approved.type === 'forward') {\n      return true;\n    }\n    return false;\n  },\n  showForwardDeleteButton: function(approve) {\n    if (db.instances.find(approve.forward_instance).count() === 0) {\n      return false;\n    }\n    if (approve && approve.type === 'forward' && approve.from_user === Meteor.userId() && !Session.get(\"instancePrint\") && approve.judge !== 'terminated') {\n      return true;\n    }\n    return false;\n  },\n  markDownToHtml: function(markDownString) {\n    if (markDownString) {\n      if (Meteor.isServer) {\n        marked = Npm.require('marked');\n      }\n      return Spacebars.SafeString(marked.parse(markDownString));\n    }\n  },\n  isDistribute: function(approve) {\n    if (approve && approve.type === 'distribute') {\n      return true;\n    }\n    return false;\n  },\n  showDistributeDeleteButton: function(approve) {\n    var ins;\n    if (db.instances.find(approve.forward_instance).count() === 0) {\n      return false;\n    }\n    if (approve && approve.type === 'distribute' && !Session.get(\"instancePrint\") && approve.judge !== 'terminated') {\n      ins = db.instances.findOne({\n        _id: approve.instance\n      }, {\n        fields: {\n          flow: 1,\n          space: 1\n        }\n      });\n      if (ins && ins.flow && ins.space) {\n        if (WorkflowManager.hasFlowAdminPermission(ins.flow, ins.space, Meteor.userId())) {\n          return true;\n        }\n      }\n      if (approve.from_user === Meteor.userId()) {\n        return true;\n      }\n    }\n    return false;\n  },\n  finishDateSchema: function() {\n    if (Steedos.isAndroidOrIOS()) {\n      return new SimpleSchema({\n        finish_date: {\n          autoform: {\n            type: \"datetime-local\"\n          },\n          optional: false,\n          type: Date\n        }\n      });\n    } else {\n      return new SimpleSchema({\n        finish_date: {\n          autoform: {\n            type: \"bootstrap-datetimepicker\",\n            readonly: true,\n            dateTimePickerOptions: {\n              format: \"YYYY-MM-DD HH:mm\",\n              ignoreReadonly: true,\n              locale: Session.get(\"TAPi18n::loaded_lang\"),\n              widgetPositioning: {\n                horizontal: 'right'\n              }\n            }\n          },\n          optional: false,\n          type: Date\n        }\n      });\n    }\n  },\n  finishDateValues: function() {\n    return {\n      finish_date: this.finish_date\n    };\n  },\n\n  /*\n     \t此函数用于控制是否显示traces view\n     \ttrue: 显示traces view,签核历程按钮点击后是直接定位到traces view\n     \tfalse: 不显示traces view，签核历程按钮点击后,以Modal 方式显示traces view\n   */\n  showTracesView: function(form, form_version) {\n    var ref, show_modal_traces_list;\n    show_modal_traces_list = ((ref = db.space_settings.findOne({\n      space: Session.get(\"spaceId\"),\n      key: \"show_modal_traces_list\"\n    })) != null ? ref.values : void 0) || false;\n    return !show_modal_traces_list;\n  },\n  getInstanceStateText: function(instance_id) {\n    var ins, locale, text;\n    if (Meteor.isServer) {\n      locale = Template.instance().view.template.steedosData.locale;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    ins = db.instances.findOne({\n      _id: instance_id\n    }, {\n      fields: {\n        state: 1,\n        is_read: 1\n      }\n    });\n    if (!ins) {\n      return TAPi18n.__('instance_deleted', {}, locale);\n    }\n    text = '';\n    if (ins.state === 'completed') {\n      text = TAPi18n.__('completed', {}, locale);\n    } else if (ins.state === 'pending') {\n      text = TAPi18n.__('pending', {}, locale);\n    } else if (ins.state === 'draft') {\n      if (ins.is_read) {\n        text = TAPi18n.__('instance_approve_read', {}, locale);\n      } else {\n        text = TAPi18n.__('instance_approve_not_yet_handled', {}, locale);\n      }\n    }\n    return text;\n  },\n  getInstanceStateColor: function(instance_id) {\n    var cla, ins;\n    ins = db.instances.findOne({\n      _id: instance_id\n    }, {\n      fields: {\n        state: 1,\n        is_read: 1\n      }\n    });\n    if (!ins) {\n      return \"\";\n    }\n    cla = '';\n    if (ins.state === 'draft') {\n      if (ins.is_read) {\n        cla = 'blue';\n      } else {\n        cla = 'red';\n      }\n    }\n    return cla;\n  },\n  firstTrace: function(index) {\n    return index === 0;\n  },\n  last_distribute_from: function(instance_id) {\n    var dis_info, ins, user;\n    ins = db.instances.findOne({\n      _id: instance_id,\n      distribute_from_instance: {\n        $exists: true\n      }\n    }, {\n      fields: {\n        created: 1,\n        created_by: 1\n      }\n    });\n    if (ins) {\n      dis_info = {};\n      user = {};\n      if (Meteor.isClient) {\n        user = UUflow_api.getNameForUser(ins.created_by);\n      } else if (Meteor.isServer) {\n        user = db.users.findOne({\n          _id: ins.created_by\n        }, {\n          fields: {\n            name: 1\n          }\n        });\n      }\n      if (user.name) {\n        dis_info.from_user = user._id;\n        dis_info.from_user_name = user.name;\n        dis_info.created = ins.created;\n      }\n      if (!_.isEmpty(dis_info)) {\n        return dis_info;\n      }\n    }\n  },\n  isCCOrDistributeOrForwardTerminated: function(approve) {\n    if ((approve.type === 'cc' || approve.type === 'distribute' || approve.type === 'forward') && approve.judge === 'terminated') {\n      return true;\n    }\n    return false;\n  },\n  judgeTerminated: function(judge) {\n    return judge === 'terminated';\n  },\n  instanceExists: function(instance_id) {\n    return !!db.instances.find(instance_id).count();\n  },\n  agentDescription: function(userName) {\n    var locale;\n    if (Meteor.isServer) {\n      locale = Template.instance().view.template.steedosData.locale;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    return TAPi18n.__('process_delegation_rules_description', {\n      userName: userName\n    }, locale);\n  },\n  traceName: function(instance_id, traceId) {\n    var ref, ref1;\n    return (ref = _.find((ref1 = db.instances.findOne(instance_id, {\n      fields: {\n        traces: 1\n      }\n    })) != null ? ref1.traces : void 0, function(trace) {\n      return trace._id === traceId;\n    })) != null ? ref.name : void 0;\n  },\n  objectUrl: function(object_name, record_id, app_id) {\n    return Creator.getObjectUrl(object_name, record_id, app_id);\n  },\n  handlerDoc: function(handlerId) {\n    var ref, ref1, users_can_read_cc_handler_detail_info;\n    users_can_read_cc_handler_detail_info = (ref = Meteor.settings[\"public\"]) != null ? (ref1 = ref.workflow) != null ? ref1.users_can_read_cc_handler_detail_info : void 0 : void 0;\n    if (!users_can_read_cc_handler_detail_info || !users_can_read_cc_handler_detail_info.includes(Meteor.userId())) {\n      return;\n    }\n    if (Meteor.isClient) {\n      return UUflow_api.getContactInfoForUser(handlerId, Session.get('spaceId'));\n    } else if (Meteor.isServer) {\n      return db.users.findOne(handlerId);\n    }\n  }\n};\n\nif (Meteor.isServer) {\n  TracesTemplate.helpers.dateFormat = function(date) {\n    var utcOffset;\n    if (date) {\n      utcOffset = Template.instance().view.template.steedosData.utcOffset;\n      return InstanceReadOnlyTemplate.formatDate(date, utcOffset);\n    }\n  };\n  TracesTemplate.helpers._t = function(key) {\n    var locale;\n    locale = Template.instance().view.template.steedosData.locale;\n    return TAPi18n.__(key, {}, locale);\n  };\n  TracesTemplate.helpers.showDeleteButton = function(approved) {\n    return false;\n  };\n}\n\nTracesTemplate.events = {\n  'click .cc-approve-remove': function(event, template) {\n    var approveId, instanceId;\n    event.stopPropagation();\n    if (event.currentTarget.dataset.calling * 1 !== 1) {\n      event.currentTarget.dataset.calling = 1;\n      $(\"i\", event.currentTarget).addClass(\"fa-spin\");\n      instanceId = Session.get('instanceId');\n      approveId = event.target.dataset.approve;\n      $(\"body\").addClass(\"loading\");\n      Meteor.call('cc_remove', instanceId, approveId, function(err, result) {\n        $(\"body\").removeClass(\"loading\");\n        if (err) {\n          toastr.error(err);\n          event.currentTarget.dataset.calling = 0;\n          $(\"i\", event.currentTarget).removeClass(\"fa-spin\");\n        }\n        if (result === true) {\n          toastr.success(TAPi18n.__(\"remove_cc_approve\"));\n          if ($(\".instance-trace-detail-modal\").length) {\n            Modal.hide(\"instance_trace_detail_modal\");\n          }\n        }\n      });\n    }\n  },\n  'click .instance-trace-detail-modal .btn-cc-approve-remove': function(event, template) {\n    var approveId, instanceId;\n    instanceId = Session.get('instanceId');\n    approveId = event.target.dataset.approve;\n    Modal.allowMultiple = true;\n    return Modal.show('cancel_cc_modal');\n  },\n  'click .approve-item,.approve-description': function(event, template) {\n    if (!$(event.target).closest(\"a.btn-link\").length) {\n      return Modal.show(\"instance_trace_detail_modal\", this);\n    }\n  },\n  'taphold .approve-item,.approve-description': function(event, template) {\n    if (!$(event.target).closest(\"a.btn-link\").length) {\n      return Modal.show(\"instance_trace_detail_modal\", this);\n    }\n  },\n  'click .approve-item a.btn-link,.approve-description a.btn-link,.approve-item-distribute a.btn-link': function(event, template) {\n    var ref, userId;\n    if (Steedos.isMobile()) {\n      userId = (ref = event.target.dataset) != null ? ref.target_user_id : void 0;\n      return Creator.openSafeObjectUrl('users', userId);\n    }\n  },\n  'tapend .approve-item,.approve-description': function(event, template) {\n    if (!$(event.target).closest(\"a.btn-link\").length) {\n      event.stopPropagation();\n      event.preventDefault();\n      return false;\n    }\n  },\n  'click .instance-trace-detail-modal .btn-forward-approve-remove': function(event, template) {\n    var approveId, instanceId, traceId;\n    instanceId = Session.get('instanceId');\n    approveId = event.target.dataset.approve;\n    traceId = event.target.dataset.trace;\n    $(\"body\").addClass(\"loading\");\n    Meteor.call('forward_remove', instanceId, traceId, approveId, function(err, result) {\n      $(\"body\").removeClass(\"loading\");\n      if (err) {\n        toastr.error(TAPi18n.__(err.reason));\n      }\n      if (result === true) {\n        toastr.success(TAPi18n.__(\"instance_approve_forward_remove_success\"));\n        Modal.hide(\"instance_trace_detail_modal\");\n      }\n    });\n  },\n  'click .instance-trace-detail-modal .btn-forward-instance-look': function(event, template) {\n    var forward_instance, forward_space;\n    forward_space = event.target.dataset.forwardspace;\n    forward_instance = event.target.dataset.forwardinstance;\n    return Steedos.openWindow(Steedos.absoluteUrl(\"workflow/space/\" + forward_space + \"/view/readonly/\" + forward_instance));\n  },\n  'click .btn-modification': function(event, template) {\n    template.is_editing.set(!template.is_editing.get());\n    if (!Steedos.isAndroidOrIOS()) {\n      return Tracker.afterFlush(function() {\n        return $(\"#instance_trace_detail_modal #finish_input\").on(\"dp.show\", function() {\n          return $(\".modal-body\").scrollTop(100);\n        });\n      });\n    }\n  },\n  'click .btn-cancelBut': function(event, template) {\n    return template.is_editing.set(!template.is_editing.get());\n  },\n  'click .btn-saveBut': function(event, template) {\n    var approveId, finish_input, instanceId, opinion_input, traceId;\n    instanceId = Session.get('instanceId');\n    approveId = event.target.dataset.approve;\n    traceId = event.target.dataset.trace;\n    opinion_input = $('#opinion_input').val();\n    finish_input = AutoForm.getFieldValue(\"finish_date\", \"finishDateAutoForm\");\n    $(\"body\").addClass(\"loading\");\n    return Meteor.call('change_approve_info', instanceId, traceId, approveId, opinion_input, finish_input, function(err, result) {\n      $(\"body\").removeClass(\"loading\");\n      if (err) {\n        toastr.error(TAPi18n.__(err.reason));\n      }\n      if (result === true) {\n        toastr.success(t(\"instance_approve_modal_modificationsave\"));\n        Modal.hide(\"instance_trace_detail_modal\");\n      }\n    });\n  },\n  'click .instance-trace-detail-modal .btn-distribute-approve-remove': function(event, template) {\n    Modal.allowMultiple = true;\n    return Modal.show('cancel_distribute_modal');\n  }\n};\n","RelatedInstances.helpers =\n\tshowRelatedInstaces: ->\n\t\tif Meteor.isClient\n\t\t\tins = WorkflowManager.getInstance();\n\t\telse\n\t\t\tins = this.instance\n\t\tif ins?.related_instances && _.isArray(ins?.related_instances)\n\t\t\tif db.instances.find({_id: {$in: ins.related_instances}}, {fields: {space: 1, name: 1}}).count() > 0\n\t\t\t\treturn true\n\t\t\treturn false\n\t\telse\n\t\t\treturn false\n\n\trelated_instaces: ->\n\t\tif Meteor.isClient\n\t\t\tins = WorkflowManager.getInstance();\n\t\telse\n\t\t\tins = this.instance\n\t\tif ins?.related_instances && _.isArray(ins?.related_instances)\n\t\t\treturn db.instances.find({_id: {$in: ins.related_instances}}, {fields: {space: 1, name: 1}}).fetch()\n\n\trelated_instace_url: (ins) ->\n\n\t\tif Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())\n\t\t\treturn ''\n\n\t\tabsolute = false\n\n\t\tif Meteor.isServer\n\t\t\tabsolute = this.absolute\n\t\tif absolute\n\t\t\treturn Meteor.absoluteUrl(\"workflow/space/\"+ins.space+\"/view/readonly/\" + ins._id + '?hide_traces=0')\n\t\telse\n\t\t\treturn Steedos.absoluteUrl(\"workflow/space/\"+ins.space+\"/view/readonly/\" + ins._id + '?hide_traces=0')\n\n\t_t: (key)->\n\t\tif Meteor.isClient\n\t\t\treturn TAPi18n.__(key)\n\t\telse\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\treturn TAPi18n.__(key, {}, locale)\n\n\tshow_delete: ()->\n\t\tif !Meteor.isClient\n\t\t\treturn false\n\t\telse\n\t\t\tif Session.get(\"box\") == \"draft\" || Session.get(\"box\") == 'inbox'\n\t\t\t\tcurrent_step = InstanceManager.getCurrentStep()\n\t\t\t\tif current_step\n\t\t\t\t\tif (current_step.can_edit_main_attach || current_step.can_edit_normal_attach == true || current_step.can_edit_normal_attach == undefined)\n\t\t\t\t\t\treturn true","RelatedInstances.helpers = {\n  showRelatedInstaces: function() {\n    var ins;\n    if (Meteor.isClient) {\n      ins = WorkflowManager.getInstance();\n    } else {\n      ins = this.instance;\n    }\n    if ((ins != null ? ins.related_instances : void 0) && _.isArray(ins != null ? ins.related_instances : void 0)) {\n      if (db.instances.find({\n        _id: {\n          $in: ins.related_instances\n        }\n      }, {\n        fields: {\n          space: 1,\n          name: 1\n        }\n      }).count() > 0) {\n        return true;\n      }\n      return false;\n    } else {\n      return false;\n    }\n  },\n  related_instaces: function() {\n    var ins;\n    if (Meteor.isClient) {\n      ins = WorkflowManager.getInstance();\n    } else {\n      ins = this.instance;\n    }\n    if ((ins != null ? ins.related_instances : void 0) && _.isArray(ins != null ? ins.related_instances : void 0)) {\n      return db.instances.find({\n        _id: {\n          $in: ins.related_instances\n        }\n      }, {\n        fields: {\n          space: 1,\n          name: 1\n        }\n      }).fetch();\n    }\n  },\n  related_instace_url: function(ins) {\n    var absolute;\n    if (Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())) {\n      return '';\n    }\n    absolute = false;\n    if (Meteor.isServer) {\n      absolute = this.absolute;\n    }\n    if (absolute) {\n      return Meteor.absoluteUrl(\"workflow/space/\" + ins.space + \"/view/readonly/\" + ins._id + '?hide_traces=0');\n    } else {\n      return Steedos.absoluteUrl(\"workflow/space/\" + ins.space + \"/view/readonly/\" + ins._id + '?hide_traces=0');\n    }\n  },\n  _t: function(key) {\n    var locale;\n    if (Meteor.isClient) {\n      return TAPi18n.__(key);\n    } else {\n      locale = Template.instance().view.template.steedosData.locale;\n      return TAPi18n.__(key, {}, locale);\n    }\n  },\n  show_delete: function() {\n    var current_step;\n    if (!Meteor.isClient) {\n      return false;\n    } else {\n      if (Session.get(\"box\") === \"draft\" || Session.get(\"box\") === 'inbox') {\n        current_step = InstanceManager.getCurrentStep();\n        if (current_step) {\n          if (current_step.can_edit_main_attach || current_step.can_edit_normal_attach === true || current_step.can_edit_normal_attach === void 0) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n};\n","RelatedRecords.helpers =\n\tshowRelatedRecords: ()->\n\t\tif Meteor.isClient\n\t\t\tins = WorkflowManager.getInstance();\n\t\telse\n\t\t\tins = this.instance\n\t\tif !ins\n\t\t\treturn false\n\t\treturn !_.isEmpty(ins.record_ids)\n\trelatedRecordUrl: ()->\n\t\tif Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())\n\t\t\treturn ''\n\n\t\tabsolute = false\n\t\t\n\t\tif Meteor.isServer\n\t\t\tins = this.instance\n\t\t\tabsolute = this.absolute\n\t\telse\n\t\t\tins = WorkflowManager.getInstance();\n\t\n\t\tobjcetName = ins.record_ids[0].o\n\t\tid = ins.record_ids[0].ids[0]\n\n\t\tif absolute\n\t\t\treturn Meteor.absoluteUrl(\"app/-/#{objcetName}/view/#{id}\")\n\t\telse\n\t\t\treturn Steedos.absoluteUrl(\"app/-/#{objcetName}/view/#{id}\")","RelatedRecords.helpers = {\n  showRelatedRecords: function() {\n    var ins;\n    if (Meteor.isClient) {\n      ins = WorkflowManager.getInstance();\n    } else {\n      ins = this.instance;\n    }\n    if (!ins) {\n      return false;\n    }\n    return !_.isEmpty(ins.record_ids);\n  },\n  relatedRecordUrl: function() {\n    var absolute, id, ins, objcetName;\n    if (Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())) {\n      return '';\n    }\n    absolute = false;\n    if (Meteor.isServer) {\n      ins = this.instance;\n      absolute = this.absolute;\n    } else {\n      ins = WorkflowManager.getInstance();\n    }\n    objcetName = ins.record_ids[0].o;\n    id = ins.record_ids[0].ids[0];\n    if (absolute) {\n      return Meteor.absoluteUrl(\"app/-/\" + objcetName + \"/view/\" + id);\n    } else {\n      return Steedos.absoluteUrl(\"app/-/\" + objcetName + \"/view/\" + id);\n    }\n  }\n};\n","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-24 15:29:22\n * @Description: \n */\n// JsonRoutes.add(\"post\", \"/api/workflow/getSpaceUsers\", function (req, res, next) {\n//   var\n//     userIds = req.body.userIds,\n//     spaceId = req.query.spaceId,\n//     spaceUsers = []\n//   ;\n\n//   if (!userIds || !spaceId) {\n//     JsonRoutes.sendResult(res, {\n//       code: 200,\n//       data: {\n//         'errors': '缺少参数'\n//       }\n//     });\n//   }\n\n//   spaceUsers = WorkflowManager.getUsers(spaceId, userIds);\n\n//   JsonRoutes.sendResult(res, {\n//     code: 200,\n//     data: {\n//       'spaceUsers': spaceUsers\n//     }\n//   });\n// })\n\n\n  \n  ","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-24 15:23:14\n * @Description: \n */\n// JsonRoutes.add(\"post\", \"/api/workflow/getFormulaUserObjects\", function (req, res, next) {\n//   var\n//     userIds = req.body.userIds,\n//     spaceId = req.query.spaceId,\n//     spaceUsers = []\n//   ;\n\n//   if (!userIds || !spaceId) {\n//     JsonRoutes.sendResult(res, {\n//       code: 200,\n//       data: {\n//         'errors': '缺少参数'\n//       }\n//     });\n//   }\n\n//   var users = WorkflowManager.getFormulaUserObject(spaceId, userIds);\n\n//   JsonRoutes.sendResult(res, {\n//     code: 200,\n//     data: {\n//       'spaceUsers': users\n//     }\n//   });\n// })\n\n\n  \n  ","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-24 15:38:54\n * @Description: \n */\n// JsonRoutes.add(\"post\", \"/api/workflow/init_formula_values\", function(req, res, next) {\n// \tvar\n// \t\tfields = req.body.fields,\n// \t\tautoFormDoc = req.body.autoFormDoc,\n// \t\tapprover = req.body.approver,\n// \t\tapplicant = req.body.applicant,\n\n// \t\tspaceId = req.query.spaceId,\n\n// \t\tspaceUsers = [];\n\n// \tif (!fields || !spaceId || !autoFormDoc || !approver || !applicant) {\n// \t\tJsonRoutes.sendResult(res, {\n// \t\t\tcode: 200,\n// \t\t\tdata: {\n// \t\t\t\t'errors': '缺少参数'\n// \t\t\t}\n// \t\t});\n// \t\treturn;\n// \t}\n\n// \tformula_values = Form_formula.init_formula_values(fields, autoFormDoc, approver, applicant, spaceId);\n\n// \tJsonRoutes.sendResult(res, {\n// \t\tcode: 200,\n// \t\tdata: {\n// \t\t\t'formula_values': formula_values\n// \t\t}\n// \t});\n// })\n","// JsonRoutes.add('post', '/api/workflow/forward', function (req, res, next) {\n// \ttry {\n// \t\tvar current_user_info = uuflowManager.check_authorization(req);\n// \t\tvar current_user_id = current_user_info._id;\n\n// \t\tvar hashData = req.body;\n// \t\tvar instance_id = hashData.instance_id;\n// \t\tvar space_id = hashData.space_id;\n// \t\tvar flow_id = hashData.flow_id;\n// \t\tvar hasSaveInstanceToAttachment = hashData.hasSaveInstanceToAttachment;\n// \t\tvar description = hashData.description;\n// \t\tvar isForwardAttachments = hashData.isForwardAttachments;\n// \t\tvar selectedUsers = hashData.selectedUsers;\n// \t\tvar action_type = hashData.action_type;\n// \t\tvar related = hashData.related;\n// \t\tvar from_approve_id = hashData.from_approve_id;\n\n// \t\tcheck(instance_id, String);\n// \t\tcheck(space_id, String);\n// \t\tcheck(flow_id, String);\n// \t\tcheck(hasSaveInstanceToAttachment, Boolean);\n// \t\tcheck(description, String);\n// \t\tcheck(isForwardAttachments, Boolean);\n// \t\tcheck(selectedUsers, Array);\n// \t\tcheck(action_type, Match.OneOf('forward', 'distribute'));\n\n// \t\tif (action_type == \"distribute\")\n// \t\t\tcheck(from_approve_id, String);\n\n// \t\tvar ins = db.instances.findOne(instance_id);\n// \t\tvar old_space_id = ins.space;\n\n// \t\tvar flow = db.flows.findOne(flow_id);\n\n// \t\tvar space = db.spaces.findOne(space_id);\n\n// \t\tif (!ins || !flow || !space) {\n// \t\t\tthrow new Meteor.Error('params error!', 'record not exists!');\n// \t\t}\n\n// \t\tvar forward_users = new Array;\n// \t\tif (_.isEmpty(selectedUsers)) {\n// \t\t\tforward_users = [current_user_id];\n// \t\t} else {\n// \t\t\tforward_users = selectedUsers;\n// \t\t}\n\n// \t\t// 校验分发对象是否有分发流程的提交权限\n// \t\tvar no_permission_user_ids = new Array();\n// \t\t_.each(forward_users, function (uid) {\n// \t\t\tvar permissions = permissionManager.getFlowPermissions(flow_id, uid);\n// \t\t\tif (!permissions.includes(\"add\")) {\n// \t\t\t\t// throw new Meteor.Error('error!', \"该申请人没有提交此申请单的权限。\")\n// \t\t\t\tno_permission_user_ids.push(uid);\n// \t\t\t}\n// \t\t})\n// \t\tif (!_.isEmpty(no_permission_user_ids)) {\n// \t\t\tvar no_permission_users_name = new Array();\n// \t\t\tdb.users.find({\n// \t\t\t\t_id: {\n// \t\t\t\t\t$in: no_permission_user_ids\n// \t\t\t\t}\n// \t\t\t}, {\n// \t\t\t\tfields: {\n// \t\t\t\t\tname: 1\n// \t\t\t\t}\n// \t\t\t}).forEach(function (u) {\n// \t\t\t\tno_permission_users_name.push(u.name);\n// \t\t\t});\n// \t\t\tthrow new Meteor.Error('no_permission', \"该提交人没有提交此申请单的权限。\", no_permission_users_name.join(','))\n// \t\t}\n\n// \t\tvar new_ins_ids = new Array;\n\n// \t\tvar current_trace = null;\n// \t\tif (action_type == \"distribute\") {\n// \t\t\t_.each(ins.traces, function (t) {\n// \t\t\t\tif (!current_trace) {\n// \t\t\t\t\t_.each(t.approves, function (a) {\n// \t\t\t\t\t\tif (!current_trace) {\n// \t\t\t\t\t\t\tif (a._id == from_approve_id)\n// \t\t\t\t\t\t\t\tcurrent_trace = t;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t}\n// \t\t\t})\n// \t\t} else {\n// \t\t\tcurrent_trace = _.last(ins.traces);\n// \t\t}\n// \t\tvar current_trace_id = current_trace._id;\n// \t\tvar forward_approves = [];\n// \t\tvar from_user_name = db.users.findOne(current_user_id, {\n// \t\t\tfields: {\n// \t\t\t\tname: 1\n// \t\t\t}\n// \t\t}).name\n// \t\tvar set_obj = new Object;\n\n// \t\t// 计算values\n// \t\tvar old_values = ins.values,\n// \t\t\tnew_values = {};\n// \t\tvar form = db.forms.findOne(flow.form);\n// \t\tvar fields = form.current.fields || [];\n\n// \t\tvar old_form = db.forms.findOne(ins.form);\n// \t\tvar old_form_version = ins.form_version,\n// \t\t\told_fields = [],\n// \t\t\tcommon_fields = [];\n\n// \t\tvar select_to_input_fields = [];\n\n// \t\tif (old_form.current._id == old_form_version) {\n// \t\t\told_fields = old_form.current.fields;\n// \t\t} else {\n// \t\t\tif (old_form.historys) {\n// \t\t\t\told_form.historys.forEach(function (h) {\n// \t\t\t\t\tif (h._id == old_form_version)\n// \t\t\t\t\t\told_fields = h.fields;\n// \t\t\t\t})\n// \t\t\t}\n// \t\t}\n\n// \t\tfields.forEach(function (field) {\n// \t\t\tvar exists_field = _.find(old_fields, function (f) {\n// \t\t\t\treturn f.type == field.type && f.code == field.code;\n// \t\t\t})\n// \t\t\tif (exists_field)\n// \t\t\t\tcommon_fields.push(field);\n// \t\t\tvar select_input_field = _.find(old_fields, function (f) {\n// \t\t\t\treturn f.type == 'select' && field.type == 'input' && f.code == field.code;\n// \t\t\t})\n// \t\t\tif (select_input_field)\n// \t\t\t\tselect_to_input_fields.push(select_input_field);\n// \t\t})\n\n// \t\tselect_to_input_fields.forEach(function (field) {\n// \t\t\tif (old_values[field.code]) {\n// \t\t\t\tnew_values[field.code] = old_values[field.code];\n// \t\t\t}\n// \t\t})\n\n// \t\tcommon_fields.forEach(function (field) {\n// \t\t\tif (field.type == 'section') {\n// \t\t\t\tif (field.fields) {\n// \t\t\t\t\tfield.fields.forEach(function (f) {\n// \t\t\t\t\t\t// 跨工作区转发不复制选人选组\n// \t\t\t\t\t\tif (['group', 'user'].includes(f.type) && old_space_id != space_id) {\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t\tvar key = f.code;\n// \t\t\t\t\t\tvar old_v = old_values[key];\n// \t\t\t\t\t\tif (old_v) {\n// \t\t\t\t\t\t\tvar fieldOptions = f.options && f.options.split && f.options.split(\"\\n\").map(function(n){\n// \t\t\t\t\t\t\t\tvar itemSplits = n.split(\":\");\n// \t\t\t\t\t\t\t\treturn {\n// \t\t\t\t\t\t\t\t\tlabel: itemSplits[0],\n// \t\t\t\t\t\t\t\t\tvalue: itemSplits[1] || n\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t// 校验 单选，多选，下拉框 字段值是否在新表单对应字段的可选值范围内\n// \t\t\t\t\t\t\tif (f.type == 'select' || f.type == 'radio') {\n// \t\t\t\t\t\t\t\tvar selectedOption = fieldOptions.find(function(item) {\n// \t\t\t\t\t\t\t\t\treturn item.value === old_v;\n// \t\t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t\tif(!selectedOption){\n// \t\t\t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\tif (f.type == 'multiSelect') {\n// \t\t\t\t\t\t\t\tvar old_multiSelected = old_v.split(',');\n// \t\t\t\t\t\t\t\tvar new_multiSelected = _.intersection(fieldOptions.map(function(n){ return n.value; }), old_multiSelected);\n// \t\t\t\t\t\t\t\told_v = new_multiSelected.join(',');\n// \t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\tnew_values[key] = old_v;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t}\n// \t\t\t} else if (field.type == 'table') {\n// \t\t\t\tif (!_.isEmpty(old_values[field.code])) {\n// \t\t\t\t\tnew_values[field.code] = new Array;\n// \t\t\t\t\told_values[field.code].forEach(function (old_table_row_values) {\n// \t\t\t\t\t\tvar new_table_row_values = {};\n\n// \t\t\t\t\t\tif (!_.isEmpty(field.fields)) {\n// \t\t\t\t\t\t\tfield.fields.forEach(function (f) {\n// \t\t\t\t\t\t\t\t// 跨工作区转发不复制选人选组\n// \t\t\t\t\t\t\t\tif (['group', 'user'].includes(f.type) && old_space_id != space_id) {\n// \t\t\t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t\tvar key = f.code;\n// \t\t\t\t\t\t\t\tvar old_v = old_table_row_values[key];\n// \t\t\t\t\t\t\t\tif (old_v) {\n// \t\t\t\t\t\t\t\t\tvar fieldOptions = f.options && f.options.split && f.options.split(\"\\n\").map(function(n){\n// \t\t\t\t\t\t\t\t\t\tvar itemSplits = n.split(\":\");\n// \t\t\t\t\t\t\t\t\t\treturn {\n// \t\t\t\t\t\t\t\t\t\t\tlabel: itemSplits[0],\n// \t\t\t\t\t\t\t\t\t\t\tvalue: itemSplits[1] || n\n// \t\t\t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t\t\t// 校验 单选，多选，下拉框 字段值是否在新表单对应字段的可选值范围内\n// \t\t\t\t\t\t\t\t\tif (f.type == 'select' || f.type == 'radio') {\n// \t\t\t\t\t\t\t\t\t\tvar selectedOption = fieldOptions.find(function(item) {\n// \t\t\t\t\t\t\t\t\t\t\treturn item.value === old_v;\n// \t\t\t\t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t\t\t\tif(!selectedOption){\n// \t\t\t\t\t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\t\t\tif (f.type == 'multiSelect') {\n// \t\t\t\t\t\t\t\t\t\tvar old_multiSelected = old_v.split(',');\n// \t\t\t\t\t\t\t\t\t\tvar new_multiSelected = _.intersection(fieldOptions.map(function(n){ return n.value; }), old_multiSelected);\n// \t\t\t\t\t\t\t\t\t\told_v = new_multiSelected.join(',');\n// \t\t\t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\t\t\tnew_table_row_values[key] = old_v;\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t})\n// \t\t\t\t\t\t}\n\n// \t\t\t\t\t\tif (old_table_row_values._id) {\n// \t\t\t\t\t\t\tnew_table_row_values._id = new Mongo.ObjectID()._str;\n// \t\t\t\t\t\t}\n\n// \t\t\t\t\t\tif (!_.isEmpty(new_table_row_values)) {\n// \t\t\t\t\t\t\tnew_values[field.code].push(new_table_row_values);\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t}\n// \t\t\t} else {\n// \t\t\t\t// 跨工作区转发不复制选人选组\n// \t\t\t\tif (['group', 'user'].includes(field.type) && old_space_id != space_id) {\n// \t\t\t\t\treturn;\n// \t\t\t\t}\n// \t\t\t\tvar key = field.code;\n// \t\t\t\tvar old_v = old_values[key];\n// \t\t\t\tif (old_v) {\n// \t\t\t\t\t// 校验 单选，多选，下拉框 字段值是否在新表单对应字段的可选值范围内\n// \t\t\t\t\tvar fieldOptions = field.options && field.options.split && field.options.split(\"\\n\").map(function(n){\n// \t\t\t\t\t\tvar itemSplits = n.split(\":\");\n// \t\t\t\t\t\treturn {\n// \t\t\t\t\t\t\tlabel: itemSplits[0],\n// \t\t\t\t\t\t\tvalue: itemSplits[1] || n\n// \t\t\t\t\t\t}\n// \t\t\t\t\t});\n// \t\t\t\t\tif (field.type == 'select' || field.type == 'radio') {\n// \t\t\t\t\t\tvar selectedOption = fieldOptions.find(function(item) {\n// \t\t\t\t\t\t\treturn item.value === old_v;\n// \t\t\t\t\t\t});\n// \t\t\t\t\t\tif(!selectedOption){\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t}\n\n// \t\t\t\t\tif (field.type == 'multiSelect') {\n// \t\t\t\t\t\tvar old_multiSelected = old_v.split(',');\n// \t\t\t\t\t\tvar new_multiSelected = _.intersection(fieldOptions.map(function(n){ return n.value; }), old_multiSelected);\n// \t\t\t\t\t\told_v = new_multiSelected.join(',');\n// \t\t\t\t\t}\n\n// \t\t\t\t\tnew_values[key] = old_v;\n// \t\t\t\t}\n// \t\t\t}\n\n// \t\t})\n\n// \t\t//如果是分发，则value中的record_need、FONDSID不需要分发到新申请单中\n// \t\tif (action_type === 'distribute') {\n// \t\t\tdelete new_values.record_need;\n// \t\t\tdelete new_values.FONDSID;\n// \t\t}\n\n// \t\t// 计算申请单标题\n// \t\tvar instance_name = \"\";\n// \t\tvar name_forumla = form.current.name_forumla;\n// \t\tif (name_forumla) {\n// \t\t\ttry {\n// \t\t\t\tvar iscript = name_forumla.replace(/\\{/g, \"(new_values['\").replace(/\\}/g, \"'] || '')\");\n// \t\t\t\tvar rev = eval(iscript);\n// \t\t\t\tinstance_name = rev || flow.name;\n// \t\t\t} catch (error) {\n// \t\t\t\tthrow new Meteor.Error('caculate_instance_name', \"计算申请单标题出错请检查表单标题脚本。\");\n// \t\t\t}\n// \t\t} else {\n// \t\t\tinstance_name = flow.name;\n// \t\t}\n\n// \t\t// instance中记录当前步骤名称 #1314\n// \t\tvar start_step = _.find(flow.current.steps, function (step) {\n// \t\t\treturn step.step_type == 'start';\n// \t\t})\n\n// \t\t// 流程转发功能修改为，开始节点有编辑权限的字段的值进行复制，无编辑权限的字段值不进行复制 #3748\n// \t\tif (action_type === 'forward') {\n// \t\t\tnew_values = uuflowManager.getApproveValues(new_values, start_step.permissions, flow.form, flow.current.form_version);\n// \t\t}\n\n// \t\t// 新建申请单时，instances记录流程名称、流程分类名称 #1313\n// \t\tvar category_name = \"\";\n// \t\tif (form.category) {\n// \t\t\tvar category = uuflowManager.getCategory(form.category);\n// \t\t\tif (category)\n// \t\t\t\tcategory_name = category.name;\n// \t\t}\n\n// \t\t_.each(forward_users, function (user_id) {\n\n// \t\t\tvar user_info = db.users.findOne(user_id);\n\n// \t\t\tvar space_user = db.space_users.findOne({\n// \t\t\t\tspace: space_id,\n// \t\t\t\tuser: user_id\n// \t\t\t}, {\n// \t\t\t\tfields: {\n// \t\t\t\t\torganization: 1\n// \t\t\t\t}\n// \t\t\t});\n// \t\t\tvar space_user_org_info = db.organizations.findOne({\n// \t\t\t\t_id: space_user.organization\n// \t\t\t}, {\n// \t\t\t\tfields: {\n// \t\t\t\t\tname: 1,\n// \t\t\t\t\tfullname: 1\n// \t\t\t\t}\n// \t\t\t});\n\n// \t\t\tvar now = new Date();\n// \t\t\tvar ins_obj = {};\n\n// \t\t\tvar agent = uuflowManager.getAgent(space_id, user_id);\n// \t\t\tvar handler_id = user_id;\n// \t\t\tvar handler_info = user_info;\n// \t\t\tvar handler_space_user = space_user;\n// \t\t\tvar handler_org_info = space_user_org_info;\n// \t\t\tif (agent) {\n// \t\t\t\thandler_id = agent;\n// \t\t\t\thandler_info = db.users.findOne(agent);\n// \t\t\t\thandler_space_user = uuflowManager.getSpaceUser(space_id, agent);\n// \t\t\t\thandler_org_info = uuflowManager.getSpaceUserOrgInfo(handler_space_user);\n// \t\t\t}\n// \t\t\tins_obj._id = db.instances._makeNewID();\n// \t\t\tins_obj.space = space_id;\n// \t\t\tins_obj.flow = flow_id;\n// \t\t\tins_obj.flow_version = flow.current._id;\n// \t\t\tins_obj.form = flow.form;\n// \t\t\tins_obj.form_version = flow.current.form_version;\n// \t\t\tins_obj.name = instance_name;\n// \t\t\tins_obj.submitter = handler_id;\n// \t\t\tins_obj.submitter_name = handler_info.name;\n// \t\t\tins_obj.applicant = user_id;\n// \t\t\tins_obj.applicant_name = user_info.name;\n// \t\t\tins_obj.applicant_organization = space_user.organization;\n// \t\t\tins_obj.applicant_organization_name = space_user_org_info.name;\n// \t\t\tins_obj.applicant_organization_fullname = space_user_org_info.fullname;\n// \t\t\tins_obj.state = \"draft\";\n// \t\t\tins_obj.code = \"\";\n// \t\t\tins_obj.is_archived = false;\n// \t\t\tins_obj.is_deleted = false;\n// \t\t\tins_obj.created = now;\n// \t\t\tins_obj.created_by = current_user_id;\n// \t\t\tins_obj.modified = now;\n// \t\t\tins_obj.modified_by = current_user_id;\n// \t\t\tins_obj.inbox_users = [handler_id];\n// \t\t\tins_obj.values = new_values;\n// \t\t\tif (action_type == 'distribute') {\n// \t\t\t\t// 解决多次分发看不到正文、附件问题\n// \t\t\t\tif (ins.distribute_from_instance) {\n// \t\t\t\t\tins_obj.distribute_from_instance = ins.distribute_from_instance;\n// \t\t\t\t} else {\n// \t\t\t\t\tins_obj.distribute_from_instance = instance_id;\n// \t\t\t\t}\n// \t\t\t\tins_obj.distribute_from_instances = _.clone(ins.distribute_from_instances) || [];\n// \t\t\t\tins_obj.distribute_from_instances.push(instance_id);\n\n// \t\t\t\tif (related) {\n// \t\t\t\t\tins_obj.related_instances = [instance_id]\n// \t\t\t\t}\n\n// \t\t\t} else if (action_type == 'forward') {\n// \t\t\t\tins_obj.forward_from_instance = instance_id\n// \t\t\t}\n\n// \t\t\t// 新建Trace\n// \t\t\tvar trace_obj = {};\n// \t\t\ttrace_obj._id = new Mongo.ObjectID()._str;\n// \t\t\ttrace_obj.instance = ins_obj._id;\n// \t\t\ttrace_obj.is_finished = false;\n\n// \t\t\t// 当前最新版flow中开始节点的step_id\n// \t\t\tvar step_id, step_name, can_edit_main_attach, can_edit_normal_attach;\n// \t\t\tflow.current.steps.forEach(function (step) {\n// \t\t\t\tif (step.step_type == \"start\") {\n// \t\t\t\t\tstep_id = step._id;\n// \t\t\t\t\tstep_name = step.name;\n// \t\t\t\t\tcan_edit_main_attach = step.can_edit_main_attach;\n// \t\t\t\t\tcan_edit_normal_attach = step.can_edit_normal_attach;\n// \t\t\t\t}\n// \t\t\t})\n// \t\t\ttrace_obj.step = step_id;\n// \t\t\ttrace_obj.start_date = now;\n// \t\t\ttrace_obj.name = step_name;\n\n// \t\t\t// 新建Approve\n// \t\t\tvar appr_obj = {};\n// \t\t\tappr_obj._id = new Mongo.ObjectID()._str;\n// \t\t\tappr_obj.instance = ins_obj._id;\n// \t\t\tappr_obj.trace = trace_obj._id;\n// \t\t\tappr_obj.is_finished = false;\n// \t\t\tappr_obj.user = user_id;\n// \t\t\tappr_obj.user_name = user_info.name;\n// \t\t\tappr_obj.handler = handler_id;\n// \t\t\tappr_obj.handler_name = handler_info.name;\n// \t\t\tappr_obj.handler_organization = handler_space_user.organization;\n// \t\t\tappr_obj.handler_organization_name = handler_org_info.name;\n// \t\t\tappr_obj.handler_organization_fullname = handler_org_info.fullname;\n// \t\t\tappr_obj.type = \"draft\";\n// \t\t\tappr_obj.start_date = now;\n// \t\t\tappr_obj.read_date = now;\n// \t\t\tappr_obj.is_read = false;\n// \t\t\tappr_obj.is_error = false;\n\n// \t\t\tappr_obj.values = new_values;\n\n// \t\t\tif (agent) {\n// \t\t\t\tappr_obj.agent = agent;\n// \t\t\t}\n\n// \t\t\ttrace_obj.approves = [appr_obj];\n// \t\t\tins_obj.traces = [trace_obj];\n\n// \t\t\tif (flow.auto_remind == true)\n// \t\t\t\tins_obj.auto_remind = true;\n\n// \t\t\tins_obj.current_step_name = start_step.name;\n\n// \t\t\tins_obj.flow_name = flow.name;\n// \t\t\tif (category_name) {\n// \t\t\t\tins_obj.category_name = category.name;\n// \t\t\t\tins_obj.category = category._id;\n// \t\t\t}\n\n// \t\t\tnew_ins_id = db.instances.insert(ins_obj);\n\n// \t\t\t// 复制附件\n// \t\t\tvar collection = cfs.instances;\n\n// \t\t\t//将原表单内容存储为第一个附件\n// \t\t\tif (hasSaveInstanceToAttachment) {\n// \t\t\t\t// try {\n\n// \t\t\t\tinstanceHtml = InstanceReadOnlyTemplate.getInstanceHtml(user_info, space_id, ins, {\n// \t\t\t\t\tabsolute: true,\n// \t\t\t\t\tshowTrace: true\n// \t\t\t\t})\n// \t\t\t\tvar instanceFile = new FS.File();\n// \t\t\t\tinstanceFile.attachData(Buffer.from(instanceHtml, \"utf-8\"), {\n// \t\t\t\t\ttype: \"text/html\"\n// \t\t\t\t}, function (error) {\n// \t\t\t\t\tif (error) {\n// \t\t\t\t\t\tthrow new Meteor.Error(error.error, error.reason);\n// \t\t\t\t\t}\n\n// \t\t\t\t\tinstanceFile.name(ins.name + \".html\");\n// \t\t\t\t\tinstanceFile.size(instanceHtml.length);\n\n// \t\t\t\t\tvar metadata = {\n// \t\t\t\t\t\towner: user_id,\n// \t\t\t\t\t\towner_name: user_info.name,\n// \t\t\t\t\t\tspace: space_id,\n// \t\t\t\t\t\tinstance: new_ins_id,\n// \t\t\t\t\t\tapprove: appr_obj._id,\n// \t\t\t\t\t\tcurrent: true\n// \t\t\t\t\t};\n// \t\t\t\t\tinstanceFile.metadata = metadata;\n// \t\t\t\t\tvar fileObj = collection.insert(instanceFile);\n// \t\t\t\t\tfileObj.update({\n// \t\t\t\t\t\t$set: {\n// \t\t\t\t\t\t\t'metadata.parent': fileObj._id\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t})\n\n// \t\t\t\t// } catch (e) {\n// \t\t\t\t//     console.error(e);\n// \t\t\t\t// }\n// \t\t\t}\n\n// \t\t\tif (isForwardAttachments && action_type == 'forward') {\n// \t\t\t\tvar files = collection.find({\n// \t\t\t\t\t'metadata.instance': instance_id,\n// \t\t\t\t\t'metadata.current': true\n// \t\t\t\t});\n// \t\t\t\tfiles.forEach(function (f) {\n// \t\t\t\t\t// 判断新的流程开始节点是否有编辑正文和编辑附件权限\n// \t\t\t\t\tif (f.metadata.main == true) {\n// \t\t\t\t\t\tif (can_edit_main_attach != true && can_edit_normal_attach != true)\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t} else {\n// \t\t\t\t\t\tif (can_edit_normal_attach != true)\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t}\n\n// \t\t\t\t\tvar newFile = new FS.File();\n// \t\t\t\t\tnewFile.attachData(f.createReadStream('instances'), {\n// \t\t\t\t\t\ttype: f.original.type\n// \t\t\t\t\t}, function (err) {\n// \t\t\t\t\t\tif (err) {\n// \t\t\t\t\t\t\tthrow new Meteor.Error(err.error, err.reason);\n// \t\t\t\t\t\t}\n// \t\t\t\t\t\tnewFile.name(f.name());\n// \t\t\t\t\t\tnewFile.size(f.size());\n// \t\t\t\t\t\tvar metadata = {\n// \t\t\t\t\t\t\towner: user_id,\n// \t\t\t\t\t\t\towner_name: user_info.name,\n// \t\t\t\t\t\t\tspace: space_id,\n// \t\t\t\t\t\t\tinstance: new_ins_id,\n// \t\t\t\t\t\t\tapprove: appr_obj._id,\n// \t\t\t\t\t\t\tcurrent: true\n// \t\t\t\t\t\t};\n// \t\t\t\t\t\tif (f.metadata.main == true && can_edit_main_attach == true) {\n// \t\t\t\t\t\t\tmetadata.main = true;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t\tnewFile.metadata = metadata;\n// \t\t\t\t\t\tvar fileObj = collection.insert(newFile);\n// \t\t\t\t\t\tfileObj.update({\n// \t\t\t\t\t\t\t$set: {\n// \t\t\t\t\t\t\t\t'metadata.parent': fileObj._id\n// \t\t\t\t\t\t\t}\n// \t\t\t\t\t\t})\n// \t\t\t\t\t})\n\n// \t\t\t\t})\n// \t\t\t}\n\n// \t\t\tif (action_type === 'distribute') {\n// \t\t\t\t// 给当前的申请单增加分发记录\n// \t\t\t\tvar appr = {\n// \t\t\t\t\t'_id': new Mongo.ObjectID()._str,\n// \t\t\t\t\t'instance': instance_id,\n// \t\t\t\t\t'trace': current_trace_id,\n// \t\t\t\t\t'is_finished': true,\n// \t\t\t\t\t'user': user_id,\n// \t\t\t\t\t'user_name': user_info.name,\n// \t\t\t\t\t'handler': user_id,\n// \t\t\t\t\t'handler_name': user_info.name,\n// \t\t\t\t\t'handler_organization': space_user.organization,\n// \t\t\t\t\t'handler_organization_name': space_user_org_info.name,\n// \t\t\t\t\t'handler_organization_fullname': space_user_org_info.fullname,\n// \t\t\t\t\t'type': action_type,\n// \t\t\t\t\t'start_date': new Date(),\n// \t\t\t\t\t'finish_date': new Date(),\n// \t\t\t\t\t'is_read': false,\n// \t\t\t\t\t'judge': 'submitted',\n// \t\t\t\t\t'from_user': current_user_id,\n// \t\t\t\t\t'from_user_name': from_user_name,\n// \t\t\t\t\t'forward_space': space_id,\n// \t\t\t\t\t'forward_instance': new_ins_id,\n// \t\t\t\t\t'description': description,\n// \t\t\t\t\t'from_approve_id': from_approve_id\n// \t\t\t\t};\n\n// \t\t\t\tforward_approves.push(appr);\n// \t\t\t}\n\n// \t\t\tnew_ins_ids.push(new_ins_id);\n// \t\t\tpushManager.send_message_to_specifyUser(\"current_user\", user_id);\n// \t\t})\n\n// \t\tif (!_.isEmpty(forward_approves)) {\n// \t\t\tset_obj.modified = new Date();\n// \t\t\tset_obj.modified_by = current_user_id;\n// \t\t\tvar r = db.instances.update({\n// \t\t\t\t_id: instance_id,\n// \t\t\t\t\"traces._id\": current_trace_id\n// \t\t\t}, {\n// \t\t\t\t$set: set_obj,\n// \t\t\t\t$addToSet: {\n// \t\t\t\t\t'traces.$.approves': {\n// \t\t\t\t\t\t$each: forward_approves\n// \t\t\t\t\t}\n// \t\t\t\t}\n// \t\t\t});\n// \t\t}\n\n\n// \t\tif (r) {\n// \t\t\t_.each(current_trace.approves, function (a, idx) {\n// \t\t\t\tif (a._id == from_approve_id) {\n// \t\t\t\t\tvar update_read = {};\n// \t\t\t\t\tupdate_read[\"traces.$.approves.\" + idx + \".read_date\"] = new Date();\n// \t\t\t\t\tdb.instances.update({\n// \t\t\t\t\t\t_id: instance_id,\n// \t\t\t\t\t\t\"traces._id\": current_trace_id\n// \t\t\t\t\t}, {\n// \t\t\t\t\t\t$set: update_read\n// \t\t\t\t\t});\n// \t\t\t\t}\n// \t\t\t})\n\n// \t\t}\n\n// \t\tJsonRoutes.sendResult(res, {\n// \t\t\tcode: 200,\n// \t\t\tdata: { new_ins_ids: new_ins_ids }\n// \t\t})\n// \t} catch (e) {\n// \t\tconsole.error(e.stack)\n// \t\tJsonRoutes.sendResult(res, {\n// \t\t\tcode: 200,\n// \t\t\tdata: {\n// \t\t\t\terrors: [e]\n// \t\t\t}\n// \t\t})\n// \t}\n\n// })","if process.env.CREATOR_NODE_ENV == 'development'\n    JsonRoutes.add 'post', '/test/webhook', (req, res, next) ->\n        try\n\n            hashData = req.body\n            console.log 'action: ', hashData.action\n            console.log 'from_user: ', hashData.from_user\n            console.log 'to_users: ', hashData.to_users\n\n\n            JsonRoutes.sendResult res,\n                    code: 200\n                    data: {}\n        catch e\n            console.error e.stack\n            JsonRoutes.sendResult res,\n                code: 200\n                data: { errors: [{errorMessage: e.message}] }","if (process.env.CREATOR_NODE_ENV === 'development') {\n  JsonRoutes.add('post', '/test/webhook', function(req, res, next) {\n    var e, hashData;\n    try {\n      hashData = req.body;\n      console.log('action: ', hashData.action);\n      console.log('from_user: ', hashData.from_user);\n      console.log('to_users: ', hashData.to_users);\n      return JsonRoutes.sendResult(res, {\n        code: 200,\n        data: {}\n      });\n    } catch (error) {\n      e = error;\n      console.error(e.stack);\n      return JsonRoutes.sendResult(res, {\n        code: 200,\n        data: {\n          errors: [\n            {\n              errorMessage: e.message\n            }\n          ]\n        }\n      });\n    }\n  });\n}\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tset_instance_step_approve: (ins_id, step_approve, stepsApprovesOptions)->\n\t\treturn workflowMethods.set_instance_step_approve.apply(this, arguments)\n\tset_instance_skip_steps: (ins_id, stepId, action)->\n\t\treturn workflowMethods.set_instance_skip_steps.apply(this, arguments)","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-22 15:18:59\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\n\tget_instance_data: function (instance_id, formCached, flowCached) {\n\t\treturn workflowMethods.get_instance_data.apply(this, arguments)\n\t}\n\n});\n","const { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\n\tdraft_save_instance: function (ins) {\n\t\treturn workflowMethods.draft_save_instance.apply(this, arguments)\n\t},\n\n\tinbox_save_instance: function (approve) {\n\t\treturn workflowMethods.inbox_save_instance.apply(this, arguments)\n\t}\n\n})","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2023-01-13 17:35:13\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2023-03-11 10:51:29\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\tcc_do: function (approve, cc_user_ids, description) {\n\t\treturn workflowMethods.cc_do.apply(this, arguments)\n\t},\n\n\tcc_read: function (approve) {\n\t\treturn workflowMethods.cc_read.apply(this, arguments)\n\t},\n\n\tcc_submit: function (ins_id, description, myApprove, ccHasEditPermission) {\n\t\treturn workflowMethods.cc_submit.apply(this, arguments)\n\t},\n\n\tcc_remove: function (instanceId, approveId) {\n\t\treturn workflowMethods.cc_remove.apply(this, arguments)\n\t},\n\n\tbatch_cancel_cc: function (instance_id, approve_ids) {\n\t\treturn workflowMethods.batch_cancel_cc.apply(this, arguments)\n\t},\n\n\tcc_save: function (ins_id, description, myApprove, ccHasEditPermission) {\n\t\treturn workflowMethods.cc_save.apply(this, arguments)\n\t}\n})","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-22 15:18:38\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\t// 改为通过api调用\n\tforward_instance: function (instance_id, space_id, flow_id, hasSaveInstanceToAttachment, description, isForwardAttachments, selectedUsers, action_type, related, from_approve_id) {\n\t\tif (!this.userId)\n\t\t\tthrow new Meteor.Error('not-authorized');\n\n\t\treturn;\n\t},\n\n\n\tforward_remove: function (instance_id, trace_id, approve_id) {\n\t\treturn workflowMethods.forward_remove.apply(this, arguments)\n\t},\n\n\tcancelDistribute: function (instance_id, approve_ids) {\n\t\treturn workflowMethods.cancelDistribute.apply(this, arguments)\n\t}\n\n\n})","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-22 15:17:54\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n    cfs_instances_remove: function (file_id) {\n        return workflowMethods.cfs_instances_remove.apply(this, arguments)\n    },\n\n    cfs_instances_set_current: function (file_id) {\n        return workflowMethods.cfs_instances_set_current.apply(this, arguments)\n    },\n\n    cfs_instances_lock: function (file_id, user_id, user_name) {\n        return workflowMethods.cfs_instances_lock.apply(this, arguments)\n    },\n\n    cfs_instances_unlock: function (file_id) {\n        return workflowMethods.cfs_instances_unlock.apply(this, arguments)\n    },\n\n    download_space_instance_attachments_to_disk: function (spaceId, cfsRecordIds) {\n        return workflowMethods.download_space_instance_attachments_to_disk.apply(this, arguments)\n    }\n})","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tset_approve_have_read: (instanceId, traceId, approveId) ->\n\t\treturn workflowMethods.set_approve_have_read.apply(this, arguments)\n\n\tchange_approve_info: (instanceId, traceId, approveId, description, finish_date) ->\n\t\treturn workflowMethods.change_approve_info.apply(this, arguments)\n\n\tupdate_approve_sign: (instanceId, traceId, approveId, sign_field_code, description, sign_type, lastSignApprove)->\n\t\treturn workflowMethods.update_approve_sign.apply(this, arguments)\n\n\n\tupdate_sign_show: (objs, myApprove_id) ->\n\t\treturn workflowMethods.update_sign_show.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tinstance_return: (approve, reason)->\n\t\treturn workflowMethods.instance_return.apply(this, arguments)","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tinstance_remind: (remind_users, remind_count, remind_deadline, instance_id, action_types, trace_id)->\n\t\treturn workflowMethods.instance_remind.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tnext_step_users_not_found: (deal_type, step_name, params) ->\n\t\treturn workflowMethods.next_step_users_not_found.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\n_eval = require('eval')\n\nMeteor.methods\n\tinstanceNumberBuilder: (spaceId, name)->\n\t\treturn workflowMethods.instanceNumberBuilder.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tcheck_main_attach: (ins_id, name)->\n\t\treturn workflowMethods.check_main_attach.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tremove_related: (ins_id, re_ins_id)->\n\t\treturn workflowMethods.remove_related.apply(this, arguments)\n\n\tupdate_instance_related: (ins_id, related_instances)->\n\t\treturn workflowMethods.update_instance_related.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tupdateFlowPosition: (data) ->\n\t\treturn workflowMethods.updateFlowPosition.apply(this, arguments)\n\n\tupdateFlowRole: (data) ->\n\t\treturn workflowMethods.updateFlowRole.apply(this, arguments)","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tstart_flow: (space, flowId, start) ->\n\n\t\treturn workflowMethods.start_flow.apply(this, arguments)\n\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tget_instance_traces: (ins_id)->\n\t\treturn workflowMethods.get_instance_traces.apply(this, arguments)","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\t'get_batch_instances': (space, categoryId, flowIds)->\n\t\treturn workflowMethods.get_batch_instances.apply(this, arguments)\n\n\t'get_batch_instances_count': (space, categoryId, flowIds)->\n\t\treturn workflowMethods.get_batch_instances_count.apply(this, arguments)\n\n\t'get_my_approves': (instanceIds)->\n\t\treturn workflowMethods.get_my_approves.apply(this, arguments)\n\n\n\n\n\n\n\n\n\n\n\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tchange_flow_state: (flows) ->\n\t\treturn workflowMethods.change_flow_state.apply(this, arguments)\n\n\n\n\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\n\thide_instance: (insId, is_hidden) ->\n\t\treturn workflowMethods.hide_instance.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tgetInstanceValues: (insId)->\n\t\treturn workflowMethods.getInstanceValues.apply(this, arguments)","Cookies = require(\"cookies\")\n\ngetInstanceReadOnly = (req, res, next, options) ->\n\n\tuser = Steedos.getAPILoginUser(req, res)\n\n\tif req?.query?.access_token\n\t\tuserId = Steedos.getUserIdFromAccessToken(req.query.access_token)\n\t\tif userId\n\t\t\tuser = Meteor.users.findOne({_id: userId})\n\n\tspaceId = req.params.space\n\n\tinstanceId = req.params.instance_id\n\n\tinstance = db.instances.findOne({_id: instanceId});\n\n\tspace = db.spaces.findOne({_id: spaceId});\n\n\thide_traces = req.query?.hide_traces\n\n\tif !options\n\t\toptions = {showTrace: true}\n\telse\n\t\toptions.showTrace = true\n\n\tif hide_traces is \"1\"\n\t\tif options\n\t\t\toptions.showTrace = false\n\t\telse\n\t\t\toptions = {showTrace: false}\n\n\tif !options.showAttachments\n\t\toptions.showAttachments = true\n\n\tif !space\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing space\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tif  !instance\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing instance\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tif !user\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing X-Auth-Token,X-User-Id\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tif instance.space != spaceId\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing space or instance\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\n\n\tspaceUserCount = db.space_users.find({ user: user._id, space: spaceId }).count()\n\n\tif spaceUserCount is 0\n\t\tif !space\n\t\t\tJsonRoutes.sendResult res,\n\t\t\t\tcode: 401,\n\t\t\t\tdata:\n\t\t\t\t\t\"error\": \"Validate Request -- Missing sapceUser\",\n\t\t\t\t\t\"success\": false\n\t\t\treturn;\n\n\t#校验user是否对instance有查看权限\n\t_hasPermission = WorkflowManager.hasInstancePermissions(user, instance)\n\n\tif !_hasPermission  && instance.distribute_from_instance\n\t\t_parent_instances = _.union([instance.distribute_from_instance], instance.distribute_from_instances || [])\n\n\t\t_hasPermission = _.find _parent_instances, (_parent_id)->\n\t\t\t_parent_ins = db.instances.findOne({_id:_parent_id}, {fields: {traces: 0}})\n\n\t\t\treturn WorkflowManager.hasInstancePermissions(user, _parent_ins)\n\n\tif !_hasPermission\n\t\t_locale = Steedos.locale(user._id, true)\n\t\terror = TAPi18n.__(\"instance_permissions_error\", {}, _locale)\n\t\tres.charset = \"utf-8\"\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": error,\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\thtml = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options)\n\tdataBuf = new Buffer(html);\n\tres.setHeader('Content-type', 'text/html; charset=utf-8');\n\tres.setHeader('content-length', dataBuf.length)\n\tres.setHeader('content-range', \"bytes 0-#{dataBuf.length - 1}/#{dataBuf.length}\")\n\tres.statusCode = 200\n\tres.end(html)\n\nJsonRoutes.add \"get\", \"/workflow/space/:space/view/readonly/:instance_id\", getInstanceReadOnly\n\nJsonRoutes.add \"get\", \"/workflow/space/:space/view/readonly/:instance_id/:instance_name\", (req, res, next)->\n\tres.setHeader('Content-type', 'application/x-msdownload');\n\tres.setHeader('Content-Disposition', 'attachment;filename='+encodeURI(req.params.instance_name));\n\tres.setHeader('Transfer-Encoding', '')\n\n\toptions = {absolute: true}\n\n\treturn getInstanceReadOnly(req, res, next, options)\n###\n\t获取申请单列表：\n    final_decision：审批结果\n    state: 申请单状态\n###\nJsonRoutes.add \"get\", \"/api/workflow/instances\", (req, res, next) ->\n\n\tif !Steedos.APIAuthenticationCheck(req, res)\n\t\treturn ;\n\n\tuser_id = req.userId\n\n\tspaceId = req.headers[\"x-space-id\"]\n\n\tif not spaceId\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing X-Space-Id\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tflowId = req.query?.flowId\n\n\tif !flowId\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 400,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing flowId\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tquery = {}\n\n\tret_sync_token = new Date().getTime()\n\n\tflowIds = flowId.split(\",\")\n\n\n\tflows = db.flows.find({_id: {$in: flowIds}}).fetch()\n\n\ti = 0\n\twhile i < flows.length\n\t\tf = flows[i]\n\t\tspaceUser = db.space_users.findOne({space: f.space, user: user_id})\n\t\tif !spaceUser\n\t\t\tJsonRoutes.sendResult res,\n\t\t\t\tcode: 401,\n\t\t\t\tdata:\n\t\t\t\t\t\"error\": \"Validate Request -- No permission, flow is #{f._id}\",\n\t\t\t\t\t\"success\": false\n\t\t\treturn;\n\t\telse\n\n\t#\t是否工作区管理员\n\t\tif !Steedos.isSpaceAdmin(spaceId, user_id)\n\t\t\tspaceUserOrganizations = db.organizations.find({\n\t\t\t\t_id: {\n\t\t\t\t\t$in: spaceUser.organizations\n\t\t\t\t}\n\t\t\t}).fetch();\n\n\t\t\tif !WorkflowManager.canMonitor(f, spaceUser, spaceUserOrganizations) && !WorkflowManager.canAdmin(f, spaceUser, spaceUserOrganizations)\n\t\t\t\tJsonRoutes.sendResult res,\n\t\t\t\t\tcode: 401,\n\t\t\t\t\tdata:\n\t\t\t\t\t\t\"error\": \"Validate Request -- No permission, flow is #{f._id}\",\n\t\t\t\t\t\t\"success\": false\n\t\t\t\treturn;\n\t\ti++\n\n\n\tquery.flow = {$in: flowIds}\n\n\tquery.space = spaceId\n\n\tif req.query?.sync_token\n\t\tsync_token = new Date(Number(req.query.sync_token))\n\t\tquery.modified = {$gt: sync_token}\n\n\tif req.query?.final_decision\n\t\tquery.final_decision = {$in : req.query.final_decision.split(\",\")}\n\telse\n\t\tquery.final_decision = {$nin: [\"terminated\", \"rejected\"]}\n\n\tif req.query?.state\n\t\tquery.state = {$in: req.query.state.split(\",\")}\n\telse\n\t\tquery.state = \"completed\"\n\n#\t最多返回500条数据\n\tinstances = db.instances.find(query, {fields: {inbox_uers: 0, cc_users: 0, outbox_users: 0, traces: 0, attachments: 0}, skip: 0, limit: 500}).fetch()\n\tinstances.forEach (instance)->\n\n\t\tattachments = cfs.instances.find({'metadata.instance': instance._id,'metadata.current': true, \"metadata.is_private\": {$ne: true}}, {fields: {copies: 0}}).fetch()\n\n\t\tinstance.attachments = attachments\n\n\n\tJsonRoutes.sendResult res,\n\t\t\tcode: 200,\n\t\t\tdata:\n\t\t\t\t\"status\": \"success\",\n\t\t\t\t\"sync_token\": ret_sync_token\n\t\t\t\t\"data\": instances\n\treturn;\n","var Cookies, getInstanceReadOnly;\n\nCookies = require(\"cookies\");\n\ngetInstanceReadOnly = function(req, res, next, options) {\n  var _hasPermission, _locale, _parent_instances, dataBuf, error, hide_traces, html, instance, instanceId, ref, ref1, space, spaceId, spaceUserCount, user, userId;\n  user = Steedos.getAPILoginUser(req, res);\n  if (req != null ? (ref = req.query) != null ? ref.access_token : void 0 : void 0) {\n    userId = Steedos.getUserIdFromAccessToken(req.query.access_token);\n    if (userId) {\n      user = Meteor.users.findOne({\n        _id: userId\n      });\n    }\n  }\n  spaceId = req.params.space;\n  instanceId = req.params.instance_id;\n  instance = db.instances.findOne({\n    _id: instanceId\n  });\n  space = db.spaces.findOne({\n    _id: spaceId\n  });\n  hide_traces = (ref1 = req.query) != null ? ref1.hide_traces : void 0;\n  if (!options) {\n    options = {\n      showTrace: true\n    };\n  } else {\n    options.showTrace = true;\n  }\n  if (hide_traces === \"1\") {\n    if (options) {\n      options.showTrace = false;\n    } else {\n      options = {\n        showTrace: false\n      };\n    }\n  }\n  if (!options.showAttachments) {\n    options.showAttachments = true;\n  }\n  if (!space) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing space\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  if (!instance) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing instance\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  if (!user) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing X-Auth-Token,X-User-Id\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  if (instance.space !== spaceId) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing space or instance\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  spaceUserCount = db.space_users.find({\n    user: user._id,\n    space: spaceId\n  }).count();\n  if (spaceUserCount === 0) {\n    if (!space) {\n      JsonRoutes.sendResult(res, {\n        code: 401,\n        data: {\n          \"error\": \"Validate Request -- Missing sapceUser\",\n          \"success\": false\n        }\n      });\n      return;\n    }\n  }\n  _hasPermission = WorkflowManager.hasInstancePermissions(user, instance);\n  if (!_hasPermission && instance.distribute_from_instance) {\n    _parent_instances = _.union([instance.distribute_from_instance], instance.distribute_from_instances || []);\n    _hasPermission = _.find(_parent_instances, function(_parent_id) {\n      var _parent_ins;\n      _parent_ins = db.instances.findOne({\n        _id: _parent_id\n      }, {\n        fields: {\n          traces: 0\n        }\n      });\n      return WorkflowManager.hasInstancePermissions(user, _parent_ins);\n    });\n  }\n  if (!_hasPermission) {\n    _locale = Steedos.locale(user._id, true);\n    error = TAPi18n.__(\"instance_permissions_error\", {}, _locale);\n    res.charset = \"utf-8\";\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": error,\n        \"success\": false\n      }\n    });\n    return;\n  }\n  html = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options);\n  dataBuf = new Buffer(html);\n  res.setHeader('Content-type', 'text/html; charset=utf-8');\n  res.setHeader('content-length', dataBuf.length);\n  res.setHeader('content-range', \"bytes 0-\" + (dataBuf.length - 1) + \"/\" + dataBuf.length);\n  res.statusCode = 200;\n  return res.end(html);\n};\n\nJsonRoutes.add(\"get\", \"/workflow/space/:space/view/readonly/:instance_id\", getInstanceReadOnly);\n\nJsonRoutes.add(\"get\", \"/workflow/space/:space/view/readonly/:instance_id/:instance_name\", function(req, res, next) {\n  var options;\n  res.setHeader('Content-type', 'application/x-msdownload');\n  res.setHeader('Content-Disposition', 'attachment;filename=' + encodeURI(req.params.instance_name));\n  res.setHeader('Transfer-Encoding', '');\n  options = {\n    absolute: true\n  };\n  return getInstanceReadOnly(req, res, next, options);\n});\n\n\n/*\n\t获取申请单列表：\n    final_decision：审批结果\n    state: 申请单状态\n */\n\nJsonRoutes.add(\"get\", \"/api/workflow/instances\", function(req, res, next) {\n  var f, flowId, flowIds, flows, i, instances, query, ref, ref1, ref2, ref3, ret_sync_token, spaceId, spaceUser, spaceUserOrganizations, sync_token, user_id;\n  if (!Steedos.APIAuthenticationCheck(req, res)) {\n    return;\n  }\n  user_id = req.userId;\n  spaceId = req.headers[\"x-space-id\"];\n  if (!spaceId) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing X-Space-Id\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  flowId = (ref = req.query) != null ? ref.flowId : void 0;\n  if (!flowId) {\n    JsonRoutes.sendResult(res, {\n      code: 400,\n      data: {\n        \"error\": \"Validate Request -- Missing flowId\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  query = {};\n  ret_sync_token = new Date().getTime();\n  flowIds = flowId.split(\",\");\n  flows = db.flows.find({\n    _id: {\n      $in: flowIds\n    }\n  }).fetch();\n  i = 0;\n  while (i < flows.length) {\n    f = flows[i];\n    spaceUser = db.space_users.findOne({\n      space: f.space,\n      user: user_id\n    });\n    if (!spaceUser) {\n      JsonRoutes.sendResult(res, {\n        code: 401,\n        data: {\n          \"error\": \"Validate Request -- No permission, flow is \" + f._id,\n          \"success\": false\n        }\n      });\n      return;\n    } else {\n\n    }\n    if (!Steedos.isSpaceAdmin(spaceId, user_id)) {\n      spaceUserOrganizations = db.organizations.find({\n        _id: {\n          $in: spaceUser.organizations\n        }\n      }).fetch();\n      if (!WorkflowManager.canMonitor(f, spaceUser, spaceUserOrganizations) && !WorkflowManager.canAdmin(f, spaceUser, spaceUserOrganizations)) {\n        JsonRoutes.sendResult(res, {\n          code: 401,\n          data: {\n            \"error\": \"Validate Request -- No permission, flow is \" + f._id,\n            \"success\": false\n          }\n        });\n        return;\n      }\n    }\n    i++;\n  }\n  query.flow = {\n    $in: flowIds\n  };\n  query.space = spaceId;\n  if ((ref1 = req.query) != null ? ref1.sync_token : void 0) {\n    sync_token = new Date(Number(req.query.sync_token));\n    query.modified = {\n      $gt: sync_token\n    };\n  }\n  if ((ref2 = req.query) != null ? ref2.final_decision : void 0) {\n    query.final_decision = {\n      $in: req.query.final_decision.split(\",\")\n    };\n  } else {\n    query.final_decision = {\n      $nin: [\"terminated\", \"rejected\"]\n    };\n  }\n  if ((ref3 = req.query) != null ? ref3.state : void 0) {\n    query.state = {\n      $in: req.query.state.split(\",\")\n    };\n  } else {\n    query.state = \"completed\";\n  }\n  instances = db.instances.find(query, {\n    fields: {\n      inbox_uers: 0,\n      cc_users: 0,\n      outbox_users: 0,\n      traces: 0,\n      attachments: 0\n    },\n    skip: 0,\n    limit: 500\n  }).fetch();\n  instances.forEach(function(instance) {\n    var attachments;\n    attachments = cfs.instances.find({\n      'metadata.instance': instance._id,\n      'metadata.current': true,\n      \"metadata.is_private\": {\n        $ne: true\n      }\n    }, {\n      fields: {\n        copies: 0\n      }\n    }).fetch();\n    return instance.attachments = attachments;\n  });\n  JsonRoutes.sendResult(res, {\n    code: 200,\n    data: {\n      \"status\": \"success\",\n      \"sync_token\": ret_sync_token,\n      \"data\": instances\n    }\n  });\n});\n","\nJsonRoutes.add \"get\", \"/steedos-css\", (req, res, next)->\n\tres.setHeader('Content-type', 'text/css');\n\tallCss = WebApp.getRefreshableAssets()\n\n\tallCssLink = \"\"\n\n\tallCss.forEach (css) ->\n\t\tif __meteor_runtime_config__.ROOT_URL_PATH_PREFIX\n\t\t\trootUrl = __meteor_runtime_config__.ROOT_URL\n\t\t\tif rootUrl.endsWith(\"/\")\n\t\t\t\tcssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX + \"/\", \"\") + css.url\n\t\t\telse\n\t\t\t\tcssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX, \"\") + css.url\n\t\telse\n\t\t\tcssHref = Meteor.absoluteUrl(css.url)\n\t\tallCssLink += \"@import url(#{cssHref});\"\n\n\tres.statusCode = 200\n\tres.end(allCssLink)","JsonRoutes.add(\"get\", \"/steedos-css\", function(req, res, next) {\n  var allCss, allCssLink;\n  res.setHeader('Content-type', 'text/css');\n  allCss = WebApp.getRefreshableAssets();\n  allCssLink = \"\";\n  allCss.forEach(function(css) {\n    var cssHref, rootUrl;\n    if (__meteor_runtime_config__.ROOT_URL_PATH_PREFIX) {\n      rootUrl = __meteor_runtime_config__.ROOT_URL;\n      if (rootUrl.endsWith(\"/\")) {\n        cssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX + \"/\", \"\") + css.url;\n      } else {\n        cssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX, \"\") + css.url;\n      }\n    } else {\n      cssHref = Meteor.absoluteUrl(css.url);\n    }\n    return allCssLink += \"@import url(\" + cssHref + \");\";\n  });\n  res.statusCode = 200;\n  return res.end(allCssLink);\n});\n","JsonRoutes.add \"get\", \"/api/workflow/space/:space/view/draft/:flow\", (req, res, next) ->\n\tif !Steedos.APIAuthenticationCheck(req, res)\n\t\treturn\n\n\tuser_id = req.userId\n\n\tuser = db.users.findOne({ _id: user_id })\n\n\tspaceId = req.params.space\n\n\tflowId = req.params.flow\n\n\tspace = db.spaces.findOne({ _id: spaceId })\n\n\tflow = db.flows.findOne({ _id: flowId }, { fields: { name: 1, 'current._id': 1, form: 1 } })\n\n\tform = db.forms.findOne({ _id: flow.form }, { fields: { 'current._id': 1 } })\n\n\toptions = {\n\t\tshowTrace: false,\n\t\tshowAttachments: false,\n\t\ttemplateName: \"default\",\n\t\teditable: true,\n\t\twidth: \"100%\",\n\t\tinstance_style: \"instance-default\",\n\t\tplugins: \"\"\"\n\n\t\t\t<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge,chrome=1\" />\n\t\t\t<meta name=\"format-detection\" content=\"telephone=no\">\n\t\t\t<meta http-equiv=\"x-rim-auto-match\" content=\"none\">\n\t\t\t<title>#{flow.name}</title>\n\t\t\t<meta content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0' name='viewport' />\n\t\t\t<meta name=\"viewport\" content=\"width=device-width\" />\n\n\t\t\t<link rel=\"stylesheet\" type=\"text/css\" href=\"/plugins/bootstrap-datetimepicker/css/bootstrap-datetimepicker.min.css\">\n\n\t\t\t<script src=\"/plugins/bootstrap-datetimepicker/js/bootstrap-datetimepicker.min.js\" type=\"text/javascript\"></script>\n\n\t\t\t<script src=\"/plugins/bootstrap-datetimepicker/js/locales/bootstrap-datetimepicker.zh-CN.js\" type=\"text/javascript\" charset=\"UTF-8\"></script>\n\n\t\t\t<link rel=\"stylesheet\" type=\"text/css\" href=\"/plugins/toastr/toastr.min.css\">\n\t\t\t<script src=\"/plugins/toastr/toastr.min.js\" type=\"text/javascript\"></script>\n\t\t\t<link rel=\"stylesheet\" type=\"text/css\" href=\"/js/workflow_client.css\">\n\t\t\t<script src=\"/js/workflow_client.js\" type=\"text/javascript\"></script>\n\t\t\"\"\"\n\t}\n\n\tinstance = {\n\t\tflow: flow._id,\n\t\tflow_version: flow.current._id,\n\t\tform: form._id,\n\t\tform_version: form.current._id,\n\t\tvalues: {},\n\t\tname: flow.name,\n\t\tspace: spaceId\n\t}\n\n\thtml = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options)\n\n\tdataBuf = new Buffer(html)\n\n\tres.setHeader('content-length', dataBuf.length)\n\n\tres.setHeader('content-range', \"bytes 0-#{dataBuf.length - 1}/#{dataBuf.length}\")\n\n\tres.statusCode = 200\n\n\tres.end(html)\n","JsonRoutes.add(\"get\", \"/api/workflow/space/:space/view/draft/:flow\", function(req, res, next) {\n  var dataBuf, flow, flowId, form, html, instance, options, space, spaceId, user, user_id;\n  if (!Steedos.APIAuthenticationCheck(req, res)) {\n    return;\n  }\n  user_id = req.userId;\n  user = db.users.findOne({\n    _id: user_id\n  });\n  spaceId = req.params.space;\n  flowId = req.params.flow;\n  space = db.spaces.findOne({\n    _id: spaceId\n  });\n  flow = db.flows.findOne({\n    _id: flowId\n  }, {\n    fields: {\n      name: 1,\n      'current._id': 1,\n      form: 1\n    }\n  });\n  form = db.forms.findOne({\n    _id: flow.form\n  }, {\n    fields: {\n      'current._id': 1\n    }\n  });\n  options = {\n    showTrace: false,\n    showAttachments: false,\n    templateName: \"default\",\n    editable: true,\n    width: \"100%\",\n    instance_style: \"instance-default\",\n    plugins: \"\\n<meta http-equiv=\\\"X-UA-Compatible\\\" content=\\\"IE=edge,chrome=1\\\" />\\n<meta name=\\\"format-detection\\\" content=\\\"telephone=no\\\">\\n<meta http-equiv=\\\"x-rim-auto-match\\\" content=\\\"none\\\">\\n<title>\" + flow.name + \"</title>\\n<meta content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0' name='viewport' />\\n<meta name=\\\"viewport\\\" content=\\\"width=device-width\\\" />\\n\\n<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"/plugins/bootstrap-datetimepicker/css/bootstrap-datetimepicker.min.css\\\">\\n\\n<script src=\\\"/plugins/bootstrap-datetimepicker/js/bootstrap-datetimepicker.min.js\\\" type=\\\"text/javascript\\\"></script>\\n\\n<script src=\\\"/plugins/bootstrap-datetimepicker/js/locales/bootstrap-datetimepicker.zh-CN.js\\\" type=\\\"text/javascript\\\" charset=\\\"UTF-8\\\"></script>\\n\\n<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"/plugins/toastr/toastr.min.css\\\">\\n<script src=\\\"/plugins/toastr/toastr.min.js\\\" type=\\\"text/javascript\\\"></script>\\n<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"/js/workflow_client.css\\\">\\n<script src=\\\"/js/workflow_client.js\\\" type=\\\"text/javascript\\\"></script>\"\n  };\n  instance = {\n    flow: flow._id,\n    flow_version: flow.current._id,\n    form: form._id,\n    form_version: form.current._id,\n    values: {},\n    name: flow.name,\n    space: spaceId\n  };\n  html = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options);\n  dataBuf = new Buffer(html);\n  res.setHeader('content-length', dataBuf.length);\n  res.setHeader('content-range', \"bytes 0-\" + (dataBuf.length - 1) + \"/\" + dataBuf.length);\n  res.statusCode = 200;\n  return res.end(html);\n});\n","Array.prototype.filterProperty = function(h, l){\n    var g = [];\n    this.forEach(function(t){\n        var m = t? t[h]:null;\n        var d = false;\n        if(m instanceof Array){\n            d = m.includes(l);\n        }else{\n            d = (l === undefined)? false:m==l;\n        }\n        if(d){\n            g.push(t);\n        }\n    });\n    return g;\n};\n\nArray.prototype.getProperty = function(k){\n    var v = new Array();\n    this.forEach(function(t){\n        var m = t? t[k]:null;\n        v.push(m);\n    });\n    return v;\n}\n\nArray.prototype.getEach = function(code){\n    var rev = [];\n    for(var i = 0 ; i < this.length ; i++){\n        rev.push(this[i][code]);\n    }\n    return rev;\n};\n\nArray.prototype.uniq = function(){\n    var a = [];\n    this.forEach(function(b){ \n        if(a.indexOf(b) < 0)\n            {a[a.length] = b}\n    });\n    return a;\n};\n\nForm_formula = {};\n\n\nForm_formula.mixin = function(dest, src){\n    for(var key in src){\n        dest[key] = src[key];\n    }\n    return dest;\n};\n\n\nForm_formula.handerUserObject = function(u){\n\n    if(u instanceof Array){\n        var user = {};\n\n        user.name = u.getProperty(\"name\")\n        user.organization = {};\n        user.organization.name = u.getProperty(\"organization\").getProperty(\"name\");\n        user.organization.fullname = u.getProperty(\"organization\").getProperty(\"fullname\");\n\n        user.hr = u.getProperty(\"hr\")\n\n        user.sort_no = u.getProperty(\"sort_no\")\n\n\t\tuser.mobile = u.getProperty(\"mobile\")\n\n\t\tuser.work_phone = u.getProperty(\"work_phone\")\n\n\t\tuser.position = u.getProperty(\"position\")\n\n        var userRoles = u.getProperty(\"roles\");\n        var roles = new Array();\n        userRoles.forEach(function(i){\n            roles = roles.concat(i);\n        }); \n        roles.uniq();\n        user.roles = roles;\n        return user;\n    }else{\n        return u;\n    }\n}\n\nForm_formula.handerOrgObject = function(o){\n\n    if(o instanceof Array){\n        var org = {};\n\t\torg.id = o.getProperty(\"_id\");\n        org.name = o.getProperty(\"name\");\n        org.fullname = o.getProperty(\"fullname\");\n\n        return org;\n    }else{\n        return o;\n    }\n}\n\n\n\n/**\n    * 获得公式需要用到的初始值\n    * 输入：fields, values, applicant\n    * 输出：__values\n**/\nForm_formula.init_formula_values = function(fields, autoFormDoc, approver, applicant, spaceId){\n    var __values = {};\n    //申请单中填的值处理\n    if(fields && fields.length && autoFormDoc) {\n        //debugger;\n        fields.forEach(function(field){\n            var type = field.type;\n            if(type) {\n                if(type === 'table') {\n                    /*\n                    * 将表格字段的值进行转换后传入__values中\n                    * values中表格的值格式为\n                    * [{\"a\":1,\"b\":4},{\"a\":2,\"b\":5},{\"a\":3,\"b\":6}]\n                    * __values需要转化为下面格式且和主表的值一样放到第一层\n                    * {\"a\":[1,2,3],\"b\":[4,5,6]}\n                    **/\n                    var tableFields = field.sfields,\n                        tableValues = autoFormDoc[field.code],\n                        formulaTableValues = [],\n                        __tableValues = {};\n                    //按公式的格式转换值为__tableValues\n                    if(tableFields && tableFields.length && tableValues && tableValues instanceof Array) {\n                        tableValues.forEach(function(tableValue){\n                            formulaTableValues.push(Form_formula.init_formula_values(tableFields, tableValue));\n                        }, this);\n                        //按主表的格式转换__tableValues加到\n                        tableFields.forEach(function(tablefield){\n                            __tableValues[tablefield.code] = formulaTableValues.getEach(tablefield.code);\n                        });\n                        __values = Form_formula.mixin(__values, __tableValues);\n                    }\n                } else if (type == 'user'){\n                    __values[field.code] = Form_formula.handerUserObject(WorkflowManager.getFormulaUserObjects(spaceId, autoFormDoc[field.code]));\n\n                } else if (type == 'group'){\n                    __values[field.code] = Form_formula.handerOrgObject(WorkflowManager.getFormulaOrgObjects(autoFormDoc[field.code]));\n\n                } else if (type == 'odata'){\n\t\t\t\t\t__values[field.code] = autoFormDoc[field.code] || {}\n\n\t\t\t\t} else {\n                    //此处传spaceId给选人控件的旧数据计算roles和organization\n                    __values[field.code] = autoFormDoc[field.code];\n                }\n            }\n        }, this);\n    }\n    //当前处理人\n    __values[\"approver\"] = WorkflowManager.getFormulaUserObject(spaceId, approver);\n    //申请人\n    __values[\"applicant\"] = WorkflowManager.getFormulaUserObject(spaceId, applicant);\n\n    return __values;\n};\n\n","Meteor.publish 'categories', (spaceId) ->\n\tcheck spaceId, String\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\n\treturn db.categories.find({ space: spaceId }, { fields: { name: 1, space: 1, sort_no: 1, app: 1 } })","Meteor.publish('categories', function(spaceId) {\n  check(spaceId, String);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.categories.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      space: 1,\n      sort_no: 1,\n      app: 1\n    }\n  });\n});\n","\nMeteor.publish 'cfs_instances', (instanceIds)->\n\tcheck(instanceIds, Array)\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless instanceIds\n\t\t\treturn this.ready()\n\n\treturn cfs.instances.find({'metadata.instance': {$in: instanceIds} , $or: [{'metadata.is_private': {$ne: true}},{'metadata.is_private': true, \"metadata.owner\": this.userId}]})\n","Meteor.publish('cfs_instances', function(instanceIds) {\n  check(instanceIds, Array);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instanceIds) {\n    return this.ready();\n  }\n  return cfs.instances.find({\n    'metadata.instance': {\n      $in: instanceIds\n    },\n    $or: [\n      {\n        'metadata.is_private': {\n          $ne: true\n        }\n      }, {\n        'metadata.is_private': true,\n        \"metadata.owner\": this.userId\n      }\n    ]\n  });\n});\n","\n\nMeteor.publish 'flow_positions', (spaceId)->\n\t\n\tunless this.userId\n\t\treturn this.ready()\n\t\n\tunless spaceId\n\t\treturn this.ready()\n\n\treturn db.flow_positions.find({space: spaceId}, {fields: {role:1, users: 1, org: 1}});\n","Meteor.publish('flow_positions', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.flow_positions.find({\n    space: spaceId\n  }, {\n    fields: {\n      role: 1,\n      users: 1,\n      org: 1\n    }\n  });\n});\n","Meteor.publishComposite 'flow_positions_tabular', (tableName, ids, fields)->\n\tcheck(tableName, String);\n\tcheck(ids, Array);\n\tcheck(fields, Match.Optional(Object));\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tthis.unblock()\n\n\tfind: ->\n\t\tthis.unblock()\n\t\tdb.flow_positions.find {_id: {$in: ids}}, fields: fields\n\n\tchildren: [\n\t\t{\n\t\t\tfind: (position) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related flow_roles\n\t\t\t\tdb.flow_roles.find { _id: position.role }, fields: name: 1\n\t\t}\n\t\t{\n\t\t\tfind: (position) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related organizations\n\t\t\t\tdb.organizations.find { _id: position.org }, fields: fullname: 1\n\t\t}\n\t\t{\n\t\t\tfind: (position) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.space_users.find {\n\t\t\t\t\tspace: position.space\n\t\t\t\t\tuser: $in: position.users\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\tuser: 1\n\t\t\t\t\tname: 1\n\t\t}\n\t]","Meteor.publishComposite('flow_positions_tabular', function(tableName, ids, fields) {\n  check(tableName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  if (!this.userId) {\n    return this.ready();\n  }\n  this.unblock();\n  return {\n    find: function() {\n      this.unblock();\n      return db.flow_positions.find({\n        _id: {\n          $in: ids\n        }\n      }, {\n        fields: fields\n      });\n    },\n    children: [\n      {\n        find: function(position) {\n          this.unblock();\n          return db.flow_roles.find({\n            _id: position.role\n          }, {\n            fields: {\n              name: 1\n            }\n          });\n        }\n      }, {\n        find: function(position) {\n          this.unblock();\n          return db.organizations.find({\n            _id: position.org\n          }, {\n            fields: {\n              fullname: 1\n            }\n          });\n        }\n      }, {\n        find: function(position) {\n          this.unblock();\n          return db.space_users.find({\n            space: position.space,\n            user: {\n              $in: position.users\n            }\n          }, {\n            fields: {\n              space: 1,\n              user: 1,\n              name: 1\n            }\n          });\n        }\n      }\n    ]\n  };\n});\n","\n\n\tMeteor.publish 'flow_roles', (spaceId)->\n\t\t\n\t\tunless this.userId\n\t\t\treturn this.ready()\n\t\t\n\t\tunless spaceId\n\t\t\treturn this.ready()\n\n\n\t\treturn db.flow_roles.find({space: spaceId}, {fields: {name:1}});\n","Meteor.publish('flow_roles', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.flow_roles.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1\n    }\n  });\n});\n","Meteor.publish 'flows', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\t# 第一次订阅时初始化工作区\n\tif db.flows.find({space: spaceId}).count() == 0\n\t\tdb.spaces.createTemplateFormAndFlow(spaceId)\n\n\treturn db.flows.find({space: spaceId}, {\n\t\tfields: {\n\t\t\tname: 1,\n\t\t\tform: 1,\n\t\t\tstate: 1,\n\t\t\tperms: 1,\n\t\t\tspace: 1,\n\t\t\tcompany_id: 1,\n\t\t\tsort_no: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\n\nMeteor.publish 'instance_flow', (spaceId, flowId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\treturn db.flows.find({_id: flowId, space: spaceId}, {\n\t\tfields: {\n\t\t\tname: 1,\n\t\t\tform: 1,\n\t\t\tstate: 1,\n\t\t\tperms: 1,\n\t\t\tspace: 1,\n\t\t\tcompany_id: 1,\n\t\t\tsort_no: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\n\n\nMeteor.publish 'flow_version', (spaceId, flowId, versionId) ->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\tunless versionId\n\t\treturn this.ready()\n\n\n\tself = this;\n\n\tgetFlowVersion = (id , versionId)->\n\t\tflow = db.flows.findOne({_id : id});\n\t\tif flow\n\t\t\tflow_version = flow.current\n\t\t\tflow_version.latest = true\n\n\t\t\tif flow_version._id != versionId\n\t\t\t\tflow_version = flow.historys.findPropertyByPK(\"_id\", versionId)\n\t\t\t\tflow_version.latest = false\n\n\t\t\treturn flow_version\n\thandle = db.flows.find({_id: flowId}, {fields: {_id: 1, \"current.modified\": 1}}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tself.changed(\"flow_versions\", versionId, getFlowVersion(id, versionId));\n\t}\n\n\n\tself.added(\"flow_versions\", versionId, getFlowVersion(flowId, versionId));\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n\nMeteor.publish 'distribute_optional_flows', (flow_ids)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless flow_ids\n\t\treturn this.ready()\n\n\treturn db.flows.find({_id: {$in: flow_ids}}, {\n\t\tfields: {\n\t\t\tname: 1,\n\t\t\tform: 1,\n\t\t\tstate: 1,\n\t\t\tperms: 1,\n\t\t\tspace: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tdistribute_end_notification: 1,\n\t\t\tcompany_id: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\n\nMeteor.publish 'flow', (spaceId, flowId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\n\treturn db.flows.find({_id: flowId, space: spaceId}, {\n\t\tfields: {\n\t\t\tprint_template: 1,\n\t\t\tinstance_template: 1,\n\t\t\tevents: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tupload_after_being_distributed: 1,\n\t\t\tdistribute_end_notification: 1,\n\t\t\tcompany_id: 1,\n\t\t\tallow_select_step: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\nMeteor.publish 'flow_files', (spaceId, flowId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\treturn cfs.files.find({ 'metadata.space': spaceId, 'metadata.object_name': 'flows', 'metadata.record_id': flowId })\n\nMeteor.publishComposite 'flows_tabular', (tableName, ids, fields)->\n\tcheck(tableName, String);\n\tcheck(ids, Array);\n\tcheck(fields, Match.Optional(Object));\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tthis.unblock()\n\n\tfind: ->\n\t\tthis.unblock()\n\t\tdb.flows.find {_id: {$in: ids}}, fields: fields\n\n\tchildren: [\n\t\t{\n\t\t\tfind: (flow) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.space_users.find {\n\t\t\t\t\tspace: flow.space,\n\t\t\t\t\tuser: flow.current.modified_by\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\tuser: 1\n\t\t\t\t\tname: 1\n\t\t},\n\t\t{\n\t\t\tfind: (flow) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.forms.find {\n\t\t\t\t\tspace: flow.space,\n\t\t\t\t\t_id: flow.form\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\t_id: 1\n\t\t\t\t\tname: 1,\n\t\t\t\t\tcategory: 1\n\t\t},\n\t\t{\n\t\t\tfind: (flow) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.categories.find {\n\t\t\t\t\tspace: flow.space\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\t_id: 1\n\t\t\t\t\tname: 1\n\t\t}\n\t]","Meteor.publish('flows', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (db.flows.find({\n    space: spaceId\n  }).count() === 0) {\n    db.spaces.createTemplateFormAndFlow(spaceId);\n  }\n  return db.flows.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      form: 1,\n      state: 1,\n      perms: 1,\n      space: 1,\n      company_id: 1,\n      sort_no: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('instance_flow', function(spaceId, flowId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  return db.flows.find({\n    _id: flowId,\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      form: 1,\n      state: 1,\n      perms: 1,\n      space: 1,\n      company_id: 1,\n      sort_no: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('flow_version', function(spaceId, flowId, versionId) {\n  var getFlowVersion, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  if (!versionId) {\n    return this.ready();\n  }\n  self = this;\n  getFlowVersion = function(id, versionId) {\n    var flow, flow_version;\n    flow = db.flows.findOne({\n      _id: id\n    });\n    if (flow) {\n      flow_version = flow.current;\n      flow_version.latest = true;\n      if (flow_version._id !== versionId) {\n        flow_version = flow.historys.findPropertyByPK(\"_id\", versionId);\n        flow_version.latest = false;\n      }\n      return flow_version;\n    }\n  };\n  handle = db.flows.find({\n    _id: flowId\n  }, {\n    fields: {\n      _id: 1,\n      \"current.modified\": 1\n    }\n  }).observeChanges({\n    changed: function(id) {\n      return self.changed(\"flow_versions\", versionId, getFlowVersion(id, versionId));\n    }\n  });\n  self.added(\"flow_versions\", versionId, getFlowVersion(flowId, versionId));\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n\nMeteor.publish('distribute_optional_flows', function(flow_ids) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!flow_ids) {\n    return this.ready();\n  }\n  return db.flows.find({\n    _id: {\n      $in: flow_ids\n    }\n  }, {\n    fields: {\n      name: 1,\n      form: 1,\n      state: 1,\n      perms: 1,\n      space: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      distribute_end_notification: 1,\n      company_id: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('flow', function(spaceId, flowId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  return db.flows.find({\n    _id: flowId,\n    space: spaceId\n  }, {\n    fields: {\n      print_template: 1,\n      instance_template: 1,\n      events: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      upload_after_being_distributed: 1,\n      distribute_end_notification: 1,\n      company_id: 1,\n      allow_select_step: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('flow_files', function(spaceId, flowId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  return cfs.files.find({\n    'metadata.space': spaceId,\n    'metadata.object_name': 'flows',\n    'metadata.record_id': flowId\n  });\n});\n\nMeteor.publishComposite('flows_tabular', function(tableName, ids, fields) {\n  check(tableName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  if (!this.userId) {\n    return this.ready();\n  }\n  this.unblock();\n  return {\n    find: function() {\n      this.unblock();\n      return db.flows.find({\n        _id: {\n          $in: ids\n        }\n      }, {\n        fields: fields\n      });\n    },\n    children: [\n      {\n        find: function(flow) {\n          this.unblock();\n          return db.space_users.find({\n            space: flow.space,\n            user: flow.current.modified_by\n          }, {\n            fields: {\n              space: 1,\n              user: 1,\n              name: 1\n            }\n          });\n        }\n      }, {\n        find: function(flow) {\n          this.unblock();\n          return db.forms.find({\n            space: flow.space,\n            _id: flow.form\n          }, {\n            fields: {\n              space: 1,\n              _id: 1,\n              name: 1,\n              category: 1\n            }\n          });\n        }\n      }, {\n        find: function(flow) {\n          this.unblock();\n          return db.categories.find({\n            space: flow.space\n          }, {\n            fields: {\n              space: 1,\n              _id: 1,\n              name: 1\n            }\n          });\n        }\n      }\n    ]\n  };\n});\n","Meteor.publish 'forms', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\n\treturn db.forms.find({space: spaceId}, {fields: {name: 1, category: 1, state: 1, description: 1, instance_style: 1, amis_schema: 1}})\n\nMeteor.publish 'instance_form', (spaceId, formId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\n\treturn db.forms.find({_id: formId, space: spaceId}, {fields: {name: 1, category: 1, state: 1, description: 1, instance_style: 1, amis_schema: 1}})\n\n\nMeteor.publish 'form_version', (spaceId, formId, versionId) ->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless formId\n\t\treturn this.ready()\n\n\tunless versionId\n\t\treturn this.ready()\n\n\n\tself = this;\n\n\tgetFormVersion = (id , versionId)->\n\t\tform = db.forms.findOne({_id : id});\n\t\tif !form\n\t\t\treturn {}\n\t\tform_version = form.current\n\t\tform_version.latest = true\n\t\tif form_version._id != versionId\n\t\t\tform_version = form.historys.findPropertyByPK(\"_id\", versionId)\n\t\t\tform_version.latest = false\n\t\treturn form_version\n\n\thandle = db.forms.find({_id: formId}, {fields: {_id: 1, \"current.modified\": 1}}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tself.changed(\"form_versions\", versionId, getFormVersion(id, versionId));\n\t}\n\n\tself.added(\"form_versions\", versionId, getFormVersion(formId, versionId));\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()","Meteor.publish('forms', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.forms.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      category: 1,\n      state: 1,\n      description: 1,\n      instance_style: 1,\n      amis_schema: 1\n    }\n  });\n});\n\nMeteor.publish('instance_form', function(spaceId, formId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.forms.find({\n    _id: formId,\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      category: 1,\n      state: 1,\n      description: 1,\n      instance_style: 1,\n      amis_schema: 1\n    }\n  });\n});\n\nMeteor.publish('form_version', function(spaceId, formId, versionId) {\n  var getFormVersion, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!formId) {\n    return this.ready();\n  }\n  if (!versionId) {\n    return this.ready();\n  }\n  self = this;\n  getFormVersion = function(id, versionId) {\n    var form, form_version;\n    form = db.forms.findOne({\n      _id: id\n    });\n    if (!form) {\n      return {};\n    }\n    form_version = form.current;\n    form_version.latest = true;\n    if (form_version._id !== versionId) {\n      form_version = form.historys.findPropertyByPK(\"_id\", versionId);\n      form_version.latest = false;\n    }\n    return form_version;\n  };\n  handle = db.forms.find({\n    _id: formId\n  }, {\n    fields: {\n      _id: 1,\n      \"current.modified\": 1\n    }\n  }).observeChanges({\n    changed: function(id) {\n      return self.changed(\"form_versions\", versionId, getFormVersion(id, versionId));\n    }\n  });\n  self.added(\"form_versions\", versionId, getFormVersion(formId, versionId));\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n","Meteor.publish 'instance_data', (instanceId, box)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless (instanceId && db.instances.find({_id: instanceId}).count())\n\t\treturn this.ready()\n\n\tself = this;\n\n\tminiApproveFields = ['_id', 'is_finished', 'user', 'handler', 'handler_name', 'type', 'start_date', 'description',\n\t\t'is_read', 'judge', 'finish_date', 'from_user_name', 'from_user', 'cc_description', 'auto_submitted']\n\n\ttriggerChangeFields = ['form_version', 'flow_version', 'related_instances', '_my_approve_read_dates', 'values', 'change_time']\n\n\ttriggerChangeFieldsValues = {}\n\n\tinstance_fields_0 = {\n\t\t\"record_synced\": 0,\n\n#\t\t\"traces.approves.handler_organization_fullname\": 0,\n\t\t\"traces.approves.handler_organization_name\": 0,\n\t\t\"traces.approves.handler_organization\": 0,\n\t\t\"traces.approves.cost_time\": 0,\n#\t\t\"traces.approves.read_date\": 0,\n\t\t\"traces.approves.is_error\": 0,\n\t\t# \"traces.approves.user_name\": 0,\n\t\t\"traces.approves.deadline\": 0,\n\t\t\"traces.approves.remind_date\": 0,\n\t\t\"traces.approves.reminded_count\": 0,\n\t\t\"traces.approves.modified_by\": 0,\n\t\t\"traces.approves.modified\": 0,\n\t\t\"traces.approves.geolocation\": 0,\n\t\t\"traces.approves.cc_users\": 0,\n\t\t\"traces.approves.from_approve_id\": 0,\n\t\t\"traces.approves.values_history\": 0\n\t}\n\n\tgetMyapproveModified = (traces)->\n\t\tmyApproveModifieds = new Array()\n\n\t\ttraces?.forEach (trace)->\n\t\t\ttrace?.approves?.forEach (approve)->\n\t\t\t\tif (approve.user == self.userId || approve.handler == self.userId)\n\t\t\t\t# && !approve.is_finished\n#\t\t\t\t\tconsole.log(\"approve\", approve._id, approve.read_date)\n\n\t\t\t\t\tmyApproveModifieds.push(approve.read_date)\n\n\t\treturn myApproveModifieds\n\n\n\tgetMiniInstance = (_instanceId)->\n\t\tinstance = db.instances.findOne({_id: _instanceId}, {fields: instance_fields_0})\n\n\t\tif instance\n\n\t\t\ttriggerChangeFields.forEach (key)->\n\t\t\t\tif key == '_my_approve_read_dates'\n\t\t\t\t\ttriggerChangeFieldsValues[key] = getMyapproveModified(instance.traces)\n\t\t\t\telse\n\t\t\t\t\ttriggerChangeFieldsValues[key] = instance[key]\n\n#\t\t\thasOpinionField = InstanceSignText.includesOpinionField(instance.form, instance.form_version)\n\n\t\t\tshow_modal_traces_list = db.space_settings.findOne({ space: instance.space, key: \"show_modal_traces_list\" }, { fields: { values: 1 } })?.values || false\n\n\t\t\tif show_modal_traces_list\n\n\t\t\t\ttraces = new Array();\n\n\t\t\t\tinstance?.traces?.forEach (trace)->\n\t\t\t\t\t_trace = _.clone(trace)\n\n\t\t\t\t\tapproves = new Array()\n\n\t\t\t\t\ttrace?.approves?.forEach (approve)->\n\t\t\t\t\t\tif approve.type != 'cc' || approve.user == self.userId || approve.handler == self.userId || (!_.isEmpty(approve.sign_field_code))\n\t\t\t\t\t\t\tapproves.push(approve)\n\n\t\t\t\t\t_trace.approves = approves\n\n\t\t\t\t\ttraces.push(_trace)\n\n\t\t\t\tinstance.traces = traces;\n\n\t\treturn instance\n\n\n\tneedChange = (changeFields)->\n\t\tif changeFields\n\n\t\t\t_change = false\n\n\t\t\t_rev = _.find triggerChangeFields, (key)->\n\t\t\t\t_key = key\n\n\t\t\t\tif key == '_my_approve_read_dates'\n\t\t\t\t\t_key = 'traces'\n\n\t\t\t\tif _.has(changeFields, _key)\n\n\t\t\t\t\tif key == '_my_approve_read_dates'\n\n\t\t\t\t\t\t_my_approve_modifieds = getMyapproveModified(changeFields.traces)\n\n#\t\t\t\t\t\tconsole.log(triggerChangeFieldsValues[key], _my_approve_modifieds)\n\n\t\t\t\t\t\treturn !_.isEqual(triggerChangeFieldsValues[key], _my_approve_modifieds)\n\t\t\t\t\telse\n\t\t\t\t\t\treturn !_.isEqual(triggerChangeFieldsValues[key], changeFields[key])\n\n\t\t\tif _rev\n\t\t\t\t_change = true\n\n#\t\t\tconsole.log(_rev, _change)\n\n\t\t\treturn _change\n\n\t\treturn true\n\t#此处不能添加fields限制，否则会导致数据不实时\n\thandle = db.instances.find({_id: instanceId}).observeChanges {\n\t\tchanged: (id, fields)->\n\t\t\tif(box != 'inbox' || needChange(fields))\n\t\t\t\tself.changed(\"instances\", id, getMiniInstance(id));\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tinstance = getMiniInstance(instanceId)\n\n\tself.added(\"instances\", instance?._id, instance);\n\n\tself.ready();\n\n\tself.onStop ()->\n\t\thandle.stop()\n\n\nMeteor.publish 'instance_traces', (instanceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless instanceId\n\t\treturn this.ready()\n\n\tself = this\n\n\tgetInstanceTraces = (_insId)->\n\t\treturn db.instances.findOne({_id: _insId}, {fields: {_id: 1, traces: 1}})\n\n\n\thandle =  db.instances.find({_id: instanceId}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tself.changed(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n\t}\n\n\tself.added(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()","Meteor.publish('instance_data', function(instanceId, box) {\n  var getMiniInstance, getMyapproveModified, handle, instance, instance_fields_0, miniApproveFields, needChange, self, triggerChangeFields, triggerChangeFieldsValues;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!(instanceId && db.instances.find({\n    _id: instanceId\n  }).count())) {\n    return this.ready();\n  }\n  self = this;\n  miniApproveFields = ['_id', 'is_finished', 'user', 'handler', 'handler_name', 'type', 'start_date', 'description', 'is_read', 'judge', 'finish_date', 'from_user_name', 'from_user', 'cc_description', 'auto_submitted'];\n  triggerChangeFields = ['form_version', 'flow_version', 'related_instances', '_my_approve_read_dates', 'values', 'change_time'];\n  triggerChangeFieldsValues = {};\n  instance_fields_0 = {\n    \"record_synced\": 0,\n    \"traces.approves.handler_organization_name\": 0,\n    \"traces.approves.handler_organization\": 0,\n    \"traces.approves.cost_time\": 0,\n    \"traces.approves.is_error\": 0,\n    \"traces.approves.deadline\": 0,\n    \"traces.approves.remind_date\": 0,\n    \"traces.approves.reminded_count\": 0,\n    \"traces.approves.modified_by\": 0,\n    \"traces.approves.modified\": 0,\n    \"traces.approves.geolocation\": 0,\n    \"traces.approves.cc_users\": 0,\n    \"traces.approves.from_approve_id\": 0,\n    \"traces.approves.values_history\": 0\n  };\n  getMyapproveModified = function(traces) {\n    var myApproveModifieds;\n    myApproveModifieds = new Array();\n    if (traces != null) {\n      traces.forEach(function(trace) {\n        var ref;\n        return trace != null ? (ref = trace.approves) != null ? ref.forEach(function(approve) {\n          if (approve.user === self.userId || approve.handler === self.userId) {\n            return myApproveModifieds.push(approve.read_date);\n          }\n        }) : void 0 : void 0;\n      });\n    }\n    return myApproveModifieds;\n  };\n  getMiniInstance = function(_instanceId) {\n    var instance, ref, ref1, show_modal_traces_list, traces;\n    instance = db.instances.findOne({\n      _id: _instanceId\n    }, {\n      fields: instance_fields_0\n    });\n    if (instance) {\n      triggerChangeFields.forEach(function(key) {\n        if (key === '_my_approve_read_dates') {\n          return triggerChangeFieldsValues[key] = getMyapproveModified(instance.traces);\n        } else {\n          return triggerChangeFieldsValues[key] = instance[key];\n        }\n      });\n      show_modal_traces_list = ((ref = db.space_settings.findOne({\n        space: instance.space,\n        key: \"show_modal_traces_list\"\n      }, {\n        fields: {\n          values: 1\n        }\n      })) != null ? ref.values : void 0) || false;\n      if (show_modal_traces_list) {\n        traces = new Array();\n        if (instance != null) {\n          if ((ref1 = instance.traces) != null) {\n            ref1.forEach(function(trace) {\n              var _trace, approves, ref2;\n              _trace = _.clone(trace);\n              approves = new Array();\n              if (trace != null) {\n                if ((ref2 = trace.approves) != null) {\n                  ref2.forEach(function(approve) {\n                    if (approve.type !== 'cc' || approve.user === self.userId || approve.handler === self.userId || (!_.isEmpty(approve.sign_field_code))) {\n                      return approves.push(approve);\n                    }\n                  });\n                }\n              }\n              _trace.approves = approves;\n              return traces.push(_trace);\n            });\n          }\n        }\n        instance.traces = traces;\n      }\n    }\n    return instance;\n  };\n  needChange = function(changeFields) {\n    var _change, _rev;\n    if (changeFields) {\n      _change = false;\n      _rev = _.find(triggerChangeFields, function(key) {\n        var _key, _my_approve_modifieds;\n        _key = key;\n        if (key === '_my_approve_read_dates') {\n          _key = 'traces';\n        }\n        if (_.has(changeFields, _key)) {\n          if (key === '_my_approve_read_dates') {\n            _my_approve_modifieds = getMyapproveModified(changeFields.traces);\n            return !_.isEqual(triggerChangeFieldsValues[key], _my_approve_modifieds);\n          } else {\n            return !_.isEqual(triggerChangeFieldsValues[key], changeFields[key]);\n          }\n        }\n      });\n      if (_rev) {\n        _change = true;\n      }\n      return _change;\n    }\n    return true;\n  };\n  handle = db.instances.find({\n    _id: instanceId\n  }).observeChanges({\n    changed: function(id, fields) {\n      if (box !== 'inbox' || needChange(fields)) {\n        return self.changed(\"instances\", id, getMiniInstance(id));\n      }\n    },\n    removed: function(id) {\n      return self.removed(\"instances\", id);\n    }\n  });\n  instance = getMiniInstance(instanceId);\n  self.added(\"instances\", instance != null ? instance._id : void 0, instance);\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n\nMeteor.publish('instance_traces', function(instanceId) {\n  var getInstanceTraces, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instanceId) {\n    return this.ready();\n  }\n  self = this;\n  getInstanceTraces = function(_insId) {\n    return db.instances.findOne({\n      _id: _insId\n    }, {\n      fields: {\n        _id: 1,\n        traces: 1\n      }\n    });\n  };\n  handle = db.instances.find({\n    _id: instanceId\n  }).observeChanges({\n    changed: function(id) {\n      return self.changed(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n    }\n  });\n  self.added(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n","\n\tMeteor.publish 'instances_list', (spaceId, box, flowId)->\n\n\t\tunless this.userId\n\t\t\treturn this.ready()\n\t\t\n\t\tunless spaceId\n\t\t\treturn this.ready()\n\n\t\tquery = {space: spaceId}\n\t\tif box == \"inbox\"\n\t\t\tquery.inbox_users = this.userId;\n\t\telse if box == \"outbox\"\n\t\t\tquery.outbox_users = this.userId;\n\t\telse if box == \"draft\"\n\t\t\tquery.submitter = this.userId;\n\t\t\tquery.state = \"draft\"\n\t\telse if box == \"pending\"\n\t\t\tquery.submitter = this.userId;\n\t\t\tquery.state = \"pending\"\n\t\telse if box == \"completed\"\n\t\t\tquery.submitter = this.userId;\n\t\t\tquery.state = \"completed\"\n\t\telse if box == \"monitor\"\n\t\t\tquery.flow = flowId;\n\t\t\tquery.state = {$in: [\"pending\",\"completed\"]};\n\t\telse\n\t\t\tquery.state = \"none\"\n\n\t\treturn db.instances.find(query, {fields: {name:1, created:1, form:1, flow: 1, space:1, modified:1, applicant: 1, is_archived:1, form_version: 1, flow_version: 1}})\n\n","Meteor.publish('instances_list', function(spaceId, box, flowId) {\n  var query;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  query = {\n    space: spaceId\n  };\n  if (box === \"inbox\") {\n    query.inbox_users = this.userId;\n  } else if (box === \"outbox\") {\n    query.outbox_users = this.userId;\n  } else if (box === \"draft\") {\n    query.submitter = this.userId;\n    query.state = \"draft\";\n  } else if (box === \"pending\") {\n    query.submitter = this.userId;\n    query.state = \"pending\";\n  } else if (box === \"completed\") {\n    query.submitter = this.userId;\n    query.state = \"completed\";\n  } else if (box === \"monitor\") {\n    query.flow = flowId;\n    query.state = {\n      $in: [\"pending\", \"completed\"]\n    };\n  } else {\n    query.state = \"none\";\n  }\n  return db.instances.find(query, {\n    fields: {\n      name: 1,\n      created: 1,\n      form: 1,\n      flow: 1,\n      space: 1,\n      modified: 1,\n      applicant: 1,\n      is_archived: 1,\n      form_version: 1,\n      flow_version: 1\n    }\n  });\n});\n","lastFinishedApproveAggregate = (instanceid, userId, dataMap, callback)->\n\toperation = [{\n\t\t\"$match\": {\n\t\t\t\"_id\": instanceid\n\t\t}\n\t}, {\"$project\": {\"name\": 1, \"_approve\": \"$traces.approves\"}}, {\"$unwind\": \"$_approve\"}, {\"$unwind\": \"$_approve\"},\n\t\t{\"$match\": {\"_approve.is_finished\": true, $or:[{\"_approve.handler\": userId},{\"_approve.user\": userId}]}},\n\t\t{\"$group\": {\"_id\": \"$_id\", \"finish_date\": {\"$last\": \"$_approve.finish_date\"}}}\n\t]\n\n\tdb.instances.rawCollection().aggregate(operation).toArray (err, data)->\n\t\tif err\n\t\t\tthrow new Error(err)\n\n\t\tdata.forEach (doc) ->\n\t\t\tdataMap.push doc\n\n\t\tif callback && _.isFunction(callback)\n\t\t\tcallback()\n\t\treturn\n\nasyncLastFinishedApprove = Meteor.wrapAsync(lastFinishedApproveAggregate)\n\nMeteor.publish \"instance_tabular\", (tableName, ids, fields)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tcheck(tableName, String);\n\n\tcheck(ids, Array);\n\n\tcheck(fields, Match.Optional(Object))\n\n\tfields.cc_users = 1\n\n\tself = this;\n\n\tgetMyLastFinishedApprove = (userId, instanceId)->\n\t\tdata = []\n\t\tasyncLastFinishedApprove(instanceId, userId, data)\n\t\tif data.length > 0\n\t\t\treturn data[0]\n\n\n\tgetMyApprove = (userId, instanceId)->\n\t\tinstance = db.instances.findOne({_id: instanceId}, {fields: {traces: 1}})\n\t\tmyApprove = null\n\n\t\tif !instance\n\t\t\treturn\n\n\t\tif !instance.traces || instance.traces.length < 1\n\t\t\treturn\n\n\t\tnotFinishedTraces = instance.traces.filterProperty(\"is_finished\", false)\n\n\t\tif notFinishedTraces.length > 0\n\t\t\tapproves = notFinishedTraces[0].approves.filterProperty(\"is_finished\", false).filterProperty(\"handler\", userId);\n\n\t\t\tif approves.length > 0\n\t\t\t\tapprove = approves[0]\n\t\t\t\tmyApprove = {\n\t\t\t\t\tid: approve._id,\n\t\t\t\t\tinstance: approve.instance,\n\t\t\t\t\ttrace: approve.trace,\n\t\t\t\t\tis_read: approve.is_read,\n\t\t\t\t\tstart_date: approve.start_date\n\t\t\t\t\tagent: approve.agent\n\t\t\t\t\tuser_name: approve.user_name\n\t\t\t\t}\n\n\t\tif !myApprove\n\t\t\tis_read = false\n\t\t\tinstance.traces.forEach (trace) ->\n\t\t\t\ttrace?.approves?.forEach (approve) ->\n\t\t\t\t\tif approve.type == 'cc' and approve.user == userId and approve.is_finished == false\n\t\t\t\t\t\tif approve.is_read\n\t\t\t\t\t\t\tis_read = true\n\t\t\t\t\t\tmyApprove = {id: approve._id, is_read: is_read, start_date: approve.start_date, agent: approve.agent, user_name: approve.user_name}\n\n\t\treturn myApprove\n\n\tgetStepCurrentName = (instanceId) ->\n\t\tinstance = db.instances.findOne({_id: instanceId}, {fields: {\"traces.name\": 1, \"traces\": {$slice: -1}}})\n\t\tif instance\n\t\t\tstepCurrentName = instance.traces?[0]?.name\n\n\t\treturn stepCurrentName\n\n\thandle = db.instances.find({_id: {$in: ids}}, {fields: {traces: 0}}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tmyApprove = getMyApprove(self.userId, id)\n\t\t\tmyLastFinishedApprove = getMyLastFinishedApprove(self.userId, id)\n\t\t\tif myApprove\n\t\t\t\tinstance.is_read = myApprove.is_read\n\t\t\t\tinstance.start_date = myApprove.start_date\n\t\t\t\tif myApprove.agent\n\t\t\t\t\tinstance.agent_user_name = myApprove.user_name\n\t\t\telse\n\t\t\t\tinstance.is_read = true\n\n\t\t\tif myLastFinishedApprove\n\t\t\t\tinstance.my_finish_date = myLastFinishedApprove.finish_date\n\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tinstance.cc_count = instance.cc_users?.length || 0\n\t\t\tdelete instance.cc_users\n\t\t\ttry\n\t\t\t\tself.changed(\"instances\", id, instance);\n\t\t\tcatch error\n\t\t\t\tconsole.log('instance observeChanges error: ', error.message);\n\t\t\t\tconsole.log('self.userId: ', self.userId);\n\t\t\t\tconsole.log('tableName: ', tableName);\n\t\t\t\tconsole.log('ids: ', JSON.stringify(ids));\n\t\t\t\tconsole.log('myApprove: ', JSON.stringify(myApprove));\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tids.forEach (id)->\n\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\treturn if not instance\n\t\tmyApprove = getMyApprove(self.userId, id)\n\t\tmyLastFinishedApprove = getMyLastFinishedApprove(self.userId, id)\n\t\tif myApprove\n\t\t\tinstance.is_read = myApprove.is_read\n\t\t\tinstance.start_date = myApprove.start_date\n\t\t\tif myApprove.agent\n\t\t\t\t\tinstance.agent_user_name = myApprove.user_name\n\t\telse\n\t\t\tinstance.is_read = true\n\n\t\tif myLastFinishedApprove\n\t\t\tinstance.my_finish_date = myLastFinishedApprove.finish_date\n\n\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\tinstance.cc_count = instance.cc_users?.length || 0\n\t\tdelete instance.cc_users\n\t\tself.added(\"instances\", id, instance);\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n\nMeteor.publish \"instance_tasks_tabular\", (tabularName, ids, fields)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tcheck(tabularName, String);\n\n\tcheck(ids, Array);\n\n\tcheck(fields, Match.Optional(Object))\n\n\t# console.log('tabularName: ', tabularName);\n\t# console.log('ids: ', JSON.stringify(ids));\n\t# console.log('fields: ', JSON.stringify(fields));\n\n\tdb.instance_tasks.find({\n\t\t_id: {\n\t\t\t$in: ids\n\t\t}\n\t}, {\n\t\tfields: fields\n\t})\n\nMeteor.publish \"instances_tabular\", (tabularName, ids, fields)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tcheck(tabularName, String);\n\n\tcheck(ids, Array);\n\n\tcheck(fields, Match.Optional(Object))\n\n\t# console.log('tabularName: ', tabularName);\n\t# console.log('ids: ', JSON.stringify(ids));\n\t# console.log('fields: ', JSON.stringify(fields));\n\n\tdb.instances.find({\n\t\t_id: {\n\t\t\t$in: ids\n\t\t}\n\t}, {\n\t\tfields: fields\n\t})","var asyncLastFinishedApprove, lastFinishedApproveAggregate;\n\nlastFinishedApproveAggregate = function(instanceid, userId, dataMap, callback) {\n  var operation;\n  operation = [\n    {\n      \"$match\": {\n        \"_id\": instanceid\n      }\n    }, {\n      \"$project\": {\n        \"name\": 1,\n        \"_approve\": \"$traces.approves\"\n      }\n    }, {\n      \"$unwind\": \"$_approve\"\n    }, {\n      \"$unwind\": \"$_approve\"\n    }, {\n      \"$match\": {\n        \"_approve.is_finished\": true,\n        $or: [\n          {\n            \"_approve.handler\": userId\n          }, {\n            \"_approve.user\": userId\n          }\n        ]\n      }\n    }, {\n      \"$group\": {\n        \"_id\": \"$_id\",\n        \"finish_date\": {\n          \"$last\": \"$_approve.finish_date\"\n        }\n      }\n    }\n  ];\n  return db.instances.rawCollection().aggregate(operation).toArray(function(err, data) {\n    if (err) {\n      throw new Error(err);\n    }\n    data.forEach(function(doc) {\n      return dataMap.push(doc);\n    });\n    if (callback && _.isFunction(callback)) {\n      callback();\n    }\n  });\n};\n\nasyncLastFinishedApprove = Meteor.wrapAsync(lastFinishedApproveAggregate);\n\nMeteor.publish(\"instance_tabular\", function(tableName, ids, fields) {\n  var getMyApprove, getMyLastFinishedApprove, getStepCurrentName, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  check(tableName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  fields.cc_users = 1;\n  self = this;\n  getMyLastFinishedApprove = function(userId, instanceId) {\n    var data;\n    data = [];\n    asyncLastFinishedApprove(instanceId, userId, data);\n    if (data.length > 0) {\n      return data[0];\n    }\n  };\n  getMyApprove = function(userId, instanceId) {\n    var approve, approves, instance, is_read, myApprove, notFinishedTraces;\n    instance = db.instances.findOne({\n      _id: instanceId\n    }, {\n      fields: {\n        traces: 1\n      }\n    });\n    myApprove = null;\n    if (!instance) {\n      return;\n    }\n    if (!instance.traces || instance.traces.length < 1) {\n      return;\n    }\n    notFinishedTraces = instance.traces.filterProperty(\"is_finished\", false);\n    if (notFinishedTraces.length > 0) {\n      approves = notFinishedTraces[0].approves.filterProperty(\"is_finished\", false).filterProperty(\"handler\", userId);\n      if (approves.length > 0) {\n        approve = approves[0];\n        myApprove = {\n          id: approve._id,\n          instance: approve.instance,\n          trace: approve.trace,\n          is_read: approve.is_read,\n          start_date: approve.start_date,\n          agent: approve.agent,\n          user_name: approve.user_name\n        };\n      }\n    }\n    if (!myApprove) {\n      is_read = false;\n      instance.traces.forEach(function(trace) {\n        var ref;\n        return trace != null ? (ref = trace.approves) != null ? ref.forEach(function(approve) {\n          if (approve.type === 'cc' && approve.user === userId && approve.is_finished === false) {\n            if (approve.is_read) {\n              is_read = true;\n            }\n            return myApprove = {\n              id: approve._id,\n              is_read: is_read,\n              start_date: approve.start_date,\n              agent: approve.agent,\n              user_name: approve.user_name\n            };\n          }\n        }) : void 0 : void 0;\n      });\n    }\n    return myApprove;\n  };\n  getStepCurrentName = function(instanceId) {\n    var instance, ref, ref1, stepCurrentName;\n    instance = db.instances.findOne({\n      _id: instanceId\n    }, {\n      fields: {\n        \"traces.name\": 1,\n        \"traces\": {\n          $slice: -1\n        }\n      }\n    });\n    if (instance) {\n      stepCurrentName = (ref = instance.traces) != null ? (ref1 = ref[0]) != null ? ref1.name : void 0 : void 0;\n    }\n    return stepCurrentName;\n  };\n  handle = db.instances.find({\n    _id: {\n      $in: ids\n    }\n  }, {\n    fields: {\n      traces: 0\n    }\n  }).observeChanges({\n    changed: function(id) {\n      var error, instance, myApprove, myLastFinishedApprove, ref, ref1;\n      instance = db.instances.findOne({\n        _id: id\n      }, {\n        fields: fields\n      });\n      if (!instance) {\n        return;\n      }\n      myApprove = getMyApprove(self.userId, id);\n      myLastFinishedApprove = getMyLastFinishedApprove(self.userId, id);\n      if (myApprove) {\n        instance.is_read = myApprove.is_read;\n        instance.start_date = myApprove.start_date;\n        if (myApprove.agent) {\n          instance.agent_user_name = myApprove.user_name;\n        }\n      } else {\n        instance.is_read = true;\n      }\n      if (myLastFinishedApprove) {\n        instance.my_finish_date = myLastFinishedApprove.finish_date;\n      }\n      instance.is_cc = ((ref = instance.cc_users) != null ? ref.includes(self.userId) : void 0) || false;\n      instance.cc_count = ((ref1 = instance.cc_users) != null ? ref1.length : void 0) || 0;\n      delete instance.cc_users;\n      try {\n        return self.changed(\"instances\", id, instance);\n      } catch (error1) {\n        error = error1;\n        console.log('instance observeChanges error: ', error.message);\n        console.log('self.userId: ', self.userId);\n        console.log('tableName: ', tableName);\n        console.log('ids: ', JSON.stringify(ids));\n        return console.log('myApprove: ', JSON.stringify(myApprove));\n      }\n    },\n    removed: function(id) {\n      return self.removed(\"instances\", id);\n    }\n  });\n  ids.forEach(function(id) {\n    var instance, myApprove, myLastFinishedApprove, ref, ref1;\n    instance = db.instances.findOne({\n      _id: id\n    }, {\n      fields: fields\n    });\n    if (!instance) {\n      return;\n    }\n    myApprove = getMyApprove(self.userId, id);\n    myLastFinishedApprove = getMyLastFinishedApprove(self.userId, id);\n    if (myApprove) {\n      instance.is_read = myApprove.is_read;\n      instance.start_date = myApprove.start_date;\n      if (myApprove.agent) {\n        instance.agent_user_name = myApprove.user_name;\n      }\n    } else {\n      instance.is_read = true;\n    }\n    if (myLastFinishedApprove) {\n      instance.my_finish_date = myLastFinishedApprove.finish_date;\n    }\n    instance.is_cc = ((ref = instance.cc_users) != null ? ref.includes(self.userId) : void 0) || false;\n    instance.cc_count = ((ref1 = instance.cc_users) != null ? ref1.length : void 0) || 0;\n    delete instance.cc_users;\n    return self.added(\"instances\", id, instance);\n  });\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n\nMeteor.publish(\"instance_tasks_tabular\", function(tabularName, ids, fields) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  check(tabularName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  return db.instance_tasks.find({\n    _id: {\n      $in: ids\n    }\n  }, {\n    fields: fields\n  });\n});\n\nMeteor.publish(\"instances_tabular\", function(tabularName, ids, fields) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  check(tabularName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  return db.instances.find({\n    _id: {\n      $in: ids\n    }\n  }, {\n    fields: fields\n  });\n});\n","Meteor.publish 'instances_draft', (spaceId) ->\n\tcheck spaceId, String\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tuserId = this.userId\n\treturn db.instances.find({state:\"draft\",space:spaceId,submitter:userId,$or:[{inbox_users: {$exists:false}}, {inbox_users: []}]}, {fields: {_id: 1, state: 1, space: 1, submitter: 1, inbox_users: 1, modified: 1, name: 1}, sort:{modified: -1}})","Meteor.publish('instances_draft', function(spaceId) {\n  var userId;\n  check(spaceId, String);\n  if (!this.userId) {\n    return this.ready();\n  }\n  userId = this.userId;\n  return db.instances.find({\n    state: \"draft\",\n    space: spaceId,\n    submitter: userId,\n    $or: [\n      {\n        inbox_users: {\n          $exists: false\n        }\n      }, {\n        inbox_users: []\n      }\n    ]\n  }, {\n    fields: {\n      _id: 1,\n      state: 1,\n      space: 1,\n      submitter: 1,\n      inbox_users: 1,\n      modified: 1,\n      name: 1\n    },\n    sort: {\n      modified: -1\n    }\n  });\n});\n","Meteor.publish 'distributed_instances_state_by_ids', (instance_ids)->\n\tcheck(instance_ids, Array)\n\n\tunless this.userId\n\t\treturn this.ready()\n\t\n\tunless instance_ids\n\t\treturn this.ready()\n\n\tif _.isEmpty(instance_ids)\n\t\treturn this.ready()\n\n\tself = this\n\n\thandle = db.instances.find({_id: {$in: instance_ids}}, {fields: {state: 1, traces:{$slice: 1} } }).observeChanges {\n\t\tadded: (id, fields)->\n\t\t\tself.added('instances', id, {state: fields.state, is_read: fields.traces[0].approves[0].is_read})\n\n\t\tchanged: (id, fields)->\n\t\t\tif fields.state\n\t\t\t\tself.changed('instances', id, {state: fields.state})\n\t\t\tif fields.traces\n\t\t\t\tself.changed('instances', id, {is_read: fields.traces[0].approves[0].is_read})\n\t}\n\n\tthis.ready()\n\tthis.onStop ()->\n\t\thandle.stop()\n","Meteor.publish('distributed_instances_state_by_ids', function(instance_ids) {\n  var handle, self;\n  check(instance_ids, Array);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instance_ids) {\n    return this.ready();\n  }\n  if (_.isEmpty(instance_ids)) {\n    return this.ready();\n  }\n  self = this;\n  handle = db.instances.find({\n    _id: {\n      $in: instance_ids\n    }\n  }, {\n    fields: {\n      state: 1,\n      traces: {\n        $slice: 1\n      }\n    }\n  }).observeChanges({\n    added: function(id, fields) {\n      return self.added('instances', id, {\n        state: fields.state,\n        is_read: fields.traces[0].approves[0].is_read\n      });\n    },\n    changed: function(id, fields) {\n      if (fields.state) {\n        self.changed('instances', id, {\n          state: fields.state\n        });\n      }\n      if (fields.traces) {\n        return self.changed('instances', id, {\n          is_read: fields.traces[0].approves[0].is_read\n        });\n      }\n    }\n  });\n  this.ready();\n  return this.onStop(function() {\n    return handle.stop();\n  });\n});\n","Meteor.publish 'related_instaces', (instanceId, related_instances)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless instanceId\n\t\treturn this.ready()\n\n\trelated_instance_ids = db.instances.findOne(instanceId,{fields: {related_instances: 1}})?.related_instances\n\n\tif related_instance_ids && _.isArray(related_instance_ids)\n\t\treturn db.instances.find({_id: {$in : related_instance_ids}}, {fields: {_id: 1, name: 1, space: 1}})\n\telse\n\t\treturn this.ready()","Meteor.publish('related_instaces', function(instanceId, related_instances) {\n  var ref, related_instance_ids;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instanceId) {\n    return this.ready();\n  }\n  related_instance_ids = (ref = db.instances.findOne(instanceId, {\n    fields: {\n      related_instances: 1\n    }\n  })) != null ? ref.related_instances : void 0;\n  if (related_instance_ids && _.isArray(related_instance_ids)) {\n    return db.instances.find({\n      _id: {\n        $in: related_instance_ids\n      }\n    }, {\n      fields: {\n        _id: 1,\n        name: 1,\n        space: 1\n      }\n    });\n  } else {\n    return this.ready();\n  }\n});\n","if Meteor.isServer\n    Meteor.publish 'space_user_signs', (spaceId) ->\n        check spaceId, String\n\n        unless this.userId\n            return this.ready()\n\n        return db.space_user_signs.find({ space: spaceId }, {fields: {created_by: 0, created: 0, modified_by: 0}})\n","if (Meteor.isServer) {\n  Meteor.publish('space_user_signs', function(spaceId) {\n    check(spaceId, String);\n    if (!this.userId) {\n      return this.ready();\n    }\n    return db.space_user_signs.find({\n      space: spaceId\n    }, {\n      fields: {\n        created_by: 0,\n        created: 0,\n        modified_by: 0\n      }\n    });\n  });\n}\n","###\nMeteor.publishComposite \"user_inbox_instance\", ()->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tuserSpaceIds = db.space_users.find({\n\t\tuser: this.userId,\n\t\tuser_accepted: true\n\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\tquery = {space: {$in: userSpaceIds}}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfind: ->\n\t\tdb.instances.find(query, {\n\t\t\tfields: {\n\t\t\t\tspace: 1,\n\t\t\t\tapplicant_name: 1,\n\t\t\t\tflow: 1,\n\t\t\t\tinbox_users: 1,\n\t\t\t\tcc_users: 1,\n\t\t\t\tstate: 1,\n\t\t\t\tname: 1,\n\t\t\t\tmodified: 1,\n\t\t\t\tform: 1\n\t\t\t}, sort: {modified: -1}, skip: 0, limit: 200\n\t\t});\n\tchildren: [\n\t\t{\n\t\t\tfind: (instance, post)->\n\t\t\t\tdb.flows.find({_id: instance.flow}, {fields: {name: 1, space: 1}});\n\t\t}\n\t]\n###\n\n###\nMeteor.publish 'my_inbox_instances', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tself = this;\n\n\t#\tuserSpaceIds = db.space_users.find({\n\t#\t\tuser: this.userId,\n\t#\t\tuser_accepted: true\n\t#\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\n\tquery = {space: spaceId}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfields = {\n\t\tspace: 1,\n#\t\tapplicant_name: 1,\n\t\tflow: 1,\n\t\tinbox_users: 1,\n\t\tcc_users: 1,\n\t\tstate: 1,\n#\t\tname: 1,\n#\t\tmodified: 1,\n\t\tform: 1\n\t}\n\n\thandle = db.instances.find(query, {sort: {modified: -1}, skip: 0, limit: 500}).observeChanges {\n\t\tadded: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.added(\"instances\", id, instance)\n\t\tchanged: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.changed(\"instances\", id, instance);\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n###\n\n_get_flow_instances_aggregate = (spaceId, userId, _items, callback)->\n\tdb.instances.rawCollection().aggregate([\n\t\t{\n\t\t\t$match: {\n\t\t\t\tspace: spaceId,\n\t\t\t\t$or: [{inbox_users: userId}, {cc_users: userId}]\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\t$group: {\n\t\t\t\t_id: {flow: \"$flow\", category: \"$category\"}, count: {$sum: 1}\n\t\t\t}\n\t\t}\n\t]).toArray (err, data)->\n\t\tif err\n\t\t\tthrow new Error(err)\n\n\t\tdata.forEach (doc) ->\n\t\t\t_items.push doc\n\n\t\tif callback && _.isFunction(callback)\n\t\t\tcallback()\n\t\treturn\n\n_async_get_flow_instances_aggregate = Meteor.wrapAsync(_get_flow_instances_aggregate)\n\nMeteor.publish 'my_inbox_flow_instances_count', (spaceId)->\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tself = this;\n\n\tquery = {space: spaceId}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tdata = []  #数据格式：[{_id:flowId, count: 待办数量}, {_id:flowId2, count: 待办数量2}]\n\t_async_get_flow_instances_aggregate(spaceId, self.userId, data)\n\n\t_flowsData = []\n\n\t_.each data, (dataItem)->\n\t\t_flowsData.push({_id: dataItem._id.flow, category: dataItem._id.category, count: dataItem.count})\n\n\tself.added(\"flow_instances\", spaceId, {flows: _flowsData});\n\n\t_changeData = (doc, action)->\n\t\tflow_instance = _.find _flowsData, (f)->\n\t\t\treturn f._id == doc.flow\n\t\tif flow_instance\n\t\t\tif action == \"added\"\n\t\t\t\tflow_instance.count++\n\t\t\telse if action == \"removed\"\n\t\t\t\tflow_instance.count--\n\t\telse if action == \"added\"\n\t\t\t_flowsData.push {_id: doc.flow, category: doc.category, count: 1}\n\n\t\tself.changed(\"flow_instances\", spaceId, {flows: _flowsData});\n\n\t_init = true\n\thandle = db.instances.find(query, {fields: {_id: 1, inbox_users: 1, cc_users: 1, flow: 1, category: 1}}).observe {\n\t\tadded: (doc)->\n\t\t\tif !_init\n\t\t\t\t_changeData(doc, \"added\")\n\t\tremoved: (doc)->\n\t\t\tif !_init\n\t\t\t\t_changeData(doc, \"removed\")\n\t}\n\t_init = false\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()","\n/*\nMeteor.publishComposite \"user_inbox_instance\", ()->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tuserSpaceIds = db.space_users.find({\n\t\tuser: this.userId,\n\t\tuser_accepted: true\n\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\tquery = {space: {$in: userSpaceIds}}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfind: ->\n\t\tdb.instances.find(query, {\n\t\t\tfields: {\n\t\t\t\tspace: 1,\n\t\t\t\tapplicant_name: 1,\n\t\t\t\tflow: 1,\n\t\t\t\tinbox_users: 1,\n\t\t\t\tcc_users: 1,\n\t\t\t\tstate: 1,\n\t\t\t\tname: 1,\n\t\t\t\tmodified: 1,\n\t\t\t\tform: 1\n\t\t\t}, sort: {modified: -1}, skip: 0, limit: 200\n\t\t});\n\tchildren: [\n\t\t{\n\t\t\tfind: (instance, post)->\n\t\t\t\tdb.flows.find({_id: instance.flow}, {fields: {name: 1, space: 1}});\n\t\t}\n\t]\n */\n\n/*\nMeteor.publish 'my_inbox_instances', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tself = this;\n\n\t *\tuserSpaceIds = db.space_users.find({\n\t *\t\tuser: this.userId,\n\t *\t\tuser_accepted: true\n\t *\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\n\tquery = {space: spaceId}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfields = {\n\t\tspace: 1,\n *\t\tapplicant_name: 1,\n\t\tflow: 1,\n\t\tinbox_users: 1,\n\t\tcc_users: 1,\n\t\tstate: 1,\n *\t\tname: 1,\n *\t\tmodified: 1,\n\t\tform: 1\n\t}\n\n\thandle = db.instances.find(query, {sort: {modified: -1}, skip: 0, limit: 500}).observeChanges {\n\t\tadded: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.added(\"instances\", id, instance)\n\t\tchanged: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.changed(\"instances\", id, instance);\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n */\nvar _async_get_flow_instances_aggregate, _get_flow_instances_aggregate;\n\n_get_flow_instances_aggregate = function(spaceId, userId, _items, callback) {\n  return db.instances.rawCollection().aggregate([\n    {\n      $match: {\n        space: spaceId,\n        $or: [\n          {\n            inbox_users: userId\n          }, {\n            cc_users: userId\n          }\n        ]\n      }\n    }, {\n      $group: {\n        _id: {\n          flow: \"$flow\",\n          category: \"$category\"\n        },\n        count: {\n          $sum: 1\n        }\n      }\n    }\n  ]).toArray(function(err, data) {\n    if (err) {\n      throw new Error(err);\n    }\n    data.forEach(function(doc) {\n      return _items.push(doc);\n    });\n    if (callback && _.isFunction(callback)) {\n      callback();\n    }\n  });\n};\n\n_async_get_flow_instances_aggregate = Meteor.wrapAsync(_get_flow_instances_aggregate);\n\nMeteor.publish('my_inbox_flow_instances_count', function(spaceId) {\n  var _changeData, _flowsData, _init, data, handle, query, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  self = this;\n  query = {\n    space: spaceId\n  };\n  query.$or = [\n    {\n      inbox_users: this.userId\n    }, {\n      cc_users: this.userId\n    }\n  ];\n  data = [];\n  _async_get_flow_instances_aggregate(spaceId, self.userId, data);\n  _flowsData = [];\n  _.each(data, function(dataItem) {\n    return _flowsData.push({\n      _id: dataItem._id.flow,\n      category: dataItem._id.category,\n      count: dataItem.count\n    });\n  });\n  self.added(\"flow_instances\", spaceId, {\n    flows: _flowsData\n  });\n  _changeData = function(doc, action) {\n    var flow_instance;\n    flow_instance = _.find(_flowsData, function(f) {\n      return f._id === doc.flow;\n    });\n    if (flow_instance) {\n      if (action === \"added\") {\n        flow_instance.count++;\n      } else if (action === \"removed\") {\n        flow_instance.count--;\n      }\n    } else if (action === \"added\") {\n      _flowsData.push({\n        _id: doc.flow,\n        category: doc.category,\n        count: 1\n      });\n    }\n    return self.changed(\"flow_instances\", spaceId, {\n      flows: _flowsData\n    });\n  };\n  _init = true;\n  handle = db.instances.find(query, {\n    fields: {\n      _id: 1,\n      inbox_users: 1,\n      cc_users: 1,\n      flow: 1,\n      category: 1\n    }\n  }).observe({\n    added: function(doc) {\n      if (!_init) {\n        return _changeData(doc, \"added\");\n      }\n    },\n    removed: function(doc) {\n      if (!_init) {\n        return _changeData(doc, \"removed\");\n      }\n    }\n  });\n  _init = false;\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n","\nMeteor.publish 'flow_main_attach_template', (spaceId, flowId)->\n\tcheck(spaceId, String)\n\tcheck(flowId, String)\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId && flowId\n\t\treturn this.ready()\n\n\treturn Creator.getCollection('cms_files').find({ space: spaceId, 'parent.o': 'flows', 'parent.ids': flowId,  name: '正文.docx' })\n","Meteor.publish('flow_main_attach_template', function(spaceId, flowId) {\n  check(spaceId, String);\n  check(flowId, String);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!(spaceId && flowId)) {\n    return this.ready();\n  }\n  return Creator.getCollection('cms_files').find({\n    space: spaceId,\n    'parent.o': 'flows',\n    'parent.ids': flowId,\n    name: '正文.docx'\n  });\n});\n","workflowTemplate = {}\n\n#可用此脚本从模板工作区做批量导出：\n#使用管理员账户登录后，进入FlowModules，在控制台执行以下脚本即可\n#db.forms.find({state:\"enabled\"}).forEach(function(form){window.open(Meteor.absoluteUrl(\"api/workflow/export/form?form=\"+form._id))})\nworkflowTemplate[\"en\"] =[]\n\n#可用此脚本从模板工作区做批量导出：\n#使用管理员账户登录后，进入模板专区，在控制台执行以下脚本即可\n#db.forms.find({state:\"enabled\"}).forEach(function(form){window.open(Meteor.absoluteUrl(\"api/workflow/export/form?form=\"+form._id))})\nworkflowTemplate[\"zh-CN\"] =[]\n\nMeteor.startup ()->\n\tfs = require('fs')\n\tpath = require('path')\n\tmime = require('mime')\n\treadFileList = (pathDir, filesList)->\n\t\tfiles = fs.readdirSync(pathDir)\n\t\tfiles.forEach (name, index)->\n\t\t\tstat = fs.statSync(path.join(pathDir, name))\n\t\t\tif stat.isDirectory()\n\t\t\t\t# 递归读取文件\n\t\t\t\treadFileList(path.join(pathDir, name), filesList)\n\t\t\telse\n\t\t\t\tobj = {}\n\t\t\t\tobj.path = pathDir\n\t\t\t\tobj.name = name\n\t\t\t\tfilesList.push(obj)\n\n\t#获取zh-cn文件夹下的所有文件\n\tfilesList_cn = []\n\tpath_cn = Meteor.settings.workflowTemplates?.path_cn\n\tif path_cn\n\t\tabsolute_path_cn = path.resolve(path_cn)\n\t\tconsole.log \"absolute_path_cn\", absolute_path_cn\n\t\tif fs.existsSync(absolute_path_cn)\n\t\t\treadFileList(absolute_path_cn, filesList_cn)\n\t\t\tfilesList_cn.forEach (file)->\n\t\t\t\ttry\n\t\t\t\t\tif mime.getType(file.name) is \"application/json\"\n\t\t\t\t\t\tdata = fs.readFileSync(path.join(file.path, file.name), 'utf8')\n\t\t\t\t\t\tworkflowTemplate[\"zh-CN\"].push(JSON.parse(data))\n\t\t\t\tcatch e\n\t\t\t\t\tconsole.error \"获取zh-cn文件夹下的所有文件\", path.join(file.path, file.name)\n\t\t\t\t\tconsole.error e.stack\n\n\t#获取en-us文件夹下的所有文件\n\tfilesList_us = []\n\tpath_us = Meteor.settings.workflowTemplates?.path_us\n\tif path_us\n\t\tabsolute_path_us = path.resolve(path_us)\n\t\tconsole.log \"absolute_path_us\", absolute_path_us\n\t\tif fs.existsSync(absolute_path_us)\n\t\t\treadFileList(absolute_path_us, filesList_us)\n\t\t\tfilesList_us.forEach (file)->\n\t\t\t\ttry\n\t\t\t\t\tif mime.getType(file.name) is \"application/json\"\n\t\t\t\t\t\tdata = fs.readFileSync(path.join(file.path, file.name), 'utf8')\n\t\t\t\t\t\tworkflowTemplate[\"en\"].push(JSON.parse(data))\n\t\t\t\tcatch e\n\t\t\t\t\tconsole.error \"获取en-us文件夹下的所有文件\", path.join(file.path, file.name)\n\t\t\t\t\tconsole.error e.stack\n\t\t\t\t\n\t\t\t\t\t\n\n\n","                     \n\nworkflowTemplate = {};\n\nworkflowTemplate[\"en\"] = [];\n\nworkflowTemplate[\"zh-CN\"] = [];\n\nMeteor.startup(function() {\n  var absolute_path_cn, absolute_path_us, filesList_cn, filesList_us, fs, mime, path, path_cn, path_us, readFileList, ref, ref1;\n  fs = require('fs');\n  path = require('path');\n  mime = require('mime');\n  readFileList = function(pathDir, filesList) {\n    var files;\n    files = fs.readdirSync(pathDir);\n    return files.forEach(function(name, index) {\n      var obj, stat;\n      stat = fs.statSync(path.join(pathDir, name));\n      if (stat.isDirectory()) {\n        return readFileList(path.join(pathDir, name), filesList);\n      } else {\n        obj = {};\n        obj.path = pathDir;\n        obj.name = name;\n        return filesList.push(obj);\n      }\n    });\n  };\n  filesList_cn = [];\n  path_cn = (ref = Meteor.settings.workflowTemplates) != null ? ref.path_cn : void 0;\n  if (path_cn) {\n    absolute_path_cn = path.resolve(path_cn);\n    console.log(\"absolute_path_cn\", absolute_path_cn);\n    if (fs.existsSync(absolute_path_cn)) {\n      readFileList(absolute_path_cn, filesList_cn);\n      filesList_cn.forEach(function(file) {\n        var data, e;\n        try {\n          if (mime.getType(file.name) === \"application/json\") {\n            data = fs.readFileSync(path.join(file.path, file.name), 'utf8');\n            return workflowTemplate[\"zh-CN\"].push(JSON.parse(data));\n          }\n        } catch (error) {\n          e = error;\n          console.error(\"获取zh-cn文件夹下的所有文件\", path.join(file.path, file.name));\n          return console.error(e.stack);\n        }\n      });\n    }\n  }\n  filesList_us = [];\n  path_us = (ref1 = Meteor.settings.workflowTemplates) != null ? ref1.path_us : void 0;\n  if (path_us) {\n    absolute_path_us = path.resolve(path_us);\n    console.log(\"absolute_path_us\", absolute_path_us);\n    if (fs.existsSync(absolute_path_us)) {\n      readFileList(absolute_path_us, filesList_us);\n      return filesList_us.forEach(function(file) {\n        var data, e;\n        try {\n          if (mime.getType(file.name) === \"application/json\") {\n            data = fs.readFileSync(path.join(file.path, file.name), 'utf8');\n            return workflowTemplate[\"en\"].push(JSON.parse(data));\n          }\n        } catch (error) {\n          e = error;\n          console.error(\"获取en-us文件夹下的所有文件\", path.join(file.path, file.name));\n          return console.error(e.stack);\n        }\n      });\n    }\n  }\n});\n","###\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n###\nMeteor.startup ->\n\tif Meteor.settings.cron?.auto_finish_process_delegation\n\t\tschedule = require('node-schedule')\n\t\t# 定时执行同步\n\t\trule = Meteor.settings.cron.auto_finish_process_delegation\n\t\tgo_next = true\n\t\tschedule.scheduleJob rule, Meteor.bindEnvironment ()->\n\t\t\ttry\n\t\t\t\tif !go_next\n\t\t\t\t\treturn\n\t\t\t\tgo_next = false\n\t\t\t\tconsole.time 'auto_finish_process_delegation'\n\n\t\t\t\tnow = new Date\n\n\t\t\t\t# 将委托规则设置为不可用\n\t\t\t\tdb.process_delegation_rules.update({ enabled: true, end_time: { $lte: now } }, { $set: { enabled: false } }, { multi :true })\n\n\t\t\t\tconsole.timeEnd 'auto_finish_process_delegation'\n\t\t\t\tgo_next = true\n\n\t\t\tcatch e\n\t\t\t\tconsole.error \"AUTO AUTO_FINISH_PROCESS_DELEGATION ERROR: \"\n\t\t\t\tconsole.error e.stack\n\t\t\t\tgo_next = true\n\n\t\t, (e)->\n\t\t\tconsole.log 'Failed to bind environment: auto_finish_process_delegation.coffee'\n\t\t\tconsole.log e.stack\n","\n/*\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n */\nMeteor.startup(function() {\n  var go_next, ref, rule, schedule;\n  if ((ref = Meteor.settings.cron) != null ? ref.auto_finish_process_delegation : void 0) {\n    schedule = require('node-schedule');\n    rule = Meteor.settings.cron.auto_finish_process_delegation;\n    go_next = true;\n    return schedule.scheduleJob(rule, Meteor.bindEnvironment(function() {\n      var e, now;\n      try {\n        if (!go_next) {\n          return;\n        }\n        go_next = false;\n        console.time('auto_finish_process_delegation');\n        now = new Date;\n        db.process_delegation_rules.update({\n          enabled: true,\n          end_time: {\n            $lte: now\n          }\n        }, {\n          $set: {\n            enabled: false\n          }\n        }, {\n          multi: true\n        });\n        console.timeEnd('auto_finish_process_delegation');\n        return go_next = true;\n      } catch (error) {\n        e = error;\n        console.error(\"AUTO AUTO_FINISH_PROCESS_DELEGATION ERROR: \");\n        console.error(e.stack);\n        return go_next = true;\n      }\n    }, function(e) {\n      console.log('Failed to bind environment: auto_finish_process_delegation.coffee');\n      return console.log(e.stack);\n    }));\n  }\n});\n","###\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n###\nMeteor.startup ->\n\tif Meteor.settings.cron?.timeout_auto_submit\n\t\tschedule = require('node-schedule')\n\t\t# 定时执行同步\n\t\trule = Meteor.settings.cron.timeout_auto_submit\n\t\tgo_next = true\n\t\tschedule.scheduleJob rule, Meteor.bindEnvironment ()->\n\t\t\ttry\n\t\t\t\tif !go_next\n\t\t\t\t\treturn\n\t\t\t\tgo_next = false\n\t\t\t\tconsole.time 'timeout_auto_submit'\n\n\t\t\t\tuuflowManager.timeoutAutoSubmit()\n\n\t\t\t\tconsole.timeEnd 'timeout_auto_submit'\n\t\t\t\tgo_next = true\n\n\t\t\tcatch e\n\t\t\t\tconsole.error \"AUTO TIMEOUT_AUTO_SUBMIT ERROR: \"\n\t\t\t\tconsole.error e.stack\n\t\t\t\tgo_next = true\n\n\t\t, (e)->\n\t\t\tconsole.log 'Failed to bind environment: timeout_auto_submit.coffee'\n\t\t\tconsole.log e.stack\n\nMeteor.methods\n\ttimeout_auto_submit: (ins_id)->\n\t\tuuflowManager.timeoutAutoSubmit(ins_id)\n\t\treturn true\n\n\n","\n/*\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n */\nMeteor.startup(function() {\n  var go_next, ref, rule, schedule;\n  if ((ref = Meteor.settings.cron) != null ? ref.timeout_auto_submit : void 0) {\n    schedule = require('node-schedule');\n    rule = Meteor.settings.cron.timeout_auto_submit;\n    go_next = true;\n    return schedule.scheduleJob(rule, Meteor.bindEnvironment(function() {\n      var e;\n      try {\n        if (!go_next) {\n          return;\n        }\n        go_next = false;\n        console.time('timeout_auto_submit');\n        uuflowManager.timeoutAutoSubmit();\n        console.timeEnd('timeout_auto_submit');\n        return go_next = true;\n      } catch (error) {\n        e = error;\n        console.error(\"AUTO TIMEOUT_AUTO_SUBMIT ERROR: \");\n        console.error(e.stack);\n        return go_next = true;\n      }\n    }, function(e) {\n      console.log('Failed to bind environment: timeout_auto_submit.coffee');\n      return console.log(e.stack);\n    }));\n  }\n});\n\nMeteor.methods({\n  timeout_auto_submit: function(ins_id) {\n    uuflowManager.timeoutAutoSubmit(ins_id);\n    return true;\n  }\n});\n","Meteor.startup ()->\n\tTabularTables.related_instances_tabular = new Tabular.Table\n\t\tname: \"related_instances_tabular\"\n\t\tcollection: db.instances\n\t\tcolumns: [\n\t\t\t{\n\t\t\t\tdata: \"_id\",\n\t\t\t\ttitle: '<input type=\"checkbox\" name=\"reverse\" id=\"reverse\">',\n\t\t\t\torderable: false,\n\t\t\t\twidth: '1px',\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tinput = '<input type=\"checkbox\" class=\"related-instances-list-checkbox\" name=\"related_instances_ids\" id=\"related_instances_ids\" value=\"' + doc._id + '\"'\n\n\t\t\t\t\tif TabularTables.related_instances_tabular.related_instances?.includes(doc._id)\n\t\t\t\t\t\tinput += \" checked \"\n\n\t\t\t\t\tinput += \">\"\n\t\t\t\t\treturn input\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"name\",\n\t\t\t\torderable: false,\n\t\t\t\twidth: '45%',\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\thref = '';\n\t\t\t\t\tif Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())\n\t\t\t\t\t\thref = ''\n\n\t\t\t\t\tabsolute = false\n\n\t\t\t\t\tif Meteor.isServer\n\t\t\t\t\t\tabsolute = this.absolute\n\t\t\t\t\tif absolute\n\t\t\t\t\t\thref = Meteor.absoluteUrl(\"workflow/space/\"+doc.space+\"/view/readonly/\" + doc._id + '?hide_traces=0')\n\t\t\t\t\telse\n\t\t\t\t\t\thref = Steedos.absoluteUrl(\"workflow/space/\"+doc.space+\"/view/readonly/\" + doc._id + '?hide_traces=0')\n\t\t\t\t\treturn \"<a data-id='#{doc._id}' target='_blank' href='\"+href+\"'>\" + doc.name + \"</a>\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_name\",\n\t\t\t\ttitle: t(\"instances_applicant_name\"),\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"flow_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"current_step_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.state == \"completed\"\n\t\t\t\t\t\tjudge = doc.final_decision || \"approved\"\n\n\t\t\t\t\tstep_current_name = doc.current_step_name || ''\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t<div class=\"step-current-state #{judge}\">#{step_current_name}</div>\n\t\t\t\t\t\t\"\"\"\n\t\t\t}\n\t\t]\n\n\t\tdom: \"tp\",\n\t\tlengthChange: false,\n\t\textraFields: [\"state\", \"final_decision\", \"space\", \"keywords\"],\n\t\tpageLength: 10,\n\t\tinfo: false,\n\t\tsearching: true,\n\t\tresponsive:\n\t\t\tdetails: false\n\t\tautoWidth: false,\n\t\tchangeSelector: (selector, userId) ->\n\t\t\tunless userId\n\t\t\t\treturn {_id: -1}\n\n\t\t\tspaceId = selector.space\n\t\t\tunless spaceId\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tspaceId = selector.$and.getProperty('space')[0]\n\t\t\tunless spaceId\n\t\t\t\treturn {_id: -1}\n\t\t\tspace = db.spaces.findOne(spaceId)\n\t\t\tif !space\n\t\t\t\tselector.state = \"none\"\n\t\t\tif !space.admins.includes(userId)\n\n\t\t\t\tflow_ids = []\n\t\t\t\tcurSpaceUser = db.space_users.findOne({\n\t\t\t\t\tspace: spaceId,\n\t\t\t\t\t'user': userId\n\t\t\t\t})\n\t\t\t\tif curSpaceUser\n\t\t\t\t\torganizations = db.organizations.find({\n\t\t\t\t\t\t_id: {\n\t\t\t\t\t\t\t$in: curSpaceUser.organizations\n\t\t\t\t\t\t}\n\t\t\t\t\t}).fetch()\n\t\t\t\t\tflows = db.flows.find({ space: spaceId })\n\t\t\t\t\tflows.forEach (fl)->\n\t\t\t\t\t\tif WorkflowManager.canMonitor(fl, curSpaceUser, organizations) || WorkflowManager.canAdmin(fl, curSpaceUser, organizations)\n\t\t\t\t\t\t\tflow_ids.push(fl._id)\n\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tselector.$and[0].$or = [{submitter: userId}, {applicant: userId}, {inbox_users: userId}, {outbox_users: userId},\n\t\t\t\t\t\t\t{cc_users: userId}, { flow: { $in: flow_ids } }]\n\t\t\t\telse\n\t\t\t\t\t_.extend selector, {\n\t\t\t\t\t\t$or: [{submitter: userId}, {applicant: userId}, {inbox_users: userId}, {outbox_users: userId},\n\t\t\t\t\t\t\t{cc_users: userId}, { flow: { $in: flow_ids } }]\n\t\t\t\t\t}\n\n\t\t\treturn selector","Meteor.startup(function() {\n  return TabularTables.related_instances_tabular = new Tabular.Table({\n    name: \"related_instances_tabular\",\n    collection: db.instances,\n    columns: [\n      {\n        data: \"_id\",\n        title: '<input type=\"checkbox\" name=\"reverse\" id=\"reverse\">',\n        orderable: false,\n        width: '1px',\n        render: function(val, type, doc) {\n          var input, ref;\n          input = '<input type=\"checkbox\" class=\"related-instances-list-checkbox\" name=\"related_instances_ids\" id=\"related_instances_ids\" value=\"' + doc._id + '\"';\n          if ((ref = TabularTables.related_instances_tabular.related_instances) != null ? ref.includes(doc._id) : void 0) {\n            input += \" checked \";\n          }\n          input += \">\";\n          return input;\n        }\n      }, {\n        data: \"name\",\n        orderable: false,\n        width: '45%',\n        render: function(val, type, doc) {\n          var absolute, href;\n          href = '';\n          if (Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())) {\n            href = '';\n          }\n          absolute = false;\n          if (Meteor.isServer) {\n            absolute = this.absolute;\n          }\n          if (absolute) {\n            href = Meteor.absoluteUrl(\"workflow/space/\" + doc.space + \"/view/readonly/\" + doc._id + '?hide_traces=0');\n          } else {\n            href = Steedos.absoluteUrl(\"workflow/space/\" + doc.space + \"/view/readonly/\" + doc._id + '?hide_traces=0');\n          }\n          return (\"<a data-id='\" + doc._id + \"' target='_blank' href='\") + href + \"'>\" + doc.name + \"</a>\";\n        }\n      }, {\n        data: \"applicant_name\",\n        title: t(\"instances_applicant_name\"),\n        orderable: false\n      }, {\n        data: \"flow_name\",\n        title: t(\"instances_flow\"),\n        orderable: false\n      }, {\n        data: \"current_step_name\",\n        title: t(\"instances_flow\"),\n        render: function(val, type, doc) {\n          var judge, step_current_name;\n          if (doc.state === \"completed\") {\n            judge = doc.final_decision || \"approved\";\n          }\n          step_current_name = doc.current_step_name || '';\n          return \"<div class=\\\"step-current-state \" + judge + \"\\\">\" + step_current_name + \"</div>\";\n        }\n      }\n    ],\n    dom: \"tp\",\n    lengthChange: false,\n    extraFields: [\"state\", \"final_decision\", \"space\", \"keywords\"],\n    pageLength: 10,\n    info: false,\n    searching: true,\n    responsive: {\n      details: false\n    },\n    autoWidth: false,\n    changeSelector: function(selector, userId) {\n      var curSpaceUser, flow_ids, flows, organizations, ref, ref1, space, spaceId;\n      if (!userId) {\n        return {\n          _id: -1\n        };\n      }\n      spaceId = selector.space;\n      if (!spaceId) {\n        if ((selector != null ? (ref = selector.$and) != null ? ref.length : void 0 : void 0) > 0) {\n          spaceId = selector.$and.getProperty('space')[0];\n        }\n      }\n      if (!spaceId) {\n        return {\n          _id: -1\n        };\n      }\n      space = db.spaces.findOne(spaceId);\n      if (!space) {\n        selector.state = \"none\";\n      }\n      if (!space.admins.includes(userId)) {\n        flow_ids = [];\n        curSpaceUser = db.space_users.findOne({\n          space: spaceId,\n          'user': userId\n        });\n        if (curSpaceUser) {\n          organizations = db.organizations.find({\n            _id: {\n              $in: curSpaceUser.organizations\n            }\n          }).fetch();\n          flows = db.flows.find({\n            space: spaceId\n          });\n          flows.forEach(function(fl) {\n            if (WorkflowManager.canMonitor(fl, curSpaceUser, organizations) || WorkflowManager.canAdmin(fl, curSpaceUser, organizations)) {\n              return flow_ids.push(fl._id);\n            }\n          });\n        }\n        if ((selector != null ? (ref1 = selector.$and) != null ? ref1.length : void 0 : void 0) > 0) {\n          selector.$and[0].$or = [\n            {\n              submitter: userId\n            }, {\n              applicant: userId\n            }, {\n              inbox_users: userId\n            }, {\n              outbox_users: userId\n            }, {\n              cc_users: userId\n            }, {\n              flow: {\n                $in: flow_ids\n              }\n            }\n          ];\n        } else {\n          _.extend(selector, {\n            $or: [\n              {\n                submitter: userId\n              }, {\n                applicant: userId\n              }, {\n                inbox_users: userId\n              }, {\n                outbox_users: userId\n              }, {\n                cc_users: userId\n              }, {\n                flow: {\n                  $in: flow_ids\n                }\n              }\n            ]\n          });\n        }\n      }\n      return selector;\n    }\n  });\n});\n","Steedos.subs[\"InstanceTabular\"] = new SubsManager()\n\n\n_handleListFields = (fields) ->\n\tins_fields = new Array();\n\n\tfields?.forEach (f)->\n\t\tif f.type == 'table'\n\t\t\tconsole.log 'ignore opinion field in table'\n\t\telse if f.type == 'section'\n\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\tins_fields.push f1\n\t\telse\n\t\t\tins_fields.push f\n\n\treturn ins_fields\n\n\nupdateTabularTitle = ()->\n\n# 如果columns有加减，请修改Template.instance_list._tableColumns 函数\ninstancesListTableTabular = (flowId, fields)->\n\toptions = {\n\t\tname: \"instances\",\n\t\tcollection: db.instances,\n\t\tpub: \"instance_tabular\",\n\t\tonUnload: ()->\n\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\n\t\tdrawCallback: (settings)->\n\t\t\temptyTd = $(\".dataTables_empty\")\n\t\t\tif emptyTd.length\n\t\t\t\temptyTd[0].colSpan = \"6\"\n\t\t\tif !Steedos.isMobile() && !Steedos.isPad()\n\t\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\t\t\t\t$(\".instance-list\").scrollTop(0).ready ->\n\t\t\t\t\t$(\".instance-list\").perfectScrollbar(\"update\")\n\t\t\telse\n\t\t\t\t$(\".instance-list\").scrollTop(0)\n\n\t\t\ttitle = t \"pager_input_hint\"\n\t\t\tellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a')\n\t\t\tellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click ->\n\t\t\t\tif !$(this).find('input').length\n\t\t\t\t\tinput = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>')\n\t\t\t\t\tif Steedos.isMobile()\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"20px\"\n\t\t\t\t\t\t})\n\t\t\t\t\telse\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"16px\"\n\t\t\t\t\t\t})\n\t\t\t\t\tinput.attr(\"title\", title).attr(\"placeholder\", title)\n\t\t\t\t\t$(this).empty().append input\n\t\t\t\t\tgoPage = (index)->\n\t\t\t\t\t\tif index > 0\n\t\t\t\t\t\t\tpages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength)\n\t\t\t\t\t\t\tif index > pages\n\t\t\t\t\t\t\t\t# 页码超出索引时跳转到最后一页\n\t\t\t\t\t\t\t\tindex = pages\n\t\t\t\t\t\t\tindex--\n\t\t\t\t\t\t\tsettings.oInstance.DataTable().page(index).draw('page')\n\t\t\t\t\tinput.blur (e)->\n\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\tgoPage currentPage\n\t\t\t\t\t\t$(this).parent().html '...'\n\t\t\t\t\tinput.keydown (e)->\n\t\t\t\t\t\tif(e.keyCode.toString() == \"13\")\n\t\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\t\tgoPage currentPage\n\n\t\tcreatedRow: (row, data, dataIndex) ->\n\t\t\tif Meteor.isClient\n\t\t\t\tif data._id == FlowRouter.current().params.instanceId\n\t\t\t\t\trow.setAttribute(\"class\", \"selected\")\n\t\tcolumns: [\n\t\t\t{\n\t\t\t\tdata: \"_id\",\n\t\t\t\torderable: false\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tmodifiedString = moment(doc.modified).format('YYYY-MM-DD');\n\n\t\t\t\t\tmodified = doc.modified\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.state != 'draft'\n\t\t\t\t\t\tmodified = doc.start_date || doc.modified\n\n\t\t\t\t\tif Session.get(\"box\") == 'outbox' || Session.get(\"box\") == 'monitor'\n\t\t\t\t\t\tmodified = doc.submit_date || doc.submit_date\n\n\t\t\t\t\tmodifiedFromNow = Steedos.momentReactiveFromNow(modified);\n\t\t\t\t\tflow_name = doc.flow_name\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.is_cc && !doc.inbox_users?.includes(Meteor.userId()) && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.current_step_name})</span></div>\"\n\t\t\t\t\telse\n\t\t\t\t\t\tif Session.get(\"box\") != 'draft' && doc.current_step_name\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.current_step_name})</span></div>\"\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}</div>\"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\t# isFavoriteSelected = Favorites.isRecordSelected(\"instances\", doc._id)\n\t\t\t\t\t# if Favorites.isRecordSelected(\"instances\", doc._id)\n\t\t\t\t\t# \tunread = '<i class=\"ion ion-ios-star-outline instance-favorite-selected\"></i>'\n\t\t\t\t\t# else \n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIcon = \"\"\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.name}#{cc_view}#{agent_view}\n\t\t\t\t\t\t\t\t\t<span>#{doc.applicant_name}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t<div class='instance-detail'>#{step_current_name_view}\n\t\t\t\t\t\t\t\t\t<span class='instance-modified' title='#{modifiedString}'>#{modifiedFromNow}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\"\"\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_organization_name\",\n\t\t\t\ttitle: t(\"instances_applicant_organization_name\"),\n\t\t\t\tvisible: false,\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"name\",\n\t\t\t\ttitle: t(\"instances_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.is_cc && !doc.inbox_users?.includes(Meteor.userId()) && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.name}#{cc_view}#{agent_view}</div>\n\t\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_name\",\n\t\t\t\ttitle: t(\"instances_applicant_name\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"submit_date\",\n\t\t\t\ttitle: t(\"instances_submit_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.submit_date\n\t\t\t\t\t\treturn moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"flow_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"current_step_name\",\n\t\t\t\ttitle: t(\"instances_step_current_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.state == \"completed\"\n\t\t\t\t\t\tjudge = doc.final_decision || \"approved\"\n\n\t\t\t\t\tstep_current_name = doc.current_step_name || ''\n\n\t\t\t\t\tcc_tag = ''\n\n\t\t\t\t\tif doc.cc_count > 0\n\t\t\t\t\t\tcc_tag = TAPi18n.__('cc_tag')\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t<div class=\"step-current-state #{judge}\">#{step_current_name}#{cc_tag}</div>\n\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\ttitle: t(\"instances_modified\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\treturn moment(doc.modified).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"start_date\",\n\t\t\t\ttitle: t(\"instances_start_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.start_date\n\t\t\t\t\t\treturn moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"my_finish_date\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.my_finish_date\n\t\t\t\t\t\treturn moment(doc.my_finish_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"keywords\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"is_archived\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc?.values?.record_need && doc.values.record_need == \"true\"\n\t\t\t\t\t\tif doc?.is_archived\n\t\t\t\t\t\t\treturn t(\"YES\")\n\t\t\t\t\t\treturn t(\"NO\")\n\t\t\t\tvisible: false\n\t\t\t\torderable: false\n\t\t\t}\n\t\t],\n\t\tdom: do ->\n\t\t\t# 手机上不显示一页显示多少条记录选项\n\t\t\tif Steedos.isMobile()\n\t\t\t\t'tp'\n\t\t\telse\n\t\t\t\t'tpl'\n\t\torder: [[4, \"desc\"]],\n\t\textraFields: [\"form\", \"flow\", \"inbox_users\", \"state\", \"space\", \"applicant\", \"form_version\",\n\t\t\t\"flow_version\", \"is_cc\", \"cc_count\", \"is_read\", \"current_step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n\t\tlengthChange: true,\n\t\tlengthMenu: [10,15,20,25,50,100],\n\t\tpageLength: 10,\n\t\tinfo: false,\n\t\tsearching: true,\n\t\tresponsive:\n\t\t\tdetails: false\n\t\tautoWidth: false,\n\t\tchangeSelector: (selector, userId) ->\n\t\t\tunless userId\n\t\t\t\treturn {_id: -1}\n\t\t\tspace = selector.space\n\t\t\tunless space\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tspace = selector.$and.getProperty('space')[0]\n\t\t\tunless space\n\t\t\t\treturn {_id: -1}\n\t\t\tspace_user = db.space_users.findOne({user: userId, space: space}, {fields: {_id: 1}})\n\t\t\tunless space_user\n\t\t\t\treturn {_id: -1}\n\t\t\treturn selector\n\t\tpagingType: \"numbers\"\n\t\t\n\t\t# getSort: (selector, sort) -> \n\t\t# \tconsole.log('selector:',selector)\n\t\t# \tconsole.log('sort:',sort)\n\t\t# \tnewSort = []\n\t\t# \t_.each selector, (v, k) ->\n\t\t# \t\tnewSort.push([k, 1])\n\t\t# \tnewSort = newSort.concat(sort)\n\t\t# \tconsole.log('newSort:',newSort)\n\t\t# \treturn newSort\n\t}\n\n\tif flowId\n\t\tkey = \"instanceFlow\" + flowId\n\n\t\toptions.name = key\n\n\t\tTabularTables.instances.fields = fields\n\n\t\tins_fields = _handleListFields TabularTables.instances.fields\n\n\t\tins_fields.forEach (f)->\n\t\t\tif f.type != 'table' && f.is_list_display\n\t\t\t\toptions.columns.push\n\t\t\t\t\tdata: (f.name || f.code),\n\t\t\t\t\ttitle: t(f.name || f.code),\n\t\t\t\t\tvisible: false,\n\t\t\t\t\torderable: false\n\t\t\t\t\trender: (val, type, doc) ->\n\n\t\t\t\t\t\tvalues = doc.values || {}\n\n\t\t\t\t\t\tvalue = values[f.code]\n\n\t\t\t\t\t\tswitch f.type\n\t\t\t\t\t\t\twhen 'user'\n\t\t\t\t\t\t\t\tvalue = value?.name\n\t\t\t\t\t\t\twhen 'group'\n\t\t\t\t\t\t\t\tvalue = value?.fullname\n\t\t\t\t\t\t\twhen 'date'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD')\n\t\t\t\t\t\t\twhen 'dateTime'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD HH:mm')\n\t\t\t\t\t\t\twhen 'checkbox'\n\t\t\t\t\t\t\t\tif value == true || value == 'true'\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\");\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\");\n\t\t\t\t\t\t\twhen 'odata'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tif _.isArray(value)\n\t\t\t\t\t\t\t\t\t\tvalue = _.pluck(value, '@label').toString()\n\t\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\t\tvalue = value['@label']\n\n\t\t\t\t\t\treturn value\n\n\n\treturn options;\n\n\n# 如果columns有加减，请修改Template.instance_list._tableColumns 函数\ninstanceTasksListTableTabular = (flowId, fields)->\n\toptions = {\n\t\tname: \"instance_tasks\",\n\t\tcollection: db.instance_tasks,\n\t\tpub: \"instance_tasks_tabular\",\n\t\tonUnload: ()->\n\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\n\t\tdrawCallback: (settings)->\n\t\t\temptyTd = $(\".dataTables_empty\")\n\t\t\tif emptyTd.length\n\t\t\t\temptyTd[0].colSpan = \"6\"\n\t\t\tif !Steedos.isMobile() && !Steedos.isPad()\n\t\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\t\t\t\t$(\".instance-list\").scrollTop(0).ready ->\n\t\t\t\t\t$(\".instance-list\").perfectScrollbar(\"update\")\n\t\t\telse\n\t\t\t\t$(\".instance-list\").scrollTop(0)\n\n\t\t\ttitle = t \"pager_input_hint\"\n\t\t\tellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a')\n\t\t\tellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click ->\n\t\t\t\tif !$(this).find('input').length\n\t\t\t\t\tinput = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>')\n\t\t\t\t\tif Steedos.isMobile()\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"20px\"\n\t\t\t\t\t\t})\n\t\t\t\t\telse\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"16px\"\n\t\t\t\t\t\t})\n\t\t\t\t\tinput.attr(\"title\", title).attr(\"placeholder\", title)\n\t\t\t\t\t$(this).empty().append input\n\t\t\t\t\tgoPage = (index)->\n\t\t\t\t\t\tif index > 0\n\t\t\t\t\t\t\tpages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength)\n\t\t\t\t\t\t\tif index > pages\n\t\t\t\t\t\t\t\t# 页码超出索引时跳转到最后一页\n\t\t\t\t\t\t\t\tindex = pages\n\t\t\t\t\t\t\tindex--\n\t\t\t\t\t\t\tsettings.oInstance.DataTable().page(index).draw('page')\n\t\t\t\t\tinput.blur (e)->\n\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\tgoPage currentPage\n\t\t\t\t\t\t$(this).parent().html '...'\n\t\t\t\t\tinput.keydown (e)->\n\t\t\t\t\t\tif(e.keyCode.toString() == \"13\")\n\t\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\t\tgoPage currentPage\n\n\t\tcreatedRow: (row, data, dataIndex) ->\n\t\t\tif Meteor.isClient\n\t\t\t\tif data.instance == FlowRouter.current().params.instanceId\n\t\t\t\t\trow.setAttribute(\"class\", \"selected\")\n\t\tcolumns: [\n\t\t\t{\n\t\t\t\tdata: \"_id\",\n\t\t\t\torderable: false\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tmodifiedString = moment(doc.modified).format('YYYY-MM-DD');\n\n\t\t\t\t\tmodified = doc.modified\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.instance_state != 'draft'\n\t\t\t\t\t\tmodified = doc.start_date || doc.modified\n\n\t\t\t\t\tif Session.get(\"box\") == 'outbox'\n\t\t\t\t\t\tmodified = doc.submit_date || doc.modified\n\n\t\t\t\t\tmodifiedFromNow = Steedos.momentReactiveFromNow(modified);\n\t\t\t\t\tflow_name = doc.flow_name\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.type == 'cc' && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.step_name})</span></div>\"\n\t\t\t\t\telse\n\t\t\t\t\t\tif doc.step_name\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.step_name})</span></div>\"\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}</div>\"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIcon = \"\"\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.instance_name}#{cc_view}#{agent_view}\n\t\t\t\t\t\t\t\t\t<span>#{doc.applicant_name}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t<div class='instance-detail'>#{step_current_name_view}\n\t\t\t\t\t\t\t\t\t<span class='instance-modified' title='#{modifiedString}'>#{modifiedFromNow}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\"\"\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_organization_name\",\n\t\t\t\ttitle: t(\"instances_applicant_organization_name\"),\n\t\t\t\tvisible: false,\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"instance_name\",\n\t\t\t\ttitle: t(\"instances_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.is_cc && !doc.inbox_users?.includes(Meteor.userId()) && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.instance_name}#{cc_view}#{agent_view}</div>\n\t\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_name\",\n\t\t\t\ttitle: t(\"instances_applicant_name\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"submit_date\",\n\t\t\t\ttitle: t(\"instances_submit_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.submit_date\n\t\t\t\t\t\treturn moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"flow_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"step_name\",\n\t\t\t\ttitle: t(\"instances_step_current_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.instance_state == \"completed\"\n\t\t\t\t\t\tjudge = doc.judge || \"approved\"\n\n\t\t\t\t\tstep_current_name = doc.step_name || ''\n\n\t\t\t\t\tcc_tag = ''\n\n\t\t\t\t\tif doc.cc_count > 0\n\t\t\t\t\t\tcc_tag = TAPi18n.__('cc_tag')\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t<div class=\"step-current-state #{judge}\">#{step_current_name}#{cc_tag}</div>\n\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\ttitle: t(\"instances_modified\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\treturn moment(doc.modified).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"start_date\",\n\t\t\t\ttitle: t(\"instances_start_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.start_date\n\t\t\t\t\t\treturn moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"finish_date\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.finish_date\n\t\t\t\t\t\treturn moment(doc.finish_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"keywords\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"is_archived\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc?.values?.record_need && doc.values.record_need == \"true\"\n\t\t\t\t\t\tif doc?.is_archived\n\t\t\t\t\t\t\treturn t(\"YES\")\n\t\t\t\t\t\treturn t(\"NO\")\n\t\t\t\tvisible: false\n\t\t\t\torderable: false\n\t\t\t}\n\t\t],\n\t\tdom: do ->\n\t\t\t# 手机上不显示一页显示多少条记录选项\n\t\t\tif Steedos.isMobile()\n\t\t\t\t'tp'\n\t\t\telse\n\t\t\t\t'tpl'\n\t\torder: [[4, \"desc\"]],\n\t\textraFields: [\"instance\", \"form\", \"flow\", \"inbox_users\", \"instance_state\", \"space\", \"applicant\", \"form_version\",\n\t\t\t\"flow_version\", \"type\", \"is_read\", \"step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n\t\tlengthChange: true,\n\t\tlengthMenu: [10,15,20,25,50,100],\n\t\tpageLength: 10,\n\t\tinfo: false,\n\t\tsearching: true,\n\t\tresponsive:\n\t\t\tdetails: false\n\t\tautoWidth: false,\n\t\tchangeSelector: (selector, userId) ->\n\t\t\tunless userId\n\t\t\t\treturn {_id: -1}\n\t\t\tspace = selector.space\n\t\t\tunless space\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tspace = selector.$and.getProperty('space')[0]\n\t\t\tunless space\n\t\t\t\treturn {_id: -1}\n\t\t\tspace_user = db.space_users.findOne({user: userId, space: space}, {fields: {_id: 1}})\n\t\t\tunless space_user\n\t\t\t\treturn {_id: -1}\n\t\t\treturn selector\n\t\tpagingType: \"numbers\"\n\n\t}\n\n\tif flowId\n\t\tkey = \"instanceFlow\" + flowId\n\n\t\toptions.name = key\n\n\t\tTabularTables.instance_tasks.fields = fields\n\n\t\tins_fields = _handleListFields TabularTables.instance_tasks.fields\n\n\t\tins_fields.forEach (f)->\n\t\t\tif f.type != 'table' && f.is_list_display\n\t\t\t\toptions.columns.push\n\t\t\t\t\tdata: (f.name || f.code),\n\t\t\t\t\ttitle: t(f.name || f.code),\n\t\t\t\t\tvisible: false,\n\t\t\t\t\torderable: false\n\t\t\t\t\trender: (val, type, doc) ->\n\n\t\t\t\t\t\tvalues = doc.values || {}\n\n\t\t\t\t\t\tvalue = values[f.code]\n\n\t\t\t\t\t\tswitch f.type\n\t\t\t\t\t\t\twhen 'user'\n\t\t\t\t\t\t\t\tvalue = value?.name\n\t\t\t\t\t\t\twhen 'group'\n\t\t\t\t\t\t\t\tvalue = value?.fullname\n\t\t\t\t\t\t\twhen 'date'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD')\n\t\t\t\t\t\t\twhen 'dateTime'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD HH:mm')\n\t\t\t\t\t\t\twhen 'checkbox'\n\t\t\t\t\t\t\t\tif value == true || value == 'true'\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\");\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\");\n\t\t\t\t\t\t\twhen 'odata'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tif _.isArray(value)\n\t\t\t\t\t\t\t\t\t\tvalue = _.pluck(value, '@label').toString()\n\t\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\t\tvalue = value['@label']\n\n\t\t\t\t\t\treturn value\n\n\n\treturn options;\n\n\nMeteor.startup ()->\n\tTabularTables.instances = new Tabular.Table instancesListTableTabular()\n\tTabularTables.instance_tasks = new Tabular.Table instanceTasksListTableTabular()\n\tTabularTables.inbox_instances = new Tabular.Table GetBoxInstancesTabularOptions(\"inbox\")\n\tTabularTables.outbox_instances = new Tabular.Table GetBoxInstancesTabularOptions(\"outbox\")\n\n\nGetBoxInstancesTabularOptions = (box, flowId, fields)->\n\tkey = \"instanceFlow\" + box + flowId\n\tif box == \"inbox\"\n\t\toptions = _get_inbox_instances_tabular_options(flowId, fields)\n\telse if box == \"outbox\"\n\t\toptions = _get_outbox_instances_tabular_options(flowId, fields)\n\telse\n\t\toptions = instancesListTableTabular(flowId, fields)\n\t\tif !flowId\n\t\t\toptions.name = \"inbox_instances\"\n\tif flowId\n\t\toptions.name = key\n\treturn options\n\n_get_inbox_instances_tabular_options = (flowId, fields)->\n\toptions = instanceTasksListTableTabular(flowId, fields)\n\n\tif !flowId\n\t\toptions.name = \"inbox_instances\"\n\n\toptions.order = [[8, \"desc\"]]\n\n\toptions.getSort = (selector, sort) -> \n\t\tconsole.log('inbox_instances:',sort)\n\t\treturn sort\n\n\treturn options\n\n_get_outbox_instances_tabular_options = (flowId, fields)->\n\toptions = instanceTasksListTableTabular(flowId, fields)\n\n\tif !flowId\n\t\toptions.name = \"outbox_instances\"\n\n\toptions.order = [[9, -1]]\n\n\toptions.getSort = (selector, sort) -> \n\t\tconsole.log('outbox_instances:',sort)\n\t\t# newSort = [ \n\t\t# \t['space', 1],\n\t\t# \t['handler', 1],\n\t\t# \t['is_finished', 1],\n\t\t# ]\n\t\t# newSort = newSort.concat(sort)\n\t\t# return newSort\n\t\treturn sort\n\n\treturn options\n\nif Meteor.isClient\n\tTabularTables.flowInstances = new ReactiveVar()\n\nMeteor.startup ()->\n\tTracker.autorun (c) ->\n\t\tif Meteor.isClient && !Steedos.isMobile()\n\t\t\tif Session.get(\"flowId\") && Session.get(\"box\") != 'draft'\n\t\t\t\tMeteor.call \"newInstancesListTabular\", Session.get(\"box\"), Session.get(\"flowId\"), (error, result) ->\n\t\t\t\t\tnewInstancesListTabular Session.get(\"box\"), Session.get(\"flowId\"), result\n\t\t\t\t\tTemplate.instance_list._changeOrder()\n\n\nnewInstancesListTabular = (box, flowId, fields)->\n\tif !fields\n\t\tflow = db.flows.findOne({_id: flowId}, {fields: {form: 1}})\n\t\tfields = db.forms.findOne({ _id: flow?.form }, { fields: { 'current.fields': 1 } })?.current?.fields\n\n\tfields = _handleListFields fields\n\n\tif fields?.filterProperty(\"is_list_display\", true)?.length > 0\n\t\tkey = \"instanceFlow\" + box + flowId\n\t\tif Meteor.isClient\n\t\t\tTabularTables.flowInstances.set(new Tabular.Table GetBoxInstancesTabularOptions(box, flowId, fields))\n\t\telse\n\t\t\tnew Tabular.Table GetBoxInstancesTabularOptions(box, flowId, fields)\n\t\tconsole.log \"new TabularTables \", key\n\nif Meteor.isServer\n\tMeteor.methods\n\t\tnewInstancesListTabular: (box, flowId)->\n\t\t\tnewInstancesListTabular(box, flowId)\n\n\t\t\tflow = db.flows.findOne({_id: flowId}, {fields: {form: 1}})\n\t\t\tfields = db.forms.findOne({ _id: flow?.form }, { fields: { 'current.fields': 1 } })?.current?.fields\n\t\t\treturn fields\n\n\n","var GetBoxInstancesTabularOptions, _get_inbox_instances_tabular_options, _get_outbox_instances_tabular_options, _handleListFields, instanceTasksListTableTabular, instancesListTableTabular, newInstancesListTabular, updateTabularTitle;\n\nSteedos.subs[\"InstanceTabular\"] = new SubsManager();\n\n_handleListFields = function(fields) {\n  var ins_fields;\n  ins_fields = new Array();\n  if (fields != null) {\n    fields.forEach(function(f) {\n      var ref;\n      if (f.type === 'table') {\n        return console.log('ignore opinion field in table');\n      } else if (f.type === 'section') {\n        return f != null ? (ref = f.fields) != null ? ref.forEach(function(f1) {\n          return ins_fields.push(f1);\n        }) : void 0 : void 0;\n      } else {\n        return ins_fields.push(f);\n      }\n    });\n  }\n  return ins_fields;\n};\n\nupdateTabularTitle = function() {};\n\ninstancesListTableTabular = function(flowId, fields) {\n  var ins_fields, key, options;\n  options = {\n    name: \"instances\",\n    collection: db.instances,\n    pub: \"instance_tabular\",\n    onUnload: function() {\n      return Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n    },\n    drawCallback: function(settings) {\n      var ellipsisLink, emptyTd, title;\n      emptyTd = $(\".dataTables_empty\");\n      if (emptyTd.length) {\n        emptyTd[0].colSpan = \"6\";\n      }\n      if (!Steedos.isMobile() && !Steedos.isPad()) {\n        Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n        $(\".instance-list\").scrollTop(0).ready(function() {\n          return $(\".instance-list\").perfectScrollbar(\"update\");\n        });\n      } else {\n        $(\".instance-list\").scrollTop(0);\n      }\n      title = t(\"pager_input_hint\");\n      ellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a');\n      return ellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click(function() {\n        var goPage, input;\n        if (!$(this).find('input').length) {\n          input = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>');\n          if (Steedos.isMobile()) {\n            input.css({\n              width: \"52px\",\n              height: \"20px\"\n            });\n          } else {\n            input.css({\n              width: \"52px\",\n              height: \"16px\"\n            });\n          }\n          input.attr(\"title\", title).attr(\"placeholder\", title);\n          $(this).empty().append(input);\n          goPage = function(index) {\n            var pages;\n            if (index > 0) {\n              pages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength);\n              if (index > pages) {\n                index = pages;\n              }\n              index--;\n              return settings.oInstance.DataTable().page(index).draw('page');\n            }\n          };\n          input.blur(function(e) {\n            var currentPage;\n            currentPage = $(this).val();\n            goPage(currentPage);\n            return $(this).parent().html('...');\n          });\n          return input.keydown(function(e) {\n            var currentPage;\n            if (e.keyCode.toString() === \"13\") {\n              currentPage = $(this).val();\n              return goPage(currentPage);\n            }\n          });\n        }\n      });\n    },\n    createdRow: function(row, data, dataIndex) {\n      if (Meteor.isClient) {\n        if (data._id === FlowRouter.current().params.instanceId) {\n          return row.setAttribute(\"class\", \"selected\");\n        }\n      }\n    },\n    columns: [\n      {\n        data: \"_id\",\n        orderable: false,\n        render: function(val, type, doc) {\n          var agent_view, cc_view, flow_name, instanceNamePriorityClass, modified, modifiedFromNow, modifiedString, priorityIcon, priorityIconClass, priorityValue, ref, ref1, step_current_name_view, unread;\n          modifiedString = moment(doc.modified).format('YYYY-MM-DD');\n          modified = doc.modified;\n          if (Session.get(\"box\") === 'inbox' && doc.state !== 'draft') {\n            modified = doc.start_date || doc.modified;\n          }\n          if (Session.get(\"box\") === 'outbox' || Session.get(\"box\") === 'monitor') {\n            modified = doc.submit_date || doc.submit_date;\n          }\n          modifiedFromNow = Steedos.momentReactiveFromNow(modified);\n          flow_name = doc.flow_name;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.is_cc && !((ref = doc.inbox_users) != null ? ref.includes(Meteor.userId()) : void 0) && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n            step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.current_step_name + \")</span></div>\";\n          } else {\n            if (Session.get(\"box\") !== 'draft' && doc.current_step_name) {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.current_step_name + \")</span></div>\";\n            } else {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"</div>\";\n            }\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name && Session.get(\"box\") === 'inbox') {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIcon = \"\";\n          priorityIconClass = \"\";\n          priorityValue = (ref1 = doc.values) != null ? ref1.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.name + cc_view + agent_view + \"\\n\t<span>\" + doc.applicant_name + \"</span>\\n</div>\\n<div class='instance-detail'>\" + step_current_name_view + \"\\n\t<span class='instance-modified' title='\" + modifiedString + \"'>\" + modifiedFromNow + \"</span>\\n</div>\";\n        }\n      }, {\n        data: \"applicant_organization_name\",\n        title: t(\"instances_applicant_organization_name\"),\n        visible: false\n      }, {\n        data: \"name\",\n        title: t(\"instances_name\"),\n        render: function(val, type, doc) {\n          var agent_view, cc_view, instanceNamePriorityClass, priorityIconClass, priorityValue, ref, ref1, step_current_name_view, unread;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.is_cc && !((ref = doc.inbox_users) != null ? ref.includes(Meteor.userId()) : void 0) && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name) {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIconClass = \"\";\n          priorityValue = (ref1 = doc.values) != null ? ref1.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.name + cc_view + agent_view + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"applicant_name\",\n        title: t(\"instances_applicant_name\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"submit_date\",\n        title: t(\"instances_submit_date\"),\n        render: function(val, type, doc) {\n          if (doc.submit_date) {\n            return moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"flow_name\",\n        title: t(\"instances_flow\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"current_step_name\",\n        title: t(\"instances_step_current_name\"),\n        render: function(val, type, doc) {\n          var cc_tag, judge, step_current_name;\n          if (doc.state === \"completed\") {\n            judge = doc.final_decision || \"approved\";\n          }\n          step_current_name = doc.current_step_name || '';\n          cc_tag = '';\n          if (doc.cc_count > 0) {\n            cc_tag = TAPi18n.__('cc_tag');\n          }\n          return \"<div class=\\\"step-current-state \" + judge + \"\\\">\" + step_current_name + cc_tag + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"modified\",\n        title: t(\"instances_modified\"),\n        render: function(val, type, doc) {\n          return moment(doc.modified).format('YYYY-MM-DD HH:mm');\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"start_date\",\n        title: t(\"instances_start_date\"),\n        render: function(val, type, doc) {\n          if (doc.start_date) {\n            return moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"my_finish_date\",\n        render: function(val, type, doc) {\n          if (doc.my_finish_date) {\n            return moment(doc.my_finish_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"modified\",\n        visible: false\n      }, {\n        data: \"keywords\",\n        visible: false\n      }, {\n        data: \"is_archived\",\n        render: function(val, type, doc) {\n          var ref;\n          if ((doc != null ? (ref = doc.values) != null ? ref.record_need : void 0 : void 0) && doc.values.record_need === \"true\") {\n            if (doc != null ? doc.is_archived : void 0) {\n              return t(\"YES\");\n            }\n            return t(\"NO\");\n          }\n        },\n        visible: false,\n        orderable: false\n      }\n    ],\n    dom: (function() {\n      if (Steedos.isMobile()) {\n        return 'tp';\n      } else {\n        return 'tpl';\n      }\n    })(),\n    order: [[4, \"desc\"]],\n    extraFields: [\"form\", \"flow\", \"inbox_users\", \"state\", \"space\", \"applicant\", \"form_version\", \"flow_version\", \"is_cc\", \"cc_count\", \"is_read\", \"current_step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n    lengthChange: true,\n    lengthMenu: [10, 15, 20, 25, 50, 100],\n    pageLength: 10,\n    info: false,\n    searching: true,\n    responsive: {\n      details: false\n    },\n    autoWidth: false,\n    changeSelector: function(selector, userId) {\n      var ref, space, space_user;\n      if (!userId) {\n        return {\n          _id: -1\n        };\n      }\n      space = selector.space;\n      if (!space) {\n        if ((selector != null ? (ref = selector.$and) != null ? ref.length : void 0 : void 0) > 0) {\n          space = selector.$and.getProperty('space')[0];\n        }\n      }\n      if (!space) {\n        return {\n          _id: -1\n        };\n      }\n      space_user = db.space_users.findOne({\n        user: userId,\n        space: space\n      }, {\n        fields: {\n          _id: 1\n        }\n      });\n      if (!space_user) {\n        return {\n          _id: -1\n        };\n      }\n      return selector;\n    },\n    pagingType: \"numbers\"\n  };\n  if (flowId) {\n    key = \"instanceFlow\" + flowId;\n    options.name = key;\n    TabularTables.instances.fields = fields;\n    ins_fields = _handleListFields(TabularTables.instances.fields);\n    ins_fields.forEach(function(f) {\n      if (f.type !== 'table' && f.is_list_display) {\n        return options.columns.push({\n          data: f.name || f.code,\n          title: t(f.name || f.code),\n          visible: false,\n          orderable: false,\n          render: function(val, type, doc) {\n            var value, values;\n            values = doc.values || {};\n            value = values[f.code];\n            switch (f.type) {\n              case 'user':\n                value = value != null ? value.name : void 0;\n                break;\n              case 'group':\n                value = value != null ? value.fullname : void 0;\n                break;\n              case 'date':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD');\n                }\n                break;\n              case 'dateTime':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD HH:mm');\n                }\n                break;\n              case 'checkbox':\n                if (value === true || value === 'true') {\n                  value = TAPi18n.__(\"form_field_checkbox_yes\");\n                } else {\n                  value = TAPi18n.__(\"form_field_checkbox_no\");\n                }\n                break;\n              case 'odata':\n                if (value) {\n                  if (_.isArray(value)) {\n                    value = _.pluck(value, '@label').toString();\n                  } else {\n                    value = value['@label'];\n                  }\n                }\n            }\n            return value;\n          }\n        });\n      }\n    });\n  }\n  return options;\n};\n\ninstanceTasksListTableTabular = function(flowId, fields) {\n  var ins_fields, key, options;\n  options = {\n    name: \"instance_tasks\",\n    collection: db.instance_tasks,\n    pub: \"instance_tasks_tabular\",\n    onUnload: function() {\n      return Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n    },\n    drawCallback: function(settings) {\n      var ellipsisLink, emptyTd, title;\n      emptyTd = $(\".dataTables_empty\");\n      if (emptyTd.length) {\n        emptyTd[0].colSpan = \"6\";\n      }\n      if (!Steedos.isMobile() && !Steedos.isPad()) {\n        Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n        $(\".instance-list\").scrollTop(0).ready(function() {\n          return $(\".instance-list\").perfectScrollbar(\"update\");\n        });\n      } else {\n        $(\".instance-list\").scrollTop(0);\n      }\n      title = t(\"pager_input_hint\");\n      ellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a');\n      return ellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click(function() {\n        var goPage, input;\n        if (!$(this).find('input').length) {\n          input = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>');\n          if (Steedos.isMobile()) {\n            input.css({\n              width: \"52px\",\n              height: \"20px\"\n            });\n          } else {\n            input.css({\n              width: \"52px\",\n              height: \"16px\"\n            });\n          }\n          input.attr(\"title\", title).attr(\"placeholder\", title);\n          $(this).empty().append(input);\n          goPage = function(index) {\n            var pages;\n            if (index > 0) {\n              pages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength);\n              if (index > pages) {\n                index = pages;\n              }\n              index--;\n              return settings.oInstance.DataTable().page(index).draw('page');\n            }\n          };\n          input.blur(function(e) {\n            var currentPage;\n            currentPage = $(this).val();\n            goPage(currentPage);\n            return $(this).parent().html('...');\n          });\n          return input.keydown(function(e) {\n            var currentPage;\n            if (e.keyCode.toString() === \"13\") {\n              currentPage = $(this).val();\n              return goPage(currentPage);\n            }\n          });\n        }\n      });\n    },\n    createdRow: function(row, data, dataIndex) {\n      if (Meteor.isClient) {\n        if (data.instance === FlowRouter.current().params.instanceId) {\n          return row.setAttribute(\"class\", \"selected\");\n        }\n      }\n    },\n    columns: [\n      {\n        data: \"_id\",\n        orderable: false,\n        render: function(val, type, doc) {\n          var agent_view, cc_view, flow_name, instanceNamePriorityClass, modified, modifiedFromNow, modifiedString, priorityIcon, priorityIconClass, priorityValue, ref, step_current_name_view, unread;\n          modifiedString = moment(doc.modified).format('YYYY-MM-DD');\n          modified = doc.modified;\n          if (Session.get(\"box\") === 'inbox' && doc.instance_state !== 'draft') {\n            modified = doc.start_date || doc.modified;\n          }\n          if (Session.get(\"box\") === 'outbox') {\n            modified = doc.submit_date || doc.modified;\n          }\n          modifiedFromNow = Steedos.momentReactiveFromNow(modified);\n          flow_name = doc.flow_name;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.type === 'cc' && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n            step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.step_name + \")</span></div>\";\n          } else {\n            if (doc.step_name) {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.step_name + \")</span></div>\";\n            } else {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"</div>\";\n            }\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name && Session.get(\"box\") === 'inbox') {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIcon = \"\";\n          priorityIconClass = \"\";\n          priorityValue = (ref = doc.values) != null ? ref.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.instance_name + cc_view + agent_view + \"\\n\t<span>\" + doc.applicant_name + \"</span>\\n</div>\\n<div class='instance-detail'>\" + step_current_name_view + \"\\n\t<span class='instance-modified' title='\" + modifiedString + \"'>\" + modifiedFromNow + \"</span>\\n</div>\";\n        }\n      }, {\n        data: \"applicant_organization_name\",\n        title: t(\"instances_applicant_organization_name\"),\n        visible: false\n      }, {\n        data: \"instance_name\",\n        title: t(\"instances_name\"),\n        render: function(val, type, doc) {\n          var agent_view, cc_view, instanceNamePriorityClass, priorityIconClass, priorityValue, ref, ref1, step_current_name_view, unread;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.is_cc && !((ref = doc.inbox_users) != null ? ref.includes(Meteor.userId()) : void 0) && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name) {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIconClass = \"\";\n          priorityValue = (ref1 = doc.values) != null ? ref1.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.instance_name + cc_view + agent_view + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"applicant_name\",\n        title: t(\"instances_applicant_name\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"submit_date\",\n        title: t(\"instances_submit_date\"),\n        render: function(val, type, doc) {\n          if (doc.submit_date) {\n            return moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"flow_name\",\n        title: t(\"instances_flow\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"step_name\",\n        title: t(\"instances_step_current_name\"),\n        render: function(val, type, doc) {\n          var cc_tag, judge, step_current_name;\n          if (doc.instance_state === \"completed\") {\n            judge = doc.judge || \"approved\";\n          }\n          step_current_name = doc.step_name || '';\n          cc_tag = '';\n          if (doc.cc_count > 0) {\n            cc_tag = TAPi18n.__('cc_tag');\n          }\n          return \"<div class=\\\"step-current-state \" + judge + \"\\\">\" + step_current_name + cc_tag + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"modified\",\n        title: t(\"instances_modified\"),\n        render: function(val, type, doc) {\n          return moment(doc.modified).format('YYYY-MM-DD HH:mm');\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"start_date\",\n        title: t(\"instances_start_date\"),\n        render: function(val, type, doc) {\n          if (doc.start_date) {\n            return moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"finish_date\",\n        render: function(val, type, doc) {\n          if (doc.finish_date) {\n            return moment(doc.finish_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"modified\",\n        visible: false\n      }, {\n        data: \"keywords\",\n        visible: false\n      }, {\n        data: \"is_archived\",\n        render: function(val, type, doc) {\n          var ref;\n          if ((doc != null ? (ref = doc.values) != null ? ref.record_need : void 0 : void 0) && doc.values.record_need === \"true\") {\n            if (doc != null ? doc.is_archived : void 0) {\n              return t(\"YES\");\n            }\n            return t(\"NO\");\n          }\n        },\n        visible: false,\n        orderable: false\n      }\n    ],\n    dom: (function() {\n      if (Steedos.isMobile()) {\n        return 'tp';\n      } else {\n        return 'tpl';\n      }\n    })(),\n    order: [[4, \"desc\"]],\n    extraFields: [\"instance\", \"form\", \"flow\", \"inbox_users\", \"instance_state\", \"space\", \"applicant\", \"form_version\", \"flow_version\", \"type\", \"is_read\", \"step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n    lengthChange: true,\n    lengthMenu: [10, 15, 20, 25, 50, 100],\n    pageLength: 10,\n    info: false,\n    searching: true,\n    responsive: {\n      details: false\n    },\n    autoWidth: false,\n    changeSelector: function(selector, userId) {\n      var ref, space, space_user;\n      if (!userId) {\n        return {\n          _id: -1\n        };\n      }\n      space = selector.space;\n      if (!space) {\n        if ((selector != null ? (ref = selector.$and) != null ? ref.length : void 0 : void 0) > 0) {\n          space = selector.$and.getProperty('space')[0];\n        }\n      }\n      if (!space) {\n        return {\n          _id: -1\n        };\n      }\n      space_user = db.space_users.findOne({\n        user: userId,\n        space: space\n      }, {\n        fields: {\n          _id: 1\n        }\n      });\n      if (!space_user) {\n        return {\n          _id: -1\n        };\n      }\n      return selector;\n    },\n    pagingType: \"numbers\"\n  };\n  if (flowId) {\n    key = \"instanceFlow\" + flowId;\n    options.name = key;\n    TabularTables.instance_tasks.fields = fields;\n    ins_fields = _handleListFields(TabularTables.instance_tasks.fields);\n    ins_fields.forEach(function(f) {\n      if (f.type !== 'table' && f.is_list_display) {\n        return options.columns.push({\n          data: f.name || f.code,\n          title: t(f.name || f.code),\n          visible: false,\n          orderable: false,\n          render: function(val, type, doc) {\n            var value, values;\n            values = doc.values || {};\n            value = values[f.code];\n            switch (f.type) {\n              case 'user':\n                value = value != null ? value.name : void 0;\n                break;\n              case 'group':\n                value = value != null ? value.fullname : void 0;\n                break;\n              case 'date':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD');\n                }\n                break;\n              case 'dateTime':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD HH:mm');\n                }\n                break;\n              case 'checkbox':\n                if (value === true || value === 'true') {\n                  value = TAPi18n.__(\"form_field_checkbox_yes\");\n                } else {\n                  value = TAPi18n.__(\"form_field_checkbox_no\");\n                }\n                break;\n              case 'odata':\n                if (value) {\n                  if (_.isArray(value)) {\n                    value = _.pluck(value, '@label').toString();\n                  } else {\n                    value = value['@label'];\n                  }\n                }\n            }\n            return value;\n          }\n        });\n      }\n    });\n  }\n  return options;\n};\n\nMeteor.startup(function() {\n  TabularTables.instances = new Tabular.Table(instancesListTableTabular());\n  TabularTables.instance_tasks = new Tabular.Table(instanceTasksListTableTabular());\n  TabularTables.inbox_instances = new Tabular.Table(GetBoxInstancesTabularOptions(\"inbox\"));\n  return TabularTables.outbox_instances = new Tabular.Table(GetBoxInstancesTabularOptions(\"outbox\"));\n});\n\nGetBoxInstancesTabularOptions = function(box, flowId, fields) {\n  var key, options;\n  key = \"instanceFlow\" + box + flowId;\n  if (box === \"inbox\") {\n    options = _get_inbox_instances_tabular_options(flowId, fields);\n  } else if (box === \"outbox\") {\n    options = _get_outbox_instances_tabular_options(flowId, fields);\n  } else {\n    options = instancesListTableTabular(flowId, fields);\n    if (!flowId) {\n      options.name = \"inbox_instances\";\n    }\n  }\n  if (flowId) {\n    options.name = key;\n  }\n  return options;\n};\n\n_get_inbox_instances_tabular_options = function(flowId, fields) {\n  var options;\n  options = instanceTasksListTableTabular(flowId, fields);\n  if (!flowId) {\n    options.name = \"inbox_instances\";\n  }\n  options.order = [[8, \"desc\"]];\n  options.getSort = function(selector, sort) {\n    console.log('inbox_instances:', sort);\n    return sort;\n  };\n  return options;\n};\n\n_get_outbox_instances_tabular_options = function(flowId, fields) {\n  var options;\n  options = instanceTasksListTableTabular(flowId, fields);\n  if (!flowId) {\n    options.name = \"outbox_instances\";\n  }\n  options.order = [[9, -1]];\n  options.getSort = function(selector, sort) {\n    console.log('outbox_instances:', sort);\n    return sort;\n  };\n  return options;\n};\n\nif (Meteor.isClient) {\n  TabularTables.flowInstances = new ReactiveVar();\n}\n\nMeteor.startup(function() {\n  return Tracker.autorun(function(c) {\n    if (Meteor.isClient && !Steedos.isMobile()) {\n      if (Session.get(\"flowId\") && Session.get(\"box\") !== 'draft') {\n        return Meteor.call(\"newInstancesListTabular\", Session.get(\"box\"), Session.get(\"flowId\"), function(error, result) {\n          newInstancesListTabular(Session.get(\"box\"), Session.get(\"flowId\"), result);\n          return Template.instance_list._changeOrder();\n        });\n      }\n    }\n  });\n});\n\nnewInstancesListTabular = function(box, flowId, fields) {\n  var flow, key, ref, ref1, ref2;\n  if (!fields) {\n    flow = db.flows.findOne({\n      _id: flowId\n    }, {\n      fields: {\n        form: 1\n      }\n    });\n    fields = (ref = db.forms.findOne({\n      _id: flow != null ? flow.form : void 0\n    }, {\n      fields: {\n        'current.fields': 1\n      }\n    })) != null ? (ref1 = ref.current) != null ? ref1.fields : void 0 : void 0;\n  }\n  fields = _handleListFields(fields);\n  if ((fields != null ? (ref2 = fields.filterProperty(\"is_list_display\", true)) != null ? ref2.length : void 0 : void 0) > 0) {\n    key = \"instanceFlow\" + box + flowId;\n    if (Meteor.isClient) {\n      TabularTables.flowInstances.set(new Tabular.Table(GetBoxInstancesTabularOptions(box, flowId, fields)));\n    } else {\n      new Tabular.Table(GetBoxInstancesTabularOptions(box, flowId, fields));\n    }\n    return console.log(\"new TabularTables \", key);\n  }\n};\n\nif (Meteor.isServer) {\n  Meteor.methods({\n    newInstancesListTabular: function(box, flowId) {\n      var fields, flow, ref, ref1;\n      newInstancesListTabular(box, flowId);\n      flow = db.flows.findOne({\n        _id: flowId\n      }, {\n        fields: {\n          form: 1\n        }\n      });\n      fields = (ref = db.forms.findOne({\n        _id: flow != null ? flow.form : void 0\n      }, {\n        fields: {\n          'current.fields': 1\n        }\n      })) != null ? (ref1 = ref.current) != null ? ref1.fields : void 0 : void 0;\n      return fields;\n    }\n  });\n}\n"]} +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["meteor://💻app/packages/steedos:workflow/checkNpm.js","meteor://💻app/packages/steedos:workflow/lib/URI.js","meteor://💻app/packages/steedos_workflow/lib/core.coffee","meteor://💻app/lib/core.coffee","meteor://💻app/packages/steedos_workflow/lib/models/instance_tasks.coffee","meteor://💻app/packages/steedos_workflow/lib/models/auth_tokens.coffee","meteor://💻app/packages/steedos_workflow/client/lib/instance_readonly_template.coffee","meteor://💻app/client/lib/instance_readonly_template.coffee","meteor://💻app/packages/steedos_workflow/client/lib/template_manager.coffee","meteor://💻app/client/lib/template_manager.coffee","meteor://💻app/packages/steedos:workflow/client/coreform/inputTypes/coreform-table/steedos-table.js","meteor://💻app/packages/steedos_workflow/client/views/instance/_image_sign.coffee","meteor://💻app/client/views/instance/_image_sign.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_traces_handler.coffee","meteor://💻app/client/views/instance/_traces_handler.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_instance_form.coffee","meteor://💻app/client/views/instance/_instance_form.coffee","meteor://💻app/packages/steedos:workflow/client/views/instance/_instance_attachments.js","meteor://💻app/packages/steedos_workflow/client/views/instance/_instance_sign_text.coffee","meteor://💻app/client/views/instance/_instance_sign_text.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_traces_help.coffee","meteor://💻app/client/views/instance/_traces_help.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_related_instances.coffee","meteor://💻app/client/views/instance/_related_instances.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_related_records.coffee","meteor://💻app/client/views/instance/_related_records.coffee","meteor://💻app/packages/steedos:workflow/routes/getSpaceUsers.js","meteor://💻app/packages/steedos:workflow/routes/getFormulaUserObjects.js","meteor://💻app/packages/steedos:workflow/routes/init_formula_values.js","meteor://💻app/packages/steedos:workflow/routes/api_workflow_forward.js","meteor://💻app/packages/steedos_workflow/routes/test_webhook.coffee","meteor://💻app/routes/test_webhook.coffee","meteor://💻app/packages/steedos_workflow/server/methods/set_instance_step_approve.coffee","meteor://💻app/packages/steedos:workflow/server/methods/get_instance_data.js","meteor://💻app/packages/steedos:workflow/server/methods/save_instance.js","meteor://💻app/packages/steedos:workflow/server/methods/trace_approve_cc.js","meteor://💻app/packages/steedos:workflow/server/methods/forward_instance.js","meteor://💻app/packages/steedos:workflow/server/methods/cfs_instances.js","meteor://💻app/packages/steedos_workflow/server/methods/instance_approve.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_return.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_remind.coffee","meteor://💻app/packages/steedos_workflow/server/methods/next_step_users_not_found.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_number_rules.coffee","meteor://💻app/packages/steedos_workflow/server/methods/check_main_attach.coffee","meteor://💻app/packages/steedos_workflow/server/methods/related_instances.coffee","meteor://💻app/packages/steedos_workflow/server/methods/edit_flow_positions.coffee","meteor://💻app/packages/steedos_workflow/server/methods/start_flow.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_traces.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_batch.coffee","meteor://💻app/packages/steedos_workflow/server/methods/flow.coffee","meteor://💻app/packages/steedos_workflow/server/methods/hide_instance.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_value.coffee","meteor://💻app/packages/steedos_workflow/server/routes/instance.coffee","meteor://💻app/server/routes/instance.coffee","meteor://💻app/packages/steedos_workflow/server/routes/steedos_css.coffee","meteor://💻app/server/routes/steedos_css.coffee","meteor://💻app/packages/steedos_workflow/server/routes/instance_draft_view.coffee","meteor://💻app/server/routes/instance_draft_view.coffee","meteor://💻app/packages/steedos:workflow/server/lib/1_form_formula.js","meteor://💻app/packages/steedos_workflow/server/publications/categories.coffee","meteor://💻app/server/publications/categories.coffee","meteor://💻app/packages/steedos_workflow/server/publications/cfs_instances.coffee","meteor://💻app/server/publications/cfs_instances.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_positions.coffee","meteor://💻app/server/publications/flow_positions.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_positions_tabular.coffee","meteor://💻app/server/publications/flow_positions_tabular.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_roles.coffee","meteor://💻app/server/publications/flow_roles.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flows.coffee","meteor://💻app/server/publications/flows.coffee","meteor://💻app/packages/steedos_workflow/server/publications/forms.coffee","meteor://💻app/server/publications/forms.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_data.coffee","meteor://💻app/server/publications/instance_data.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_list.coffee","meteor://💻app/server/publications/instance_list.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_tabular.coffee","meteor://💻app/server/publications/instance_tabular.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_draft.coffee","meteor://💻app/server/publications/instance_draft.coffee","meteor://💻app/packages/steedos_workflow/server/publications/distributed_instances_state_by_ids.coffee","meteor://💻app/server/publications/distributed_instances_state_by_ids.coffee","meteor://💻app/packages/steedos_workflow/server/publications/related_instaces.coffee","meteor://💻app/server/publications/related_instaces.coffee","meteor://💻app/packages/steedos_workflow/server/publications/space_user_signs.coffee","meteor://💻app/server/publications/space_user_signs.coffee","meteor://💻app/packages/steedos_workflow/server/publications/user_inbox_instance.coffee","meteor://💻app/server/publications/user_inbox_instance.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_main_attach_template.coffee","meteor://💻app/server/publications/flow_main_attach_template.coffee","meteor://💻app/packages/steedos_workflow/server/flow-template/workflow_template.coffee","meteor://💻app/server/flow-template/workflow_template.coffee","meteor://💻app/packages/steedos_workflow/server/schedule/auto_finish_process_delegation.coffee","meteor://💻app/server/schedule/auto_finish_process_delegation.coffee","meteor://💻app/packages/steedos_workflow/server/schedule/timeout_auto_submit.coffee","meteor://💻app/server/schedule/timeout_auto_submit.coffee","meteor://💻app/packages/steedos_workflow/related_instances_tabular.coffee","meteor://💻app/related_instances_tabular.coffee","meteor://💻app/packages/steedos_workflow/tabular.coffee","meteor://💻app/tabular.coffee"],"names":["checkNpmVersions","module","link","v","root","factory","define","amd","URI","punycode","IPv6","SecondLevelDomains","SLD","_URI","url","base","_urlSupplied","arguments","length","_baseSupplied","undefined","TypeError","location","href","absoluteTo","version","p","prototype","hasOwn","Object","hasOwnProperty","escapeRegEx","string","replace","getType","value","String","toString","call","slice","isArray","obj","filterArrayValues","data","lookup","i","_match","test","splice","arrayContains","list","_type","match","arraysEqual","one","two","sort","l","trimSlashes","text","trim_expression","_parts","protocol","username","password","hostname","urn","port","path","query","fragment","duplicateQueryParameters","escapeQuerySpace","protocol_expression","idn_expression","punycode_expression","ip4_expression","ip6_expression","find_uri_expression","findUri","start","end","trim","defaultPorts","http","https","ftp","gopher","ws","wss","invalid_hostname_characters","domAttributes","getDomAttribute","node","nodeName","toLowerCase","type","escapeForDumbFirefox36","escape","strictEncodeURIComponent","encodeURIComponent","encode","decode","decodeURIComponent","iso8859","unescape","unicode","characters","pathname","expression","map","reserved","urnpath","encodeQuery","escaped","decodeQuery","e","_part","generateAccessor","_group","c","generateSegmentedPathFunction","_sep","_codingFuncName","_innerCodingFuncName","actualCodingFunc","segments","split","join","decodePath","decodeUrnPath","recodePath","recodeUrnPath","encodeReserved","parse","parts","pos","indexOf","substring","parseAuthority","parseHost","bracketPos","t","charAt","firstColon","firstSlash","nextColon","parseUserinfo","lastIndexOf","shift","parseQuery","items","splits","name","push","build","buildAuthority","buildHost","buildUserinfo","buildQuery","unique","key","buildQueryParameter","addQuery","concat","removeQuery","hasQuery","withinArray","_booly","Boolean","op","commonPath","Math","min","withinString","callback","options","_start","_end","_trim","_attributeOpen","lastIndex","exec","index","ignoreHtml","attributeOpen","max","search","ignore","result","ensureValidHostname","toASCII","noConflict","removeAll","unconflicted","URITemplate","deferBuild","_deferred_build","_string","clone","valueOf","generateSimpleAccessor","generatePrefixAccessor","_key","hash","res","_object","attribute","src","is","what","ip","ip4","ip6","sld","idn","relative","has","_protocol","_port","_hostname","scheme","x","origin","authority","host","userinfo","resource","subdomain","domain","sub","RegExp","tld","get","ReferenceError","directory","filename","decodePathSegment","mutatedDirectory","normalizePath","suffix","s","segment","separator","absolute","Error","pop","unshift","segmentCoded","q","setQuery","setSearch","addSearch","removeSearch","hasSearch","normalize","normalizeProtocol","normalizeQuery","normalizeFragment","normalizeHostname","normalizePort","best","_path","_was_relative","_leadingParents","_parent","_pos","normalizePathname","normalizeSearch","normalizeHash","d","readable","uri","toUnicode","qp","kv","resolved","properties","basedir","relativeTo","relativeParts","baseParts","common","relativePath","basePath","parents","equals","one_map","two_map","checked","one_query","two_query","Workflow","ImageSign","TracesHandler","TracesTemplate","InstanceformTemplate","InstanceAttachmentTemplate","InstanceSignText","RelatedInstances","RelatedRecords","InstanceMacro","context","TracesManager","isOpinionField_from_string","field_formula","includesOpinionField","form","form_version","_form_version","field_formulas","fields","Array","Meteor","isServer","uuflowManager","getFormVersion","db","forms","findOne","_id","form_versions","forEach","f","ref","console","log","f1","formula","_","some","helpers","instance_tasks","Collection","_simpleSchema","SimpleSchema","instance","trace","is_finished","user","user_name","handler","handler_name","handler_organization","handler_organization_name","handler_organization_fullname","start_date","Date","due_date","is_read","is_error","values","deadline","remind_date","reminded_count","Number","read_date","description","modified","modified_by","sign_show","judge","next_steps","finish_date","cost_time","space","instance_name","submitter","submitter_name","applicant","applicant_name","applicant_organization_name","submit_date","flow","flow_name","step","step_name","category_name","instance_state","distribute_from_instance","forward_from_instance","keywords","is_archived","category","auth_tokens","_getLocale","_getRequiredFields","_getStartStepEditableFields","_getStartStepRequiredFields","_getTemplateData","_getViewHtml","getLinkText","marked","require","InstanceReadOnlyTemplate","instance_attachment","afSelectUserRead","afFormGroupRead","afFormGroup","create","tempalteName","steedosData","template","templateCompiled","templateRenderFunction","SpacebarsCompiler","compile","isBody","eval","Template","Blaze","createInstanceSignText","instanceSignTextCompiled","instanceSignTextHtml","instanceSignTextRenderFunction","instanceSignText","createImageSign","imageSignCompiled","imageSignHtml","imageSignRenderFunction","imageSign","createTracesHanlder","tracesHanlderCompiled","tracesHanlderHtml","tracesHanlderRenderFunction","instance_traces_handler","init","item","label","detail_url","Steedos","absoluteUrl","getValue","field","locale","utcOffset","date","fieldOptions","hours","month","nameField","records","seconds","selectedOption","selectedOptions","splitedValues","t0","t1","uiSchema","year","n","itemSplits","encodeURI","error","is_multiselect","getProperty","fullname","TAPi18n","__","formatDate","formatTime","is_textarea","find","filter","is_percent","numberToPercentString","digits","numberToString","isClient","authRequest","JSON","stringify","async","objectFind","filters","fileName","filePreviewHtml","fileUrl","original","Creator","getObject","reference_to","NAME_FIELD_KEY","reference_to_field","getObjectNameFieldKey","getLabel","code","findPropertyByPK","getInstanceFormVersion","form_fields","current","where","historys","getFlowVersion","flow_version","flows","viewHtml","Assets","getText","ref1","toLocaleLowerCase","rev","is_required","steps","editableCode","startStep","keys","permissions","requiredFields","intersection","WorkflowManager","WorkflowManager_format","getAutoformSchemaValues","insname","ins_state","state","ins_final_decision","ins_code","ins_is_archived","ins_is_deleted","applicantContext","sessionUserId","editable","startStepEditableFields","passing","moment","format","getInstanceView","body","instanceCompiled","instanceRenderFunction","instanceTemplate","TemplateManager","getTemplate","templateName","instance_readonly_view","toHTMLWithData","getTracesView","traceCompiled","traceRenderFunction","tracesHtml","instance_style","trace_readonly_view","traces","getAttachmentView","attachmentCompiled","attachmentHtml","attachmentRenderFunction","attachments_readonly_view","getRelatedInstancesView","relatedInstancesCompiled","relatedInstancesHtml","relatedInstancesRenderFunction","related_instances_view","getRelatedRecordsView","relatedRecordsCompiled","relatedRecordsHtml","relatedRecordsRenderFunction","related_records_view","getOnLoadScript","form_script","getInstanceHtml","allCssLink","attachment","creatorService","cssHref","formDescription","formDescriptionHtml","html","ins_record_ids","instanceBoxStyle","jqHref","onLoadScript","openFileScript","related_instances","related_records","showTracesBtn","showTracesScript","traceCheck","width","settings","webservices","creator","record_ids","isMobile","showTrace","final_decision","showAttachments","isEmpty","tagger","styles","plugins","add_styles","formId","instance_title","pageTitle","pageTitleTrClass","val","CoreForm","pageTitleFieldName","handleTableTemplate","_export","table_fields","table_field","field_permission","pureCode","required","title_permission","removeSpecialCharacter","isOpinionField","tr_start","td_colspan","tr_end","includes","permission","_template","table","_templateHelps","steedos_instance","getInstance","atts","id","style","disabled","instanceId","form_types","ApproveManager","isReadOnly","steedos_form","innersubformContext","doc_values","Session","a","b","getAutoformSchema","instance_box_style","box","ins","print_template","instance_template","SteedosTable","checkItem","item_index","fieldObj","getField","fieldVal","getItemModalValue","sf_name","sfields","sf","InstanceManager","checkFormFieldValue","$","setTableItemValue","item_value","tableValue","getTableValue","getTableItemValue","removeTableItem","removed","setTableValue","getValidValue","validValue","handleData","instanceFields","getInstanceFields","getModalData","Form_formula","getFormulaFieldVariable","AutoForm","getFormValues","insertDoc","addItem","_item_value","getKeys","append","getTr","updateItem","tds","getRemoveTd","sfield","getTd","empty","runFormula","removeItem","hide","showModal","method","modalData","setTimeout","Modal","show","getCurrentDataForForm","ss","getFormSchema","schema","objectKeys","_makeGeneric","getThead","isObject","thead","trs","sf_length","wide_fields","filterProperty","is_wide","getTbody","sfieldsEditable","tbody","tr","td","td_value","getTDValue","view","CFDataManager","getFormulaSpaceUsers","u","getFormulaOrganizations","o","getFormulaOrganization","pluck","addInputType","valueOut","valueConverters","stringToStringArray","stringToNumber","stringToNumberArray","stringToBoolean","stringToBooleanArray","stringToDate","stringToDateArray","contextAdjust","maxlength","afTable","events","event","new_item_index","currentTarget","dataset","set","rendered","str","addItemTr","getCurrentStep","step_type","ccHasEditPermission","autorun","currentData","spaceUserSign","userId","space_user_signs","imageURL","sign","showSignImage","traceShowSignImage","objectUrl","object_name","record_id","app_id","getObjectUrl","unempty","unequals","include","ref2","ref3","getInstanceFlowVersion","approves","ref4","approve","judge_name","opinion_fields_code","sign_field_code","after_field","before_field","pre_fields","pre_wide_fields","sort_approve","order","p1","p2","_p1","_p2","getTime","_t","isTextarea","getCfClass","getTableThead","getTableBody","showLabel","templateData","getOpinionFieldStepsName","top_keywords","foo1","opinionFields","foo","json_formula","s1","error1","yijianlan","stepName","image_sign","only_cc_opinion","only_cc","default_description","only_handler","showCCOpinion","markDownToHtml","markDownString","Npm","Spacebars","SafeString","f_label","that","isSection","registerHelper","ins_attach_download_url","getPermissions","instanceformChangeEvent","preventDefault","openWindow","target","onCreated","compiled","instanceCustomTemplate","instanceView","renderFunction","View","instance_custom_template","onRendered","currentApprove","currentStep","formula_fields","instanceNumberFields","setInstanceFormApplicant","nextSteps","nextStepUsers","InstanceEvent","initEvents","getCurrentApprove","each","element","schemaKey","toastr","reason","getFieldValue","InstanceNumberRules","instanceNumberBuilder","trigger","run","showMainTitle","workflowMainAttachTitle","enabled_add_main_attachment","current_step","currentTrace","getCurrentTrace","main_attach_count","cfs","instances","count","distribute_main_attach_count","start_step","getStartStep","can_edit_main_attach","enabled_edit_normal_attachment","getFlow","upload_after_being_distributed","isCC","getCCStep","can_edit_normal_attach","main_attachment","main_attach","normal_attachments","selector","$ne","dfis","distribute_from_instances","$in","distribute_main","firstVersionMain","metadata","parent","attachmentUploadedAt","uploadedAt","firstVersion","sortBy","instanceIds","attachments_count","flow_files","files","isDraftAndFlowfilesExist","compact","attachments","$or","fetch","myApprove","myTrace","isInbox","defaultDescription","approve_sort","approvesGroup","approves_sorted","completed_date","hasNext","haveDescriptionApprove","is_completed","last","top_approves","union","top_approve","groupBy","handlerApproves","descriptionApproves","workflow","showBlankApproveDescription","_display","isMyApprove","myApproveDescription","approveId","now","isOpinionOfField","imageSignData","getLastSignApprove","getHandlerSignShowApproves","lastMyApproveDescription","showApprove","judge_description","is_approved","is_rejected","is_readed","addClass","dateFormat","getFullYear","getStepName","stepId","getInstanceStep","showDeleteButton","approved","from_user","isShowModificationButton","approve_admins","isShow","contains","isEditing","is_editing","isShowDescription","getApproveStatusIcon","approveJudge","autoSubmitted","approveStatusIcon","getApproveStatusText","approveStatusText","getApproveJudgeClass","isForward","showForwardDeleteButton","forward_instance","isDistribute","showDistributeDeleteButton","hasFlowAdminPermission","finishDateSchema","isAndroidOrIOS","autoform","optional","readonly","dateTimePickerOptions","ignoreReadonly","widgetPositioning","horizontal","finishDateValues","showTracesView","show_modal_traces_list","space_settings","getInstanceStateText","instance_id","getInstanceStateColor","cla","firstTrace","last_distribute_from","dis_info","$exists","created","created_by","UUflow_api","getNameForUser","users","from_user_name","isCCOrDistributeOrForwardTerminated","judgeTerminated","instanceExists","agentDescription","userName","traceName","traceId","handlerDoc","handlerId","users_can_read_cc_handler_detail_info","getContactInfoForUser","stopPropagation","calling","err","removeClass","success","allowMultiple","closest","target_user_id","openSafeObjectUrl","forward_space","forwardspace","forwardinstance","Tracker","afterFlush","on","scrollTop","finish_input","opinion_input","showRelatedInstaces","related_instaces","related_instace_url","isCordova","show_delete","showRelatedRecords","relatedRecordUrl","objcetName","ids","process","env","CREATOR_NODE_ENV","JsonRoutes","add","req","next","hashData","action","to_users","sendResult","stack","errors","errorMessage","message","workflowMethods","methods","set_instance_step_approve","ins_id","step_approve","stepsApprovesOptions","apply","set_instance_skip_steps","get_instance_data","formCached","flowCached","draft_save_instance","inbox_save_instance","cc_do","cc_user_ids","cc_read","cc_submit","cc_remove","batch_cancel_cc","approve_ids","cc_save","space_id","flow_id","hasSaveInstanceToAttachment","isForwardAttachments","selectedUsers","action_type","related","from_approve_id","forward_remove","trace_id","approve_id","cancelDistribute","cfs_instances_remove","file_id","cfs_instances_set_current","cfs_instances_lock","user_id","cfs_instances_unlock","download_space_instance_attachments_to_disk","spaceId","cfsRecordIds","set_approve_have_read","change_approve_info","update_approve_sign","sign_type","lastSignApprove","update_sign_show","objs","myApprove_id","instance_return","instance_remind","remind_users","remind_count","remind_deadline","action_types","next_step_users_not_found","deal_type","params","_eval","check_main_attach","remove_related","re_ins_id","update_instance_related","updateFlowPosition","updateFlowRole","start_flow","flowId","get_instance_traces","categoryId","flowIds","get_batch_instances","get_batch_instances_count","get_my_approves","change_flow_state","hide_instance","insId","is_hidden","getInstanceValues","Cookies","getInstanceReadOnly","_hasPermission","_locale","_parent_instances","dataBuf","hide_traces","spaceUserCount","getAPILoginUser","access_token","getUserIdFromAccessToken","spaces","space_users","hasInstancePermissions","_parent_id","_parent_ins","charset","Buffer","setHeader","statusCode","ret_sync_token","spaceUser","spaceUserOrganizations","sync_token","APIAuthenticationCheck","headers","isSpaceAdmin","organizations","canMonitor","canAdmin","$gt","$nin","inbox_uers","cc_users","outbox_users","skip","limit","copies","allCss","WebApp","getRefreshableAssets","css","rootUrl","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","ROOT_URL","endsWith","h","g","m","k","getEach","uniq","mixin","dest","handerUserObject","organization","hr","sort_no","mobile","work_phone","position","userRoles","roles","handerOrgObject","org","init_formula_values","autoFormDoc","approver","__values","tableFields","tableValues","formulaTableValues","__tableValues","tablefield","getFormulaUserObjects","getFormulaOrgObjects","getFormulaUserObject","publish","check","ready","categories","app","flow_positions","role","publishComposite","tableName","Match","Optional","unblock","children","flow_roles","createTemplateFormAndFlow","perms","company_id","distribute_optional_users","distribute_to_self","enable_amisform","versionId","handle","self","latest","observeChanges","changed","added","onStop","stop","flow_ids","distribute_end_notification","allow_select_step","amis_schema","getMiniInstance","getMyapproveModified","instance_fields_0","miniApproveFields","needChange","triggerChangeFields","triggerChangeFieldsValues","myApproveModifieds","_instanceId","_trace","changeFields","_change","_rev","_my_approve_modifieds","isEqual","getInstanceTraces","_insId","inbox_users","asyncLastFinishedApprove","lastFinishedApproveAggregate","instanceid","dataMap","operation","rawCollection","aggregate","toArray","doc","isFunction","wrapAsync","getMyApprove","getMyLastFinishedApprove","getStepCurrentName","notFinishedTraces","agent","stepCurrentName","$slice","myLastFinishedApprove","agent_user_name","my_finish_date","is_cc","cc_count","tabularName","instance_ids","related_instance_ids","_async_get_flow_instances_aggregate","_get_flow_instances_aggregate","_items","$match","$group","$sum","_changeData","_flowsData","_init","dataItem","flow_instance","observe","getCollection","workflowTemplate","startup","absolute_path_cn","absolute_path_us","filesList_cn","filesList_us","fs","mime","path_cn","path_us","readFileList","pathDir","filesList","readdirSync","stat","statSync","isDirectory","workflowTemplates","resolve","existsSync","file","readFileSync","go_next","rule","schedule","cron","auto_finish_process_delegation","scheduleJob","bindEnvironment","time","process_delegation_rules","update","enabled","end_time","$lte","$set","multi","timeEnd","timeout_auto_submit","timeoutAutoSubmit","TabularTables","related_instances_tabular","Tabular","Table","collection","columns","title","orderable","render","input","step_current_name","current_step_name","dom","lengthChange","extraFields","pageLength","info","searching","responsive","details","autoWidth","changeSelector","curSpaceUser","$and","admins","fl","extend","GetBoxInstancesTabularOptions","_get_inbox_instances_tabular_options","_get_outbox_instances_tabular_options","_handleListFields","instanceTasksListTableTabular","instancesListTableTabular","newInstancesListTabular","updateTabularTitle","subs","SubsManager","ins_fields","pub","onUnload","instance_list","_tableColumns","drawCallback","ellipsisLink","emptyTd","colSpan","isPad","perfectScrollbar","oInstance","attr","click","goPage","height","pages","ceil","fnRecordsDisplay","_iDisplayLength","DataTable","page","draw","blur","currentPage","keydown","keyCode","createdRow","row","dataIndex","FlowRouter","setAttribute","agent_view","cc_view","instanceNamePriorityClass","modifiedFromNow","modifiedString","priorityIcon","priorityIconClass","priorityValue","step_current_name_view","unread","momentReactiveFromNow","priority","visible","cc_tag","record_need","lengthMenu","space_user","pagingType","is_list_display","inbox_instances","outbox_instances","getSort","flowInstances","ReactiveVar","_changeOrder"],"mappings":"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AlB,CAAsB,CAAtB,CAAL;;AAEA,QAAG1wB,QAAH;AACC,aAAOqE,OAAOsH,WAAP,CAAmB,WAAS8kB,UAAT,GAAoB,QAApB,GAA4BhZ,EAA/C,CAAP;AADD;AAGC,aAAO/L,QAAQC,WAAR,CAAoB,WAAS8kB,UAAT,GAAoB,QAApB,GAA4BhZ,EAAhD,CAAP;ACIE;AD9BJ;AAAA,CADD,C;;;;;;;;;;;;;;;;;;;;;;;AEAA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;AC/BA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;AC/BA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AAEA;AACA;AAEA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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","file":"/packages/steedos_workflow.js","sourcesContent":["import { checkNpmVersions } from 'meteor/tmeasday:check-npm-versions';\ncheckNpmVersions({\n\t\"node-schedule\": \"^1.3.1\",\n\t\"xml2js\": \"^0.4.19\",\n}, 'steedos:workflow');","/*!\n * URI.js - Mutating URLs\n *\n * Version: 1.17.0\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/\n *\n * Licensed under\n *   MIT License http://www.opensource.org/licenses/mit-license\n *   GPL v3 http://opensource.org/licenses/GPL-3.0\n *\n */\n(function (root, factory) {\n\t'use strict';\n\t// https://github.com/umdjs/umd/blob/master/returnExports.js\n\t// if (typeof exports === 'object') {\n\t//   // Node\n\t//   module.exports = factory(require('./punycode'), require('./IPv6'), require('./SecondLevelDomains'));\n\t// } else\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine(['./punycode', './IPv6', './SecondLevelDomains'], factory);\n\t} else {\n\t\t// Browser globals (root is window)\n\t\troot.URI = factory(root.punycode, root.IPv6, root.SecondLevelDomains, root);\n\t}\n}(this, function (punycode, IPv6, SLD, root) {\n\t'use strict';\n\t/*global location, escape, unescape */\n\t// FIXME: v2.0.0 renamce non-camelCase properties to uppercase\n\t/*jshint camelcase: false */\n\n\t// save current URI variable, if any\n\tvar _URI = root && root.URI;\n\n\tfunction URI(url, base) {\n\t\tvar _urlSupplied = arguments.length >= 1;\n\t\tvar _baseSupplied = arguments.length >= 2;\n\n\t\t// Allow instantiation without the 'new' keyword\n\t\tif (!(this instanceof URI)) {\n\t\t\tif (_urlSupplied) {\n\t\t\t\tif (_baseSupplied) {\n\t\t\t\t\treturn new URI(url, base);\n\t\t\t\t}\n\n\t\t\t\treturn new URI(url);\n\t\t\t}\n\n\t\t\treturn new URI();\n\t\t}\n\n\t\tif (url === undefined) {\n\t\t\tif (_urlSupplied) {\n\t\t\t\tthrow new TypeError('undefined is not a valid argument for URI');\n\t\t\t}\n\n\t\t\tif (typeof location !== 'undefined') {\n\t\t\t\turl = location.href + '';\n\t\t\t} else {\n\t\t\t\turl = '';\n\t\t\t}\n\t\t}\n\n\t\tthis.href(url);\n\n\t\t// resolve to base according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#constructor\n\t\tif (base !== undefined) {\n\t\t\treturn this.absoluteTo(base);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tURI.version = '1.17.0';\n\n\tvar p = URI.prototype;\n\tvar hasOwn = Object.prototype.hasOwnProperty;\n\n\tfunction escapeRegEx(string) {\n\t\t// https://github.com/medialize/URI.js/commit/85ac21783c11f8ccab06106dba9735a31a86924d#commitcomment-821963\n\t\treturn string.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n\t}\n\n\tfunction getType(value) {\n\t\t// IE8 doesn't return [Object Undefined] but [Object Object] for undefined value\n\t\tif (value === undefined) {\n\t\t\treturn 'Undefined';\n\t\t}\n\n\t\treturn String(Object.prototype.toString.call(value)).slice(8, -1);\n\t}\n\n\tfunction isArray(obj) {\n\t\treturn getType(obj) === 'Array';\n\t}\n\n\tfunction filterArrayValues(data, value) {\n\t\tvar lookup = {};\n\t\tvar i, length;\n\n\t\tif (getType(value) === 'RegExp') {\n\t\t\tlookup = null;\n\t\t} else if (isArray(value)) {\n\t\t\tfor (i = 0, length = value.length; i < length; i++) {\n\t\t\t\tlookup[value[i]] = true;\n\t\t\t}\n\t\t} else {\n\t\t\tlookup[value] = true;\n\t\t}\n\n\t\tfor (i = 0, length = data.length; i < length; i++) {\n\t\t\t/*jshint laxbreak: true */\n\t\t\tvar _match = lookup && lookup[data[i]] !== undefined\n\t\t\t\t|| !lookup && value.test(data[i]);\n\t\t\t/*jshint laxbreak: false */\n\t\t\tif (_match) {\n\t\t\t\tdata.splice(i, 1);\n\t\t\t\tlength--;\n\t\t\t\ti--;\n\t\t\t}\n\t\t}\n\n\t\treturn data;\n\t}\n\n\tfunction arrayContains(list, value) {\n\t\tvar i, length;\n\n\t\t// value may be string, number, array, regexp\n\t\tif (isArray(value)) {\n\t\t\t// Note: this can be optimized to O(n) (instead of current O(m * n))\n\t\t\tfor (i = 0, length = value.length; i < length; i++) {\n\t\t\t\tif (!arrayContains(list, value[i])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\n\t\tvar _type = getType(value);\n\t\tfor (i = 0, length = list.length; i < length; i++) {\n\t\t\tif (_type === 'RegExp') {\n\t\t\t\tif (typeof list[i] === 'string' && list[i].match(value)) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else if (list[i] === value) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tfunction arraysEqual(one, two) {\n\t\tif (!isArray(one) || !isArray(two)) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// arrays can't be equal if they have different amount of content\n\t\tif (one.length !== two.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tone.sort();\n\t\ttwo.sort();\n\n\t\tfor (var i = 0, l = one.length; i < l; i++) {\n\t\t\tif (one[i] !== two[i]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tfunction trimSlashes(text) {\n\t\tvar trim_expression = /^\\/+|\\/+$/g;\n\t\treturn text.replace(trim_expression, '');\n\t}\n\n\tURI._parts = function() {\n\t\treturn {\n\t\t\tprotocol: null,\n\t\t\tusername: null,\n\t\t\tpassword: null,\n\t\t\thostname: null,\n\t\t\turn: null,\n\t\t\tport: null,\n\t\t\tpath: null,\n\t\t\tquery: null,\n\t\t\tfragment: null,\n\t\t\t// state\n\t\t\tduplicateQueryParameters: URI.duplicateQueryParameters,\n\t\t\tescapeQuerySpace: URI.escapeQuerySpace\n\t\t};\n\t};\n\t// state: allow duplicate query parameters (a=1&a=1)\n\tURI.duplicateQueryParameters = false;\n\t// state: replaces + with %20 (space in query strings)\n\tURI.escapeQuerySpace = true;\n\t// static properties\n\tURI.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;\n\tURI.idn_expression = /[^a-z0-9\\.-]/i;\n\tURI.punycode_expression = /(xn--)/i;\n\t// well, 333.444.555.666 matches, but it sure ain't no IPv4 - do we care?\n\tURI.ip4_expression = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\n\t// credits to Rich Brown\n\t// source: http://forums.intermapper.com/viewtopic.php?p=1096#1096\n\t// specification: http://www.ietf.org/rfc/rfc4291.txt\n\tURI.ip6_expression = /^\\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\s*$/;\n\t// expression used is \"gruber revised\" (@gruber v2) determined to be the\n\t// best solution in a regex-golf we did a couple of ages ago at\n\t// * http://mathiasbynens.be/demo/url-regex\n\t// * http://rodneyrehm.de/t/url-regex.html\n\tURI.find_uri_expression = /\\b((?:[a-z][\\w-]+:(?:\\/{1,3}|[a-z0-9%])|www\\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}\\/)(?:[^\\s()<>]+|\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\))+(?:\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\)|[^\\s`!()\\[\\]{};:'\".,<>?«»“”‘’]))/ig;\n\tURI.findUri = {\n\t\t// valid \"scheme://\" or \"www.\"\n\t\tstart: /\\b(?:([a-z][a-z0-9.+-]*:\\/\\/)|www\\.)/gi,\n\t\t// everything up to the next whitespace\n\t\tend: /[\\s\\r\\n]|$/,\n\t\t// trim trailing punctuation captured by end RegExp\n\t\ttrim: /[`!()\\[\\]{};:'\".,<>?«»“”„‘’]+$/\n\t};\n\t// http://www.iana.org/assignments/uri-schemes.html\n\t// http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Well-known_ports\n\tURI.defaultPorts = {\n\t\thttp: '80',\n\t\thttps: '443',\n\t\tftp: '21',\n\t\tgopher: '70',\n\t\tws: '80',\n\t\twss: '443'\n\t};\n\t// allowed hostname characters according to RFC 3986\n\t// ALPHA DIGIT \"-\" \".\" \"_\" \"~\" \"!\" \"$\" \"&\" \"'\" \"(\" \")\" \"*\" \"+\" \",\" \";\" \"=\" %encoded\n\t// I've never seen a (non-IDN) hostname other than: ALPHA DIGIT . -\n\tURI.invalid_hostname_characters = /[^a-zA-Z0-9\\.-]/;\n\t// map DOM Elements to their URI attribute\n\tURI.domAttributes = {\n\t\t'a': 'href',\n\t\t'blockquote': 'cite',\n\t\t'link': 'href',\n\t\t'base': 'href',\n\t\t'script': 'src',\n\t\t'form': 'action',\n\t\t'img': 'src',\n\t\t'area': 'href',\n\t\t'iframe': 'src',\n\t\t'embed': 'src',\n\t\t'source': 'src',\n\t\t'track': 'src',\n\t\t'input': 'src', // but only if type=\"image\"\n\t\t'audio': 'src',\n\t\t'video': 'src'\n\t};\n\tURI.getDomAttribute = function(node) {\n\t\tif (!node || !node.nodeName) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tvar nodeName = node.nodeName.toLowerCase();\n\t\t// <input> should only expose src for type=\"image\"\n\t\tif (nodeName === 'input' && node.type !== 'image') {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn URI.domAttributes[nodeName];\n\t};\n\n\tfunction escapeForDumbFirefox36(value) {\n\t\t// https://github.com/medialize/URI.js/issues/91\n\t\treturn escape(value);\n\t}\n\n\t// encoding / decoding according to RFC3986\n\tfunction strictEncodeURIComponent(string) {\n\t\t// see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent\n\t\treturn encodeURIComponent(string)\n\t\t\t.replace(/[!'()*]/g, escapeForDumbFirefox36)\n\t\t\t.replace(/\\*/g, '%2A');\n\t}\n\tURI.encode = strictEncodeURIComponent;\n\tURI.decode = decodeURIComponent;\n\tURI.iso8859 = function() {\n\t\tURI.encode = escape;\n\t\tURI.decode = unescape;\n\t};\n\tURI.unicode = function() {\n\t\tURI.encode = strictEncodeURIComponent;\n\t\tURI.decode = decodeURIComponent;\n\t};\n\tURI.characters = {\n\t\tpathname: {\n\t\t\tencode: {\n\t\t\t\t// RFC3986 2.1: For consistency, URI producers and normalizers should\n\t\t\t\t// use uppercase hexadecimal digits for all percent-encodings.\n\t\t\t\texpression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t// -._~!'()*\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%26': '&',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '=',\n\t\t\t\t\t'%3A': ':',\n\t\t\t\t\t'%40': '@'\n\t\t\t\t}\n\t\t\t},\n\t\t\tdecode: {\n\t\t\t\texpression: /[\\/\\?#]/g,\n\t\t\t\tmap: {\n\t\t\t\t\t'/': '%2F',\n\t\t\t\t\t'?': '%3F',\n\t\t\t\t\t'#': '%23'\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\treserved: {\n\t\t\tencode: {\n\t\t\t\t// RFC3986 2.1: For consistency, URI producers and normalizers should\n\t\t\t\t// use uppercase hexadecimal digits for all percent-encodings.\n\t\t\t\texpression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t// gen-delims\n\t\t\t\t\t'%3A': ':',\n\t\t\t\t\t'%2F': '/',\n\t\t\t\t\t'%3F': '?',\n\t\t\t\t\t'%23': '#',\n\t\t\t\t\t'%5B': '[',\n\t\t\t\t\t'%5D': ']',\n\t\t\t\t\t'%40': '@',\n\t\t\t\t\t// sub-delims\n\t\t\t\t\t'%21': '!',\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%26': '&',\n\t\t\t\t\t'%27': '\\'',\n\t\t\t\t\t'%28': '(',\n\t\t\t\t\t'%29': ')',\n\t\t\t\t\t'%2A': '*',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '='\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\turnpath: {\n\t\t\t// The characters under `encode` are the characters called out by RFC 2141 as being acceptable\n\t\t\t// for usage in a URN. RFC2141 also calls out \"-\", \".\", and \"_\" as acceptable characters, but\n\t\t\t// these aren't encoded by encodeURIComponent, so we don't have to call them out here. Also\n\t\t\t// note that the colon character is not featured in the encoding map; this is because URI.js\n\t\t\t// gives the colons in URNs semantic meaning as the delimiters of path segements, and so it\n\t\t\t// should not appear unencoded in a segment itself.\n\t\t\t// See also the note above about RFC3986 and capitalalized hex digits.\n\t\t\tencode: {\n\t\t\t\texpression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t'%21': '!',\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%27': '\\'',\n\t\t\t\t\t'%28': '(',\n\t\t\t\t\t'%29': ')',\n\t\t\t\t\t'%2A': '*',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '=',\n\t\t\t\t\t'%40': '@'\n\t\t\t\t}\n\t\t\t},\n\t\t\t// These characters are the characters called out by RFC2141 as \"reserved\" characters that\n\t\t\t// should never appear in a URN, plus the colon character (see note above).\n\t\t\tdecode: {\n\t\t\t\texpression: /[\\/\\?#:]/g,\n\t\t\t\tmap: {\n\t\t\t\t\t'/': '%2F',\n\t\t\t\t\t'?': '%3F',\n\t\t\t\t\t'#': '%23',\n\t\t\t\t\t':': '%3A'\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\tURI.encodeQuery = function(string, escapeQuerySpace) {\n\t\tvar escaped = URI.encode(string + '');\n\t\tif (escapeQuerySpace === undefined) {\n\t\t\tescapeQuerySpace = URI.escapeQuerySpace;\n\t\t}\n\n\t\treturn escapeQuerySpace ? escaped.replace(/%20/g, '+') : escaped;\n\t};\n\tURI.decodeQuery = function(string, escapeQuerySpace) {\n\t\tstring += '';\n\t\tif (escapeQuerySpace === undefined) {\n\t\t\tescapeQuerySpace = URI.escapeQuerySpace;\n\t\t}\n\n\t\ttry {\n\t\t\treturn URI.decode(escapeQuerySpace ? string.replace(/\\+/g, '%20') : string);\n\t\t} catch(e) {\n\t\t\t// we're not going to mess with weird encodings,\n\t\t\t// give up and return the undecoded original string\n\t\t\t// see https://github.com/medialize/URI.js/issues/87\n\t\t\t// see https://github.com/medialize/URI.js/issues/92\n\t\t\treturn string;\n\t\t}\n\t};\n\t// generate encode/decode path functions\n\tvar _parts = {'encode':'encode', 'decode':'decode'};\n\tvar _part;\n\tvar generateAccessor = function(_group, _part) {\n\t\treturn function(string) {\n\t\t\ttry {\n\t\t\t\treturn URI[_part](string + '').replace(URI.characters[_group][_part].expression, function(c) {\n\t\t\t\t\treturn URI.characters[_group][_part].map[c];\n\t\t\t\t});\n\t\t\t} catch (e) {\n\t\t\t\t// we're not going to mess with weird encodings,\n\t\t\t\t// give up and return the undecoded original string\n\t\t\t\t// see https://github.com/medialize/URI.js/issues/87\n\t\t\t\t// see https://github.com/medialize/URI.js/issues/92\n\t\t\t\treturn string;\n\t\t\t}\n\t\t};\n\t};\n\n\tfor (_part in _parts) {\n\t\tURI[_part + 'PathSegment'] = generateAccessor('pathname', _parts[_part]);\n\t\tURI[_part + 'UrnPathSegment'] = generateAccessor('urnpath', _parts[_part]);\n\t}\n\n\tvar generateSegmentedPathFunction = function(_sep, _codingFuncName, _innerCodingFuncName) {\n\t\treturn function(string) {\n\t\t\t// Why pass in names of functions, rather than the function objects themselves? The\n\t\t\t// definitions of some functions (but in particular, URI.decode) will occasionally change due\n\t\t\t// to URI.js having ISO8859 and Unicode modes. Passing in the name and getting it will ensure\n\t\t\t// that the functions we use here are \"fresh\".\n\t\t\tvar actualCodingFunc;\n\t\t\tif (!_innerCodingFuncName) {\n\t\t\t\tactualCodingFunc = URI[_codingFuncName];\n\t\t\t} else {\n\t\t\t\tactualCodingFunc = function(string) {\n\t\t\t\t\treturn URI[_codingFuncName](URI[_innerCodingFuncName](string));\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tvar segments = (string + '').split(_sep);\n\n\t\t\tfor (var i = 0, length = segments.length; i < length; i++) {\n\t\t\t\tsegments[i] = actualCodingFunc(segments[i]);\n\t\t\t}\n\n\t\t\treturn segments.join(_sep);\n\t\t};\n\t};\n\n\t// This takes place outside the above loop because we don't want, e.g., encodeUrnPath functions.\n\tURI.decodePath = generateSegmentedPathFunction('/', 'decodePathSegment');\n\tURI.decodeUrnPath = generateSegmentedPathFunction(':', 'decodeUrnPathSegment');\n\tURI.recodePath = generateSegmentedPathFunction('/', 'encodePathSegment', 'decode');\n\tURI.recodeUrnPath = generateSegmentedPathFunction(':', 'encodeUrnPathSegment', 'decode');\n\n\tURI.encodeReserved = generateAccessor('reserved', 'encode');\n\n\tURI.parse = function(string, parts) {\n\t\tvar pos;\n\t\tif (!parts) {\n\t\t\tparts = {};\n\t\t}\n\t\t// [protocol\"://\"[username[\":\"password]\"@\"]hostname[\":\"port]\"/\"?][path][\"?\"querystring][\"#\"fragment]\n\n\t\t// extract fragment\n\t\tpos = string.indexOf('#');\n\t\tif (pos > -1) {\n\t\t\t// escaping?\n\t\t\tparts.fragment = string.substring(pos + 1) || null;\n\t\t\tstring = string.substring(0, pos);\n\t\t}\n\n\t\t// extract query\n\t\tpos = string.indexOf('?');\n\t\tif (pos > -1) {\n\t\t\t// escaping?\n\t\t\tparts.query = string.substring(pos + 1) || null;\n\t\t\tstring = string.substring(0, pos);\n\t\t}\n\n\t\t// extract protocol\n\t\tif (string.substring(0, 2) === '//') {\n\t\t\t// relative-scheme\n\t\t\tparts.protocol = null;\n\t\t\tstring = string.substring(2);\n\t\t\t// extract \"user:pass@host:port\"\n\t\t\tstring = URI.parseAuthority(string, parts);\n\t\t} else {\n\t\t\tpos = string.indexOf(':');\n\t\t\tif (pos > -1) {\n\t\t\t\tparts.protocol = string.substring(0, pos) || null;\n\t\t\t\tif (parts.protocol && !parts.protocol.match(URI.protocol_expression)) {\n\t\t\t\t\t// : may be within the path\n\t\t\t\t\tparts.protocol = undefined;\n\t\t\t\t} else if (string.substring(pos + 1, pos + 3) === '//') {\n\t\t\t\t\tstring = string.substring(pos + 3);\n\n\t\t\t\t\t// extract \"user:pass@host:port\"\n\t\t\t\t\tstring = URI.parseAuthority(string, parts);\n\t\t\t\t} else {\n\t\t\t\t\tstring = string.substring(pos + 1);\n\t\t\t\t\tparts.urn = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// what's left must be the path\n\t\tparts.path = string;\n\n\t\t// and we're done\n\t\treturn parts;\n\t};\n\tURI.parseHost = function(string, parts) {\n\t\t// Copy chrome, IE, opera backslash-handling behavior.\n\t\t// Back slashes before the query string get converted to forward slashes\n\t\t// See: https://github.com/joyent/node/blob/386fd24f49b0e9d1a8a076592a404168faeecc34/lib/url.js#L115-L124\n\t\t// See: https://code.google.com/p/chromium/issues/detail?id=25916\n\t\t// https://github.com/medialize/URI.js/pull/233\n\t\tstring = string.replace(/\\\\/g, '/');\n\n\t\t// extract host:port\n\t\tvar pos = string.indexOf('/');\n\t\tvar bracketPos;\n\t\tvar t;\n\n\t\tif (pos === -1) {\n\t\t\tpos = string.length;\n\t\t}\n\n\t\tif (string.charAt(0) === '[') {\n\t\t\t// IPv6 host - http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04#section-6\n\t\t\t// I claim most client software breaks on IPv6 anyways. To simplify things, URI only accepts\n\t\t\t// IPv6+port in the format [2001:db8::1]:80 (for the time being)\n\t\t\tbracketPos = string.indexOf(']');\n\t\t\tparts.hostname = string.substring(1, bracketPos) || null;\n\t\t\tparts.port = string.substring(bracketPos + 2, pos) || null;\n\t\t\tif (parts.port === '/') {\n\t\t\t\tparts.port = null;\n\t\t\t}\n\t\t} else {\n\t\t\tvar firstColon = string.indexOf(':');\n\t\t\tvar firstSlash = string.indexOf('/');\n\t\t\tvar nextColon = string.indexOf(':', firstColon + 1);\n\t\t\tif (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {\n\t\t\t\t// IPv6 host contains multiple colons - but no port\n\t\t\t\t// this notation is actually not allowed by RFC 3986, but we're a liberal parser\n\t\t\t\tparts.hostname = string.substring(0, pos) || null;\n\t\t\t\tparts.port = null;\n\t\t\t} else {\n\t\t\t\tt = string.substring(0, pos).split(':');\n\t\t\t\tparts.hostname = t[0] || null;\n\t\t\t\tparts.port = t[1] || null;\n\t\t\t}\n\t\t}\n\n\t\tif (parts.hostname && string.substring(pos).charAt(0) !== '/') {\n\t\t\tpos++;\n\t\t\tstring = '/' + string;\n\t\t}\n\n\t\treturn string.substring(pos) || '/';\n\t};\n\tURI.parseAuthority = function(string, parts) {\n\t\tstring = URI.parseUserinfo(string, parts);\n\t\treturn URI.parseHost(string, parts);\n\t};\n\tURI.parseUserinfo = function(string, parts) {\n\t\t// extract username:password\n\t\tvar firstSlash = string.indexOf('/');\n\t\tvar pos = string.lastIndexOf('@', firstSlash > -1 ? firstSlash : string.length - 1);\n\t\tvar t;\n\n\t\t// authority@ must come before /path\n\t\tif (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {\n\t\t\tt = string.substring(0, pos).split(':');\n\t\t\tparts.username = t[0] ? URI.decode(t[0]) : null;\n\t\t\tt.shift();\n\t\t\tparts.password = t[0] ? URI.decode(t.join(':')) : null;\n\t\t\tstring = string.substring(pos + 1);\n\t\t} else {\n\t\t\tparts.username = null;\n\t\t\tparts.password = null;\n\t\t}\n\n\t\treturn string;\n\t};\n\tURI.parseQuery = function(string, escapeQuerySpace) {\n\t\tif (!string) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// throw out the funky business - \"?\"[name\"=\"value\"&\"]+\n\t\tstring = string.replace(/&+/g, '&').replace(/^\\?*&*|&+$/g, '');\n\n\t\tif (!string) {\n\t\t\treturn {};\n\t\t}\n\n\t\tvar items = {};\n\t\tvar splits = string.split('&');\n\t\tvar length = splits.length;\n\t\tvar v, name, value;\n\n\t\tfor (var i = 0; i < length; i++) {\n\t\t\tv = splits[i].split('=');\n\t\t\tname = URI.decodeQuery(v.shift(), escapeQuerySpace);\n\t\t\t// no \"=\" is null according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#collect-url-parameters\n\t\t\tvalue = v.length ? URI.decodeQuery(v.join('='), escapeQuerySpace) : null;\n\n\t\t\tif (hasOwn.call(items, name)) {\n\t\t\t\tif (typeof items[name] === 'string' || items[name] === null) {\n\t\t\t\t\titems[name] = [items[name]];\n\t\t\t\t}\n\n\t\t\t\titems[name].push(value);\n\t\t\t} else {\n\t\t\t\titems[name] = value;\n\t\t\t}\n\t\t}\n\n\t\treturn items;\n\t};\n\n\tURI.build = function(parts) {\n\t\tvar t = '';\n\n\t\tif (parts.protocol) {\n\t\t\tt += parts.protocol + ':';\n\t\t}\n\n\t\tif (!parts.urn && (t || parts.hostname)) {\n\t\t\tt += '//';\n\t\t}\n\n\t\tt += (URI.buildAuthority(parts) || '');\n\n\t\tif (typeof parts.path === 'string') {\n\t\t\tif (parts.path.charAt(0) !== '/' && typeof parts.hostname === 'string') {\n\t\t\t\tt += '/';\n\t\t\t}\n\n\t\t\tt += parts.path;\n\t\t}\n\n\t\tif (typeof parts.query === 'string' && parts.query) {\n\t\t\tt += '?' + parts.query;\n\t\t}\n\n\t\tif (typeof parts.fragment === 'string' && parts.fragment) {\n\t\t\tt += '#' + parts.fragment;\n\t\t}\n\t\treturn t;\n\t};\n\tURI.buildHost = function(parts) {\n\t\tvar t = '';\n\n\t\tif (!parts.hostname) {\n\t\t\treturn '';\n\t\t} else if (URI.ip6_expression.test(parts.hostname)) {\n\t\t\tt += '[' + parts.hostname + ']';\n\t\t} else {\n\t\t\tt += parts.hostname;\n\t\t}\n\n\t\tif (parts.port) {\n\t\t\tt += ':' + parts.port;\n\t\t}\n\n\t\treturn t;\n\t};\n\tURI.buildAuthority = function(parts) {\n\t\treturn URI.buildUserinfo(parts) + URI.buildHost(parts);\n\t};\n\tURI.buildUserinfo = function(parts) {\n\t\tvar t = '';\n\n\t\tif (parts.username) {\n\t\t\tt += URI.encode(parts.username);\n\n\t\t\tif (parts.password) {\n\t\t\t\tt += ':' + URI.encode(parts.password);\n\t\t\t}\n\n\t\t\tt += '@';\n\t\t}\n\n\t\treturn t;\n\t};\n\tURI.buildQuery = function(data, duplicateQueryParameters, escapeQuerySpace) {\n\t\t// according to http://tools.ietf.org/html/rfc3986 or http://labs.apache.org/webarch/uri/rfc/rfc3986.html\n\t\t// being »-._~!$&'()*+,;=:@/?« %HEX and alnum are allowed\n\t\t// the RFC explicitly states ?/foo being a valid use case, no mention of parameter syntax!\n\t\t// URI.js treats the query string as being application/x-www-form-urlencoded\n\t\t// see http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type\n\n\t\tvar t = '';\n\t\tvar unique, key, i, length;\n\t\tfor (key in data) {\n\t\t\tif (hasOwn.call(data, key) && key) {\n\t\t\t\tif (isArray(data[key])) {\n\t\t\t\t\tunique = {};\n\t\t\t\t\tfor (i = 0, length = data[key].length; i < length; i++) {\n\t\t\t\t\t\tif (data[key][i] !== undefined && unique[data[key][i] + ''] === undefined) {\n\t\t\t\t\t\t\tt += '&' + URI.buildQueryParameter(key, data[key][i], escapeQuerySpace);\n\t\t\t\t\t\t\tif (duplicateQueryParameters !== true) {\n\t\t\t\t\t\t\t\tunique[data[key][i] + ''] = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (data[key] !== undefined) {\n\t\t\t\t\tt += '&' + URI.buildQueryParameter(key, data[key], escapeQuerySpace);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn t.substring(1);\n\t};\n\tURI.buildQueryParameter = function(name, value, escapeQuerySpace) {\n\t\t// http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type -- application/x-www-form-urlencoded\n\t\t// don't append \"=\" for null values, according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#url-parameter-serialization\n\t\treturn URI.encodeQuery(name, escapeQuerySpace) + (value !== null ? '=' + URI.encodeQuery(value, escapeQuerySpace) : '');\n\t};\n\n\tURI.addQuery = function(data, name, value) {\n\t\tif (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tURI.addQuery(data, key, name[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'string') {\n\t\t\tif (data[name] === undefined) {\n\t\t\t\tdata[name] = value;\n\t\t\t\treturn;\n\t\t\t} else if (typeof data[name] === 'string') {\n\t\t\t\tdata[name] = [data[name]];\n\t\t\t}\n\n\t\t\tif (!isArray(value)) {\n\t\t\t\tvalue = [value];\n\t\t\t}\n\n\t\t\tdata[name] = (data[name] || []).concat(value);\n\t\t} else {\n\t\t\tthrow new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n\t\t}\n\t};\n\tURI.removeQuery = function(data, name, value) {\n\t\tvar i, length, key;\n\n\t\tif (isArray(name)) {\n\t\t\tfor (i = 0, length = name.length; i < length; i++) {\n\t\t\t\tdata[name[i]] = undefined;\n\t\t\t}\n\t\t} else if (getType(name) === 'RegExp') {\n\t\t\tfor (key in data) {\n\t\t\t\tif (name.test(key)) {\n\t\t\t\t\tdata[key] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'object') {\n\t\t\tfor (key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tURI.removeQuery(data, key, name[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'string') {\n\t\t\tif (value !== undefined) {\n\t\t\t\tif (getType(value) === 'RegExp') {\n\t\t\t\t\tif (!isArray(data[name]) && value.test(data[name])) {\n\t\t\t\t\t\tdata[name] = undefined;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdata[name] = filterArrayValues(data[name], value);\n\t\t\t\t\t}\n\t\t\t\t} else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {\n\t\t\t\t\tdata[name] = undefined;\n\t\t\t\t} else if (isArray(data[name])) {\n\t\t\t\t\tdata[name] = filterArrayValues(data[name], value);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdata[name] = undefined;\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('URI.removeQuery() accepts an object, string, RegExp as the first parameter');\n\t\t}\n\t};\n\tURI.hasQuery = function(data, name, value, withinArray) {\n\t\tif (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tif (!URI.hasQuery(data, key, name[key])) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t} else if (typeof name !== 'string') {\n\t\t\tthrow new TypeError('URI.hasQuery() accepts an object, string as the name parameter');\n\t\t}\n\n\t\tswitch (getType(value)) {\n\t\t\tcase 'Undefined':\n\t\t\t\t// true if exists (but may be empty)\n\t\t\t\treturn name in data; // data[name] !== undefined;\n\n\t\t\tcase 'Boolean':\n\t\t\t\t// true if exists and non-empty\n\t\t\t\tvar _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);\n\t\t\t\treturn value === _booly;\n\n\t\t\tcase 'Function':\n\t\t\t\t// allow complex comparison\n\t\t\t\treturn !!value(data[name], name, data);\n\n\t\t\tcase 'Array':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tvar op = withinArray ? arrayContains : arraysEqual;\n\t\t\t\treturn op(data[name], value);\n\n\t\t\tcase 'RegExp':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn Boolean(data[name] && data[name].match(value));\n\t\t\t\t}\n\n\t\t\t\tif (!withinArray) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\treturn arrayContains(data[name], value);\n\n\t\t\tcase 'Number':\n\t\t\t\tvalue = String(value);\n\t\t\t/* falls through */\n\t\t\tcase 'String':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn data[name] === value;\n\t\t\t\t}\n\n\t\t\t\tif (!withinArray) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\treturn arrayContains(data[name], value);\n\n\t\t\tdefault:\n\t\t\t\tthrow new TypeError('URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter');\n\t\t}\n\t};\n\n\n\tURI.commonPath = function(one, two) {\n\t\tvar length = Math.min(one.length, two.length);\n\t\tvar pos;\n\n\t\t// find first non-matching character\n\t\tfor (pos = 0; pos < length; pos++) {\n\t\t\tif (one.charAt(pos) !== two.charAt(pos)) {\n\t\t\t\tpos--;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (pos < 1) {\n\t\t\treturn one.charAt(0) === two.charAt(0) && one.charAt(0) === '/' ? '/' : '';\n\t\t}\n\n\t\t// revert to last /\n\t\tif (one.charAt(pos) !== '/' || two.charAt(pos) !== '/') {\n\t\t\tpos = one.substring(0, pos).lastIndexOf('/');\n\t\t}\n\n\t\treturn one.substring(0, pos + 1);\n\t};\n\n\tURI.withinString = function(string, callback, options) {\n\t\toptions || (options = {});\n\t\tvar _start = options.start || URI.findUri.start;\n\t\tvar _end = options.end || URI.findUri.end;\n\t\tvar _trim = options.trim || URI.findUri.trim;\n\t\tvar _attributeOpen = /[a-z0-9-]=[\"']?$/i;\n\n\t\t_start.lastIndex = 0;\n\t\twhile (true) {\n\t\t\tvar match = _start.exec(string);\n\t\t\tif (!match) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar start = match.index;\n\t\t\tif (options.ignoreHtml) {\n\t\t\t\t// attribut(e=[\"']?$)\n\t\t\t\tvar attributeOpen = string.slice(Math.max(start - 3, 0), start);\n\t\t\t\tif (attributeOpen && _attributeOpen.test(attributeOpen)) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar end = start + string.slice(start).search(_end);\n\t\t\tvar slice = string.slice(start, end).replace(_trim, '');\n\t\t\tif (options.ignore && options.ignore.test(slice)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tend = start + slice.length;\n\t\t\tvar result = callback(slice, start, end, string);\n\t\t\tstring = string.slice(0, start) + result + string.slice(end);\n\t\t\t_start.lastIndex = start + result.length;\n\t\t}\n\n\t\t_start.lastIndex = 0;\n\t\treturn string;\n\t};\n\n\tURI.ensureValidHostname = function(v) {\n\t\t// Theoretically URIs allow percent-encoding in Hostnames (according to RFC 3986)\n\t\t// they are not part of DNS and therefore ignored by URI.js\n\n\t\tif (v.match(URI.invalid_hostname_characters)) {\n\t\t\t// test punycode\n\t\t\tif (!punycode) {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-] and Punycode.js is not available');\n\t\t\t}\n\n\t\t\tif (punycode.toASCII(v).match(URI.invalid_hostname_characters)) {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\t\t}\n\t};\n\n\t// noConflict\n\tURI.noConflict = function(removeAll) {\n\t\tif (removeAll) {\n\t\t\tvar unconflicted = {\n\t\t\t\tURI: this.noConflict()\n\t\t\t};\n\n\t\t\tif (root.URITemplate && typeof root.URITemplate.noConflict === 'function') {\n\t\t\t\tunconflicted.URITemplate = root.URITemplate.noConflict();\n\t\t\t}\n\n\t\t\tif (root.IPv6 && typeof root.IPv6.noConflict === 'function') {\n\t\t\t\tunconflicted.IPv6 = root.IPv6.noConflict();\n\t\t\t}\n\n\t\t\tif (root.SecondLevelDomains && typeof root.SecondLevelDomains.noConflict === 'function') {\n\t\t\t\tunconflicted.SecondLevelDomains = root.SecondLevelDomains.noConflict();\n\t\t\t}\n\n\t\t\treturn unconflicted;\n\t\t} else if (root.URI === this) {\n\t\t\troot.URI = _URI;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\tp.build = function(deferBuild) {\n\t\tif (deferBuild === true) {\n\t\t\tthis._deferred_build = true;\n\t\t} else if (deferBuild === undefined || this._deferred_build) {\n\t\t\tthis._string = URI.build(this._parts);\n\t\t\tthis._deferred_build = false;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\tp.clone = function() {\n\t\treturn new URI(this);\n\t};\n\n\tp.valueOf = p.toString = function() {\n\t\treturn this.build(false)._string;\n\t};\n\n\n\tfunction generateSimpleAccessor(_part){\n\t\treturn function(v, build) {\n\t\t\tif (v === undefined) {\n\t\t\t\treturn this._parts[_part] || '';\n\t\t\t} else {\n\t\t\t\tthis._parts[_part] = v || null;\n\t\t\t\tthis.build(!build);\n\t\t\t\treturn this;\n\t\t\t}\n\t\t};\n\t}\n\n\tfunction generatePrefixAccessor(_part, _key){\n\t\treturn function(v, build) {\n\t\t\tif (v === undefined) {\n\t\t\t\treturn this._parts[_part] || '';\n\t\t\t} else {\n\t\t\t\tif (v !== null) {\n\t\t\t\t\tv = v + '';\n\t\t\t\t\tif (v.charAt(0) === _key) {\n\t\t\t\t\t\tv = v.substring(1);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._parts[_part] = v;\n\t\t\t\tthis.build(!build);\n\t\t\t\treturn this;\n\t\t\t}\n\t\t};\n\t}\n\n\tp.protocol = generateSimpleAccessor('protocol');\n\tp.username = generateSimpleAccessor('username');\n\tp.password = generateSimpleAccessor('password');\n\tp.hostname = generateSimpleAccessor('hostname');\n\tp.port = generateSimpleAccessor('port');\n\tp.query = generatePrefixAccessor('query', '?');\n\tp.fragment = generatePrefixAccessor('fragment', '#');\n\n\tp.search = function(v, build) {\n\t\tvar t = this.query(v, build);\n\t\treturn typeof t === 'string' && t.length ? ('?' + t) : t;\n\t};\n\tp.hash = function(v, build) {\n\t\tvar t = this.fragment(v, build);\n\t\treturn typeof t === 'string' && t.length ? ('#' + t) : t;\n\t};\n\n\tp.pathname = function(v, build) {\n\t\tif (v === undefined || v === true) {\n\t\t\tvar res = this._parts.path || (this._parts.hostname ? '/' : '');\n\t\t\treturn v ? (this._parts.urn ? URI.decodeUrnPath : URI.decodePath)(res) : res;\n\t\t} else {\n\t\t\tif (this._parts.urn) {\n\t\t\t\tthis._parts.path = v ? URI.recodeUrnPath(v) : '';\n\t\t\t} else {\n\t\t\t\tthis._parts.path = v ? URI.recodePath(v) : '/';\n\t\t\t}\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.path = p.pathname;\n\tp.href = function(href, build) {\n\t\tvar key;\n\n\t\tif (href === undefined) {\n\t\t\treturn this.toString();\n\t\t}\n\n\t\tthis._string = '';\n\t\tthis._parts = URI._parts();\n\n\t\tvar _URI = href instanceof URI;\n\t\tvar _object = typeof href === 'object' && (href.hostname || href.path || href.pathname);\n\t\tif (href.nodeName) {\n\t\t\tvar attribute = URI.getDomAttribute(href);\n\t\t\thref = href[attribute] || '';\n\t\t\t_object = false;\n\t\t}\n\n\t\t// window.location is reported to be an object, but it's not the sort\n\t\t// of object we're looking for:\n\t\t// * location.protocol ends with a colon\n\t\t// * location.query != object.search\n\t\t// * location.hash != object.fragment\n\t\t// simply serializing the unknown object should do the trick\n\t\t// (for location, not for everything...)\n\t\tif (!_URI && _object && href.pathname !== undefined) {\n\t\t\thref = href.toString();\n\t\t}\n\n\t\tif (typeof href === 'string' || href instanceof String) {\n\t\t\tthis._parts = URI.parse(String(href), this._parts);\n\t\t} else if (_URI || _object) {\n\t\t\tvar src = _URI ? href._parts : href;\n\t\t\tfor (key in src) {\n\t\t\t\tif (hasOwn.call(this._parts, key)) {\n\t\t\t\t\tthis._parts[key] = src[key];\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('invalid input');\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\n\t// identification accessors\n\tp.is = function(what) {\n\t\tvar ip = false;\n\t\tvar ip4 = false;\n\t\tvar ip6 = false;\n\t\tvar name = false;\n\t\tvar sld = false;\n\t\tvar idn = false;\n\t\tvar punycode = false;\n\t\tvar relative = !this._parts.urn;\n\n\t\tif (this._parts.hostname) {\n\t\t\trelative = false;\n\t\t\tip4 = URI.ip4_expression.test(this._parts.hostname);\n\t\t\tip6 = URI.ip6_expression.test(this._parts.hostname);\n\t\t\tip = ip4 || ip6;\n\t\t\tname = !ip;\n\t\t\tsld = name && SLD && SLD.has(this._parts.hostname);\n\t\t\tidn = name && URI.idn_expression.test(this._parts.hostname);\n\t\t\tpunycode = name && URI.punycode_expression.test(this._parts.hostname);\n\t\t}\n\n\t\tswitch (what.toLowerCase()) {\n\t\t\tcase 'relative':\n\t\t\t\treturn relative;\n\n\t\t\tcase 'absolute':\n\t\t\t\treturn !relative;\n\n\t\t\t// hostname identification\n\t\t\tcase 'domain':\n\t\t\tcase 'name':\n\t\t\t\treturn name;\n\n\t\t\tcase 'sld':\n\t\t\t\treturn sld;\n\n\t\t\tcase 'ip':\n\t\t\t\treturn ip;\n\n\t\t\tcase 'ip4':\n\t\t\tcase 'ipv4':\n\t\t\tcase 'inet4':\n\t\t\t\treturn ip4;\n\n\t\t\tcase 'ip6':\n\t\t\tcase 'ipv6':\n\t\t\tcase 'inet6':\n\t\t\t\treturn ip6;\n\n\t\t\tcase 'idn':\n\t\t\t\treturn idn;\n\n\t\t\tcase 'url':\n\t\t\t\treturn !this._parts.urn;\n\n\t\t\tcase 'urn':\n\t\t\t\treturn !!this._parts.urn;\n\n\t\t\tcase 'punycode':\n\t\t\t\treturn punycode;\n\t\t}\n\n\t\treturn null;\n\t};\n\n\t// component specific input validation\n\tvar _protocol = p.protocol;\n\tvar _port = p.port;\n\tvar _hostname = p.hostname;\n\n\tp.protocol = function(v, build) {\n\t\tif (v !== undefined) {\n\t\t\tif (v) {\n\t\t\t\t// accept trailing ://\n\t\t\t\tv = v.replace(/:(\\/\\/)?$/, '');\n\n\t\t\t\tif (!v.match(URI.protocol_expression)) {\n\t\t\t\t\tthrow new TypeError('Protocol \"' + v + '\" contains characters other than [A-Z0-9.+-] or doesn\\'t start with [A-Z]');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn _protocol.call(this, v, build);\n\t};\n\tp.scheme = p.protocol;\n\tp.port = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v !== undefined) {\n\t\t\tif (v === 0) {\n\t\t\t\tv = null;\n\t\t\t}\n\n\t\t\tif (v) {\n\t\t\t\tv += '';\n\t\t\t\tif (v.charAt(0) === ':') {\n\t\t\t\t\tv = v.substring(1);\n\t\t\t\t}\n\n\t\t\t\tif (v.match(/[^0-9]/)) {\n\t\t\t\t\tthrow new TypeError('Port \"' + v + '\" contains characters other than [0-9]');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn _port.call(this, v, build);\n\t};\n\tp.hostname = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v !== undefined) {\n\t\t\tvar x = {};\n\t\t\tvar res = URI.parseHost(v, x);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tv = x.hostname;\n\t\t}\n\t\treturn _hostname.call(this, v, build);\n\t};\n\n\t// compound accessors\n\tp.origin = function(v, build) {\n\t\tvar parts;\n\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tvar protocol = this.protocol();\n\t\t\tvar authority = this.authority();\n\t\t\tif (!authority) return '';\n\t\t\treturn (protocol ? protocol + '://' : '') + this.authority();\n\t\t} else {\n\t\t\tvar origin = URI(v);\n\t\t\tthis\n\t\t\t\t.protocol(origin.protocol())\n\t\t\t\t.authority(origin.authority())\n\t\t\t\t.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.host = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\treturn this._parts.hostname ? URI.buildHost(this._parts) : '';\n\t\t} else {\n\t\t\tvar res = URI.parseHost(v, this._parts);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.authority = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\treturn this._parts.hostname ? URI.buildAuthority(this._parts) : '';\n\t\t} else {\n\t\t\tvar res = URI.parseAuthority(v, this._parts);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.userinfo = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.username) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar t = URI.buildUserinfo(this._parts);\n\t\t\treturn t.substring(0, t.length -1);\n\t\t} else {\n\t\t\tif (v[v.length-1] !== '@') {\n\t\t\t\tv += '@';\n\t\t\t}\n\n\t\t\tURI.parseUserinfo(v, this._parts);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.resource = function(v, build) {\n\t\tvar parts;\n\n\t\tif (v === undefined) {\n\t\t\treturn this.path() + this.search() + this.hash();\n\t\t}\n\n\t\tparts = URI.parse(v);\n\t\tthis._parts.path = parts.path;\n\t\tthis._parts.query = parts.query;\n\t\tthis._parts.fragment = parts.fragment;\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\n\t// fraction accessors\n\tp.subdomain = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\t// convenience, return \"www\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// grab domain and add another segment\n\t\t\tvar end = this._parts.hostname.length - this.domain().length - 1;\n\t\t\treturn this._parts.hostname.substring(0, end) || '';\n\t\t} else {\n\t\t\tvar e = this._parts.hostname.length - this.domain().length;\n\t\t\tvar sub = this._parts.hostname.substring(0, e);\n\t\t\tvar replace = new RegExp('^' + escapeRegEx(sub));\n\n\t\t\tif (v && v.charAt(v.length - 1) !== '.') {\n\t\t\t\tv += '.';\n\t\t\t}\n\n\t\t\tif (v) {\n\t\t\t\tURI.ensureValidHostname(v);\n\t\t\t}\n\n\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.domain = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (typeof v === 'boolean') {\n\t\t\tbuild = v;\n\t\t\tv = undefined;\n\t\t}\n\n\t\t// convenience, return \"example.org\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// if hostname consists of 1 or 2 segments, it must be the domain\n\t\t\tvar t = this._parts.hostname.match(/\\./g);\n\t\t\tif (t && t.length < 2) {\n\t\t\t\treturn this._parts.hostname;\n\t\t\t}\n\n\t\t\t// grab tld and add another segment\n\t\t\tvar end = this._parts.hostname.length - this.tld(build).length - 1;\n\t\t\tend = this._parts.hostname.lastIndexOf('.', end -1) + 1;\n\t\t\treturn this._parts.hostname.substring(end) || '';\n\t\t} else {\n\t\t\tif (!v) {\n\t\t\t\tthrow new TypeError('cannot set domain empty');\n\t\t\t}\n\n\t\t\tURI.ensureValidHostname(v);\n\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\tthis._parts.hostname = v;\n\t\t\t} else {\n\t\t\t\tvar replace = new RegExp(escapeRegEx(this.domain()) + '$');\n\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.tld = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (typeof v === 'boolean') {\n\t\t\tbuild = v;\n\t\t\tv = undefined;\n\t\t}\n\n\t\t// return \"org\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar pos = this._parts.hostname.lastIndexOf('.');\n\t\t\tvar tld = this._parts.hostname.substring(pos + 1);\n\n\t\t\tif (build !== true && SLD && SLD.list[tld.toLowerCase()]) {\n\t\t\t\treturn SLD.get(this._parts.hostname) || tld;\n\t\t\t}\n\n\t\t\treturn tld;\n\t\t} else {\n\t\t\tvar replace;\n\n\t\t\tif (!v) {\n\t\t\t\tthrow new TypeError('cannot set TLD empty');\n\t\t\t} else if (v.match(/[^a-zA-Z0-9-]/)) {\n\t\t\t\tif (SLD && SLD.is(v)) {\n\t\t\t\t\treplace = new RegExp(escapeRegEx(this.tld()) + '$');\n\t\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t\t} else {\n\t\t\t\t\tthrow new TypeError('TLD \"' + v + '\" contains characters other than [A-Z0-9]');\n\t\t\t\t}\n\t\t\t} else if (!this._parts.hostname || this.is('IP')) {\n\t\t\t\tthrow new ReferenceError('cannot set TLD on non-domain host');\n\t\t\t} else {\n\t\t\t\treplace = new RegExp(escapeRegEx(this.tld()) + '$');\n\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.directory = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path && !this._parts.hostname) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tif (this._parts.path === '/') {\n\t\t\t\treturn '/';\n\t\t\t}\n\n\t\t\tvar end = this._parts.path.length - this.filename().length - 1;\n\t\t\tvar res = this._parts.path.substring(0, end) || (this._parts.hostname ? '/' : '');\n\n\t\t\treturn v ? URI.decodePath(res) : res;\n\n\t\t} else {\n\t\t\tvar e = this._parts.path.length - this.filename().length;\n\t\t\tvar directory = this._parts.path.substring(0, e);\n\t\t\tvar replace = new RegExp('^' + escapeRegEx(directory));\n\n\t\t\t// fully qualifier directories begin with a slash\n\t\t\tif (!this.is('relative')) {\n\t\t\t\tif (!v) {\n\t\t\t\t\tv = '/';\n\t\t\t\t}\n\n\t\t\t\tif (v.charAt(0) !== '/') {\n\t\t\t\t\tv = '/' + v;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// directories always end with a slash\n\t\t\tif (v && v.charAt(v.length - 1) !== '/') {\n\t\t\t\tv += '/';\n\t\t\t}\n\n\t\t\tv = URI.recodePath(v);\n\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.filename = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path || this._parts.path === '/') {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar pos = this._parts.path.lastIndexOf('/');\n\t\t\tvar res = this._parts.path.substring(pos+1);\n\n\t\t\treturn v ? URI.decodePathSegment(res) : res;\n\t\t} else {\n\t\t\tvar mutatedDirectory = false;\n\n\t\t\tif (v.charAt(0) === '/') {\n\t\t\t\tv = v.substring(1);\n\t\t\t}\n\n\t\t\tif (v.match(/\\.?\\//)) {\n\t\t\t\tmutatedDirectory = true;\n\t\t\t}\n\n\t\t\tvar replace = new RegExp(escapeRegEx(this.filename()) + '$');\n\t\t\tv = URI.recodePath(v);\n\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\n\t\t\tif (mutatedDirectory) {\n\t\t\t\tthis.normalizePath(build);\n\t\t\t} else {\n\t\t\t\tthis.build(!build);\n\t\t\t}\n\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.suffix = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path || this._parts.path === '/') {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar filename = this.filename();\n\t\t\tvar pos = filename.lastIndexOf('.');\n\t\t\tvar s, res;\n\n\t\t\tif (pos === -1) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// suffix may only contain alnum characters (yup, I made this up.)\n\t\t\ts = filename.substring(pos+1);\n\t\t\tres = (/^[a-z0-9%]+$/i).test(s) ? s : '';\n\t\t\treturn v ? URI.decodePathSegment(res) : res;\n\t\t} else {\n\t\t\tif (v.charAt(0) === '.') {\n\t\t\t\tv = v.substring(1);\n\t\t\t}\n\n\t\t\tvar suffix = this.suffix();\n\t\t\tvar replace;\n\n\t\t\tif (!suffix) {\n\t\t\t\tif (!v) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t\tthis._parts.path += '.' + URI.recodePath(v);\n\t\t\t} else if (!v) {\n\t\t\t\treplace = new RegExp(escapeRegEx('.' + suffix) + '$');\n\t\t\t} else {\n\t\t\t\treplace = new RegExp(escapeRegEx(suffix) + '$');\n\t\t\t}\n\n\t\t\tif (replace) {\n\t\t\t\tv = URI.recodePath(v);\n\t\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.segment = function(segment, v, build) {\n\t\tvar separator = this._parts.urn ? ':' : '/';\n\t\tvar path = this.path();\n\t\tvar absolute = path.substring(0, 1) === '/';\n\t\tvar segments = path.split(separator);\n\n\t\tif (segment !== undefined && typeof segment !== 'number') {\n\t\t\tbuild = v;\n\t\t\tv = segment;\n\t\t\tsegment = undefined;\n\t\t}\n\n\t\tif (segment !== undefined && typeof segment !== 'number') {\n\t\t\tthrow new Error('Bad segment \"' + segment + '\", must be 0-based integer');\n\t\t}\n\n\t\tif (absolute) {\n\t\t\tsegments.shift();\n\t\t}\n\n\t\tif (segment < 0) {\n\t\t\t// allow negative indexes to address from the end\n\t\t\tsegment = Math.max(segments.length + segment, 0);\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\t/*jshint laxbreak: true */\n\t\t\treturn segment === undefined\n\t\t\t\t? segments\n\t\t\t\t: segments[segment];\n\t\t\t/*jshint laxbreak: false */\n\t\t} else if (segment === null || segments[segment] === undefined) {\n\t\t\tif (isArray(v)) {\n\t\t\t\tsegments = [];\n\t\t\t\t// collapse empty elements within array\n\t\t\t\tfor (var i=0, l=v.length; i < l; i++) {\n\t\t\t\t\tif (!v[i].length && (!segments.length || !segments[segments.length -1].length)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (segments.length && !segments[segments.length -1].length) {\n\t\t\t\t\t\tsegments.pop();\n\t\t\t\t\t}\n\n\t\t\t\t\tsegments.push(trimSlashes(v[i]));\n\t\t\t\t}\n\t\t\t} else if (v || typeof v === 'string') {\n\t\t\t\tv = trimSlashes(v);\n\t\t\t\tif (segments[segments.length -1] === '') {\n\t\t\t\t\t// empty trailing elements have to be overwritten\n\t\t\t\t\t// to prevent results such as /foo//bar\n\t\t\t\t\tsegments[segments.length -1] = v;\n\t\t\t\t} else {\n\t\t\t\t\tsegments.push(v);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (v) {\n\t\t\t\tsegments[segment] = trimSlashes(v);\n\t\t\t} else {\n\t\t\t\tsegments.splice(segment, 1);\n\t\t\t}\n\t\t}\n\n\t\tif (absolute) {\n\t\t\tsegments.unshift('');\n\t\t}\n\n\t\treturn this.path(segments.join(separator), build);\n\t};\n\tp.segmentCoded = function(segment, v, build) {\n\t\tvar segments, i, l;\n\n\t\tif (typeof segment !== 'number') {\n\t\t\tbuild = v;\n\t\t\tv = segment;\n\t\t\tsegment = undefined;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tsegments = this.segment(segment, v, build);\n\t\t\tif (!isArray(segments)) {\n\t\t\t\tsegments = segments !== undefined ? URI.decode(segments) : undefined;\n\t\t\t} else {\n\t\t\t\tfor (i = 0, l = segments.length; i < l; i++) {\n\t\t\t\t\tsegments[i] = URI.decode(segments[i]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn segments;\n\t\t}\n\n\t\tif (!isArray(v)) {\n\t\t\tv = (typeof v === 'string' || v instanceof String) ? URI.encode(v) : v;\n\t\t} else {\n\t\t\tfor (i = 0, l = v.length; i < l; i++) {\n\t\t\t\tv[i] = URI.encode(v[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn this.segment(segment, v, build);\n\t};\n\n\t// mutating query string\n\tvar q = p.query;\n\tp.query = function(v, build) {\n\t\tif (v === true) {\n\t\t\treturn URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\t} else if (typeof v === 'function') {\n\t\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\t\tvar result = v.call(this, data);\n\t\t\tthis._parts.query = URI.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t} else if (v !== undefined && typeof v !== 'string') {\n\t\t\tthis._parts.query = URI.buildQuery(v, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn q.call(this, v, build);\n\t\t}\n\t};\n\tp.setQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\n\t\tif (typeof name === 'string' || name instanceof String) {\n\t\t\tdata[name] = value !== undefined ? value : null;\n\t\t} else if (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tdata[key] = name[key];\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n\t\t}\n\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.addQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\tURI.addQuery(data, name, value === undefined ? null : value);\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.removeQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\tURI.removeQuery(data, name, value);\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.hasQuery = function(name, value, withinArray) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\treturn URI.hasQuery(data, name, value, withinArray);\n\t};\n\tp.setSearch = p.setQuery;\n\tp.addSearch = p.addQuery;\n\tp.removeSearch = p.removeQuery;\n\tp.hasSearch = p.hasQuery;\n\n\t// sanitizing URLs\n\tp.normalize = function() {\n\t\tif (this._parts.urn) {\n\t\t\treturn this\n\t\t\t\t.normalizeProtocol(false)\n\t\t\t\t.normalizePath(false)\n\t\t\t\t.normalizeQuery(false)\n\t\t\t\t.normalizeFragment(false)\n\t\t\t\t.build();\n\t\t}\n\n\t\treturn this\n\t\t\t.normalizeProtocol(false)\n\t\t\t.normalizeHostname(false)\n\t\t\t.normalizePort(false)\n\t\t\t.normalizePath(false)\n\t\t\t.normalizeQuery(false)\n\t\t\t.normalizeFragment(false)\n\t\t\t.build();\n\t};\n\tp.normalizeProtocol = function(build) {\n\t\tif (typeof this._parts.protocol === 'string') {\n\t\t\tthis._parts.protocol = this._parts.protocol.toLowerCase();\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeHostname = function(build) {\n\t\tif (this._parts.hostname) {\n\t\t\tif (this.is('IDN') && punycode) {\n\t\t\t\tthis._parts.hostname = punycode.toASCII(this._parts.hostname);\n\t\t\t} else if (this.is('IPv6') && IPv6) {\n\t\t\t\tthis._parts.hostname = IPv6.best(this._parts.hostname);\n\t\t\t}\n\n\t\t\tthis._parts.hostname = this._parts.hostname.toLowerCase();\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizePort = function(build) {\n\t\t// remove port of it's the protocol's default\n\t\tif (typeof this._parts.protocol === 'string' && this._parts.port === URI.defaultPorts[this._parts.protocol]) {\n\t\t\tthis._parts.port = null;\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizePath = function(build) {\n\t\tvar _path = this._parts.path;\n\t\tif (!_path) {\n\t\t\treturn this;\n\t\t}\n\n\t\tif (this._parts.urn) {\n\t\t\tthis._parts.path = URI.recodeUrnPath(this._parts.path);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\n\t\tif (this._parts.path === '/') {\n\t\t\treturn this;\n\t\t}\n\n\t\tvar _was_relative;\n\t\tvar _leadingParents = '';\n\t\tvar _parent, _pos;\n\n\t\t// handle relative paths\n\t\tif (_path.charAt(0) !== '/') {\n\t\t\t_was_relative = true;\n\t\t\t_path = '/' + _path;\n\t\t}\n\n\t\t// handle relative files (as opposed to directories)\n\t\tif (_path.slice(-3) === '/..' || _path.slice(-2) === '/.') {\n\t\t\t_path += '/';\n\t\t}\n\n\t\t// resolve simples\n\t\t_path = _path\n\t\t\t.replace(/(\\/(\\.\\/)+)|(\\/\\.$)/g, '/')\n\t\t\t.replace(/\\/{2,}/g, '/');\n\n\t\t// remember leading parents\n\t\tif (_was_relative) {\n\t\t\t_leadingParents = _path.substring(1).match(/^(\\.\\.\\/)+/) || '';\n\t\t\tif (_leadingParents) {\n\t\t\t\t_leadingParents = _leadingParents[0];\n\t\t\t}\n\t\t}\n\n\t\t// resolve parents\n\t\twhile (true) {\n\t\t\t_parent = _path.indexOf('/..');\n\t\t\tif (_parent === -1) {\n\t\t\t\t// no more ../ to resolve\n\t\t\t\tbreak;\n\t\t\t} else if (_parent === 0) {\n\t\t\t\t// top level cannot be relative, skip it\n\t\t\t\t_path = _path.substring(3);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t_pos = _path.substring(0, _parent).lastIndexOf('/');\n\t\t\tif (_pos === -1) {\n\t\t\t\t_pos = _parent;\n\t\t\t}\n\t\t\t_path = _path.substring(0, _pos) + _path.substring(_parent + 3);\n\t\t}\n\n\t\t// revert to relative\n\t\tif (_was_relative && this.is('relative')) {\n\t\t\t_path = _leadingParents + _path.substring(1);\n\t\t}\n\n\t\t_path = URI.recodePath(_path);\n\t\tthis._parts.path = _path;\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.normalizePathname = p.normalizePath;\n\tp.normalizeQuery = function(build) {\n\t\tif (typeof this._parts.query === 'string') {\n\t\t\tif (!this._parts.query.length) {\n\t\t\t\tthis._parts.query = null;\n\t\t\t} else {\n\t\t\t\tthis.query(URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace));\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeFragment = function(build) {\n\t\tif (!this._parts.fragment) {\n\t\t\tthis._parts.fragment = null;\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeSearch = p.normalizeQuery;\n\tp.normalizeHash = p.normalizeFragment;\n\n\tp.iso8859 = function() {\n\t\t// expect unicode input, iso8859 output\n\t\tvar e = URI.encode;\n\t\tvar d = URI.decode;\n\n\t\tURI.encode = escape;\n\t\tURI.decode = decodeURIComponent;\n\t\ttry {\n\t\t\tthis.normalize();\n\t\t} finally {\n\t\t\tURI.encode = e;\n\t\t\tURI.decode = d;\n\t\t}\n\t\treturn this;\n\t};\n\n\tp.unicode = function() {\n\t\t// expect iso8859 input, unicode output\n\t\tvar e = URI.encode;\n\t\tvar d = URI.decode;\n\n\t\tURI.encode = strictEncodeURIComponent;\n\t\tURI.decode = unescape;\n\t\ttry {\n\t\t\tthis.normalize();\n\t\t} finally {\n\t\t\tURI.encode = e;\n\t\t\tURI.decode = d;\n\t\t}\n\t\treturn this;\n\t};\n\n\tp.readable = function() {\n\t\tvar uri = this.clone();\n\t\t// removing username, password, because they shouldn't be displayed according to RFC 3986\n\t\turi.username('').password('').normalize();\n\t\tvar t = '';\n\t\tif (uri._parts.protocol) {\n\t\t\tt += uri._parts.protocol + '://';\n\t\t}\n\n\t\tif (uri._parts.hostname) {\n\t\t\tif (uri.is('punycode') && punycode) {\n\t\t\t\tt += punycode.toUnicode(uri._parts.hostname);\n\t\t\t\tif (uri._parts.port) {\n\t\t\t\t\tt += ':' + uri._parts.port;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tt += uri.host();\n\t\t\t}\n\t\t}\n\n\t\tif (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== '/') {\n\t\t\tt += '/';\n\t\t}\n\n\t\tt += uri.path(true);\n\t\tif (uri._parts.query) {\n\t\t\tvar q = '';\n\t\t\tfor (var i = 0, qp = uri._parts.query.split('&'), l = qp.length; i < l; i++) {\n\t\t\t\tvar kv = (qp[i] || '').split('=');\n\t\t\t\tq += '&' + URI.decodeQuery(kv[0], this._parts.escapeQuerySpace)\n\t\t\t\t\t.replace(/&/g, '%26');\n\n\t\t\t\tif (kv[1] !== undefined) {\n\t\t\t\t\tq += '=' + URI.decodeQuery(kv[1], this._parts.escapeQuerySpace)\n\t\t\t\t\t\t.replace(/&/g, '%26');\n\t\t\t\t}\n\t\t\t}\n\t\t\tt += '?' + q.substring(1);\n\t\t}\n\n\t\tt += URI.decodeQuery(uri.hash(), true);\n\t\treturn t;\n\t};\n\n\t// resolving relative and absolute URLs\n\tp.absoluteTo = function(base) {\n\t\tvar resolved = this.clone();\n\t\tvar properties = ['protocol', 'username', 'password', 'hostname', 'port'];\n\t\tvar basedir, i, p;\n\n\t\tif (this._parts.urn) {\n\t\t\tthrow new Error('URNs do not have any generally defined hierarchical components');\n\t\t}\n\n\t\tif (!(base instanceof URI)) {\n\t\t\tbase = new URI(base);\n\t\t}\n\n\t\tif (!resolved._parts.protocol) {\n\t\t\tresolved._parts.protocol = base._parts.protocol;\n\t\t}\n\n\t\tif (this._parts.hostname) {\n\t\t\treturn resolved;\n\t\t}\n\n\t\tfor (i = 0; (p = properties[i]); i++) {\n\t\t\tresolved._parts[p] = base._parts[p];\n\t\t}\n\n\t\tif (!resolved._parts.path) {\n\t\t\tresolved._parts.path = base._parts.path;\n\t\t\tif (!resolved._parts.query) {\n\t\t\t\tresolved._parts.query = base._parts.query;\n\t\t\t}\n\t\t} else if (resolved._parts.path.substring(-2) === '..') {\n\t\t\tresolved._parts.path += '/';\n\t\t}\n\n\t\tif (resolved.path().charAt(0) !== '/') {\n\t\t\tbasedir = base.directory();\n\t\t\tbasedir = basedir ? basedir : base.path().indexOf('/') === 0 ? '/' : '';\n\t\t\tresolved._parts.path = (basedir ? (basedir + '/') : '') + resolved._parts.path;\n\t\t\tresolved.normalizePath();\n\t\t}\n\n\t\tresolved.build();\n\t\treturn resolved;\n\t};\n\tp.relativeTo = function(base) {\n\t\tvar relative = this.clone().normalize();\n\t\tvar relativeParts, baseParts, common, relativePath, basePath;\n\n\t\tif (relative._parts.urn) {\n\t\t\tthrow new Error('URNs do not have any generally defined hierarchical components');\n\t\t}\n\n\t\tbase = new URI(base).normalize();\n\t\trelativeParts = relative._parts;\n\t\tbaseParts = base._parts;\n\t\trelativePath = relative.path();\n\t\tbasePath = base.path();\n\n\t\tif (relativePath.charAt(0) !== '/') {\n\t\t\tthrow new Error('URI is already relative');\n\t\t}\n\n\t\tif (basePath.charAt(0) !== '/') {\n\t\t\tthrow new Error('Cannot calculate a URI relative to another relative URI');\n\t\t}\n\n\t\tif (relativeParts.protocol === baseParts.protocol) {\n\t\t\trelativeParts.protocol = null;\n\t\t}\n\n\t\tif (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {\n\t\t\trelativeParts.hostname = null;\n\t\t\trelativeParts.port = null;\n\t\t} else {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativePath === basePath) {\n\t\t\trelativeParts.path = '';\n\t\t\treturn relative.build();\n\t\t}\n\n\t\t// determine common sub path\n\t\tcommon = URI.commonPath(relativePath, basePath);\n\n\t\t// If the paths have nothing in common, return a relative URL with the absolute path.\n\t\tif (!common) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tvar parents = baseParts.path\n\t\t\t.substring(common.length)\n\t\t\t.replace(/[^\\/]*$/, '')\n\t\t\t.replace(/.*?\\//g, '../');\n\n\t\trelativeParts.path = (parents + relativeParts.path.substring(common.length)) || './';\n\n\t\treturn relative.build();\n\t};\n\n\t// comparing URIs\n\tp.equals = function(uri) {\n\t\tvar one = this.clone();\n\t\tvar two = new URI(uri);\n\t\tvar one_map = {};\n\t\tvar two_map = {};\n\t\tvar checked = {};\n\t\tvar one_query, two_query, key;\n\n\t\tone.normalize();\n\t\ttwo.normalize();\n\n\t\t// exact match\n\t\tif (one.toString() === two.toString()) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// extract query string\n\t\tone_query = one.query();\n\t\ttwo_query = two.query();\n\t\tone.query('');\n\t\ttwo.query('');\n\n\t\t// definitely not equal if not even non-query parts match\n\t\tif (one.toString() !== two.toString()) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// query parameters have the same length, even if they're permuted\n\t\tif (one_query.length !== two_query.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tone_map = URI.parseQuery(one_query, this._parts.escapeQuerySpace);\n\t\ttwo_map = URI.parseQuery(two_query, this._parts.escapeQuerySpace);\n\n\t\tfor (key in one_map) {\n\t\t\tif (hasOwn.call(one_map, key)) {\n\t\t\t\tif (!isArray(one_map[key])) {\n\t\t\t\t\tif (one_map[key] !== two_map[key]) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t} else if (!arraysEqual(one_map[key], two_map[key])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tchecked[key] = true;\n\t\t\t}\n\t\t}\n\n\t\tfor (key in two_map) {\n\t\t\tif (hasOwn.call(two_map, key)) {\n\t\t\t\tif (!checked[key]) {\n\t\t\t\t\t// two contains a parameter not present in one\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t};\n\n\t// state\n\tp.duplicateQueryParameters = function(v) {\n\t\tthis._parts.duplicateQueryParameters = !!v;\n\t\treturn this;\n\t};\n\n\tp.escapeQuerySpace = function(v) {\n\t\tthis._parts.escapeQuerySpace = !!v;\n\t\treturn this;\n\t};\n\n\treturn URI;\n}));","Workflow = {}\n\n@ImageSign = {};\n\n@TracesHandler = {};\n\n@TracesTemplate = {};\n\n@InstanceformTemplate = {};\n\n@InstanceAttachmentTemplate = {};\n\n@InstanceSignText = {}\n\n@RelatedInstances = {}\n\n@RelatedRecords = {}\n\n@InstanceMacro = {context: {}}\n\n@TracesManager = {};\n\nInstanceSignText.isOpinionField_from_string = (field_formula)->\n\treturn (field_formula?.indexOf(\"{traces.\") > -1 || field_formula?.indexOf(\"{signature.traces.\") > -1 || field_formula?.indexOf(\"{yijianlan:\") > -1 || field_formula?.indexOf(\"{\\\"yijianlan\\\":\") > -1 || field_formula?.indexOf(\"{'yijianlan':\") > -1)\n\nInstanceSignText.includesOpinionField = (form, form_version)->\n\tfield_formulas = new Array();\n\n\t_form_version = {}\n\n\tif Meteor.isServer\n\t\t_form_version = uuflowManager.getFormVersion(db.forms.findOne({_id: form}), form_version)\n\telse\n\t\t_form_version = db.form_versions.findOne({_id: form_version, form: form})\n\n\tfields = _form_version?.fields || []\n\n\tfields.forEach (f)->\n\t\tif f.type == 'table'\n\t\t\tconsole.log 'ignore opinion field in table'\n\t\telse if f.type == 'section'\n\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\tfield_formulas.push f1.formula\n\t\telse\n\t\t\tfield_formulas.push f.formula\n\n\t_.some field_formulas, (field_formula)->\n\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\n","             \n\nWorkflow = {};\n\nthis.ImageSign = {};\n\nthis.TracesHandler = {};\n\nthis.TracesTemplate = {};\n\nthis.InstanceformTemplate = {};\n\nthis.InstanceAttachmentTemplate = {};\n\nthis.InstanceSignText = {};\n\nthis.RelatedInstances = {};\n\nthis.RelatedRecords = {};\n\nthis.InstanceMacro = {\n  context: {}\n};\n\nthis.TracesManager = {};\n\nInstanceSignText.isOpinionField_from_string = function(field_formula) {\n  return (field_formula != null ? field_formula.indexOf(\"{traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{signature.traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{yijianlan:\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{\\\"yijianlan\\\":\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{'yijianlan':\") : void 0) > -1;\n};\n\nInstanceSignText.includesOpinionField = function(form, form_version) {\n  var _form_version, field_formulas, fields;\n  field_formulas = new Array();\n  _form_version = {};\n  if (Meteor.isServer) {\n    _form_version = uuflowManager.getFormVersion(db.forms.findOne({\n      _id: form\n    }), form_version);\n  } else {\n    _form_version = db.form_versions.findOne({\n      _id: form_version,\n      form: form\n    });\n  }\n  fields = (_form_version != null ? _form_version.fields : void 0) || [];\n  fields.forEach(function(f) {\n    var ref;\n    if (f.type === 'table') {\n      return console.log('ignore opinion field in table');\n    } else if (f.type === 'section') {\n      return f != null ? (ref = f.fields) != null ? ref.forEach(function(f1) {\n        return field_formulas.push(f1.formula);\n      }) : void 0 : void 0;\n    } else {\n      return field_formulas.push(f.formula);\n    }\n  });\n  return _.some(field_formulas, function(field_formula) {\n    return InstanceformTemplate.helpers.isOpinionField_from_string(field_formula);\n  });\n};\n","db.instance_tasks = new Meteor.Collection('instance_tasks')\n\ndb.instance_tasks._simpleSchema = new SimpleSchema\n    instance:\n        type: String\n    trace:\n        type: String\n    is_finished:\n        type: String\n    user:\n        type: String\n    user_name:\n        type: String\n    handler:\n        type: String\n    handler_name:\n        type: String\n    handler_organization:\n        type: String\n    handler_organization_name:\n        type: String\n    handler_organization_fullname:\n        type: String\n    start_date:\n        type: Date\n    due_date:\n        type: Date\n    is_read:\n        type: Boolean\n    is_error:\n        type: Boolean\n    values:\n        type: Object\n    deadline:\n        type: Date\n    remind_date:\n        type: Date\n    reminded_count:\n        type: Number\n    read_date:\n        type: Date\n    description:\n        type: String\n    modified:\n        type: Date\n    modified_by:\n        type: String\n    sign_show:\n        type: Boolean\n    judge:\n        type: String\n    next_steps:\n        type: Array\n    \"next_steps.$\":\n        type: Object\n    \"next_steps.$.step\":\n        type: String\n    \"next_steps.$.users\":\n        type: [String]\n    finish_date:\n        type: Date\n    cost_time:\n        type: Number\n    space:\n        type: String\n    instance_name:\n        type: String\n    submitter:\n        type: String\n    submitter_name:\n        type: String\n    applicant:\n        type: String\n    applicant_name:\n        type: String\n    applicant_organization_name:\n        type: String\n    submit_date:\n        type: Date\n    flow:\n        type: String\n    flow_name:\n        type: String\n    form:\n        type: String\n    step:\n        type: String\n    step_name:\n        type: String\n    category_name:\n        type: String\n    instance_state:\n        type: String\n    distribute_from_instance:\n        type: String\n    forward_from_instance:\n        type: String\n    keywords:\n        type: String\n    is_archived:\n        type: Boolean\n    category:\n        type: String\n","db.auth_tokens = new Meteor.Collection('auth_tokens')","marked = require(\"marked\")\n\nInstanceReadOnlyTemplate = {};\n\n\nInstanceReadOnlyTemplate.instance_attachment = \"\"\"\n\t<tr>\n\t\t<td class=\"ins-attach-view\">\n\t\t\t<a href=\"{{ins_attach_download_url _id absolute}}\" class=\"ins_attach_href\" target=\"_parent\" data-name=\"{{this.name}}\" data-type=\"{{this.original.type}}\" data-id=\"{{_id}}\">{{this.name}}</a>\n\t\t</td>\n\t</tr>\n\"\"\"\n\nInstanceReadOnlyTemplate.afSelectUserRead = \"\"\"\n\t<div class='selectUser form-control ins_applicant'>{{value}}</div>\n\"\"\"\n\n\nInstanceReadOnlyTemplate.afFormGroupRead = \"\"\"\n\t<div class='form-group'>\n\t\t{{#with getField this.name}}\n\t\t\t{{#if equals type 'section'}}\n\t\t\t\t\t<div class='section callout callout-default'>\n\t\t\t\t\t\t<label class=\"control-label\">{{f_label this}}</label>\n\t\t\t\t\t\t<p>{{{description}}}</p>\n\t\t\t\t\t</div>\n\t\t\t{{else}}\n\t\t\t\t{{#if equals type 'table'}}\n\t\t\t\t\t<div class=\"panel panel-default steedos-table\">\n\t\t\t\t\t\t<div class=\"panel-body\" style=\"padding:0px;\">\n\t\t\t\t\t\t\t<div class=\"panel-heading\" >\n\t\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t<span class=\"description\">{{{description}}}</span>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t<div class=\"readonly-table\" style=\"padding:0px;overflow-x:auto;\">\n\t\t\t\t\t\t\t\t\t<table type='table' class=\"table table-bordered table-condensed autoform-table\" style='margin-bottom:0px;' {{this.atts}} id=\"{{this.code}}Table\" name=\"{{this.code}}\" data-schema-key=\"{{this.name}}\">\n\t\t\t\t\t\t\t\t\t\t<thead id=\"{{this.name}}Thead\" name=\"{{this.name}}Thead\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\n\t\t\t\t\t\t\t\t\t\t</thead>\n\t\t\t\t\t\t\t\t\t\t<tbody id=\"{{this.name}}Tbody\" name=\"{{this.name}}Tbody\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\n\t\t\t\t\t\t\t\t\t\t</tbody>\n\t\t\t\t\t\t\t\t\t</table>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if showLabel}}\n\t\t\t\t\t\t<label>{{getLabel code}}</label>\n\t\t\t\t\t{{/if}}\n\t\t\t\t\t{{#if isTextarea this}}\n\t\t\t\t\t\t<p class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</p>\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/if}}\n\t\t{{/with}}\n\t</div>\n\"\"\"\n\nInstanceReadOnlyTemplate.afFormGroup = \"\"\"\n\n\t{{#with getField this.name}}\n\t\t\t{{#if equals type 'section'}}\n\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t<div class='section callout callout-default'>\n\t\t\t\t\t\t<label class=\"control-label\">{{f_label this}}</label>\n\t\t\t\t\t\t<p>{{{description}}}</p>\n\t\t\t\t\t</div>\n  \t\t\t\t</div>\n\t\t\t{{else}}\n\t\t\t\t{{#if equals type 'table'}}\n\t\t\t\t\t<div class=\"panel panel-default steedos-table\">\n\t\t\t\t\t\t<div class=\"panel-body\" style=\"padding:0px;\">\n\t\t\t\t\t\t\t<div class=\"panel-heading\" >\n\t\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t<span class=\"description\">{{{description}}}</span>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t<div class=\"readonly-table\" style=\"padding:0px;overflow-x:auto;\">\n\t\t\t\t\t\t\t\t\t<table type='table' class=\"table table-bordered table-condensed autoform-table\" style='margin-bottom:0px;' {{this.atts}} id=\"{{this.code}}Table\" name=\"{{this.code}}\" data-schema-key=\"{{this.name}}\">\n\t\t\t\t\t\t\t\t\t\t<thead id=\"{{this.name}}Thead\" name=\"{{this.name}}Thead\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\n\t\t\t\t\t\t\t\t\t\t</thead>\n\t\t\t\t\t\t\t\t\t\t<tbody id=\"{{this.name}}Tbody\" name=\"{{this.name}}Tbody\">\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\n\t\t\t\t\t\t\t\t\t\t</tbody>\n\t\t\t\t\t\t\t\t\t</table>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if equals type 'input'}}\n\t\t\t\t\t\t<div class=\"form-group\" data-required=\"{{#if is_required}}true{{/if}}\">\n\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t{{#if is_textarea}}\n\t\t\t\t\t\t\t\t<textarea title=\"{{getLabel code}}\" name=\"{{code}}\" {{getPermissions code}} data-schema-key=\"{{getLabel code}}\" class=\"form-control\"></textarea>\n\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t{{#unless is_textarea}}\n\t\t\t\t\t\t\t\t<input type=\"text\" title=\"{{getLabel code}}\" name=\"{{code}}\" {{getPermissions code}} data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t{{/unless}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t{{#if equals type 'number'}}\n\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t<input type=\"number\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t{{#if equals type 'date'}}\n\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t<input type=\"text\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-type=\"date\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t{{#if equals type 'dateTime'}}\n\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t<input type=\"text\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-type='datetime' data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t{{#if equals type 'password'}}\n\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t<input type=\"password\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t{{#if equals type 'select'}}\n\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t<select name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<option value=\"{{value}}\">{{label}}</option>\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n\t\t\t\t\t\t\t\t\t\t\t\t</select>\n\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'radio'}}\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"af-radio-group\" data-schema-key=\"{{getLabel code}}\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n        \t\t\t\t\t\t\t\t\t\t\t\t<label class=\"radio-inline fix-indent\"><input type=\"radio\" value=\"{{value}}\" name=\"{{../code}}\" class=\"radio-inline fix-indent\"> {{label}}</label>\n    \t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n    \t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'multiSelect'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"af-checkbox-group\" data-schema-key=\"{{getLabel code}}\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label class=\"checkbox-inline fix-indent\"><input type=\"checkbox\" value=\"{{value}}\" name=\"{{../code}}\" class=\"checkbox-inline fix-indent\"> {{label}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'url'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\"url\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'email'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\"email\" title=\"{{getLabel code}}\" name=\"{{code}}\" data-schema-key=\"{{getLabel code}}\" class=\"form-control\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'checkbox'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"checkbox\" data-schema-key=\"{{getLabel code}}\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label style=\"width: 100%;\"><input type=\"checkbox\" value=\"true\" name=\"{{code}}\" class=\"checkbox-inline fix-indent\"></label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\"7ZQnDsXBGohZMetA5\" class=\"control-label\">{{getLabel code}}</label>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/if}}\n\t\t{{/with}}\n\"\"\"\n\nInstanceReadOnlyTemplate.create = (tempalteName, steedosData) ->\n\ttemplate = InstanceReadOnlyTemplate[tempalteName]\n\n\ttemplateCompiled = SpacebarsCompiler.compile(template, {isBody: true});\n\n\ttemplateRenderFunction = eval(templateCompiled);\n\n\tTemplate[tempalteName] = new Blaze.Template(tempalteName, templateRenderFunction);\n\tTemplate[tempalteName].steedosData = steedosData\n\tTemplate[tempalteName].helpers InstanceformTemplate.helpers\n\nInstanceReadOnlyTemplate.createInstanceSignText = (steedosData)->\n\tinstanceSignTextHtml = _getViewHtml('client/views/instance/instance_sign_text.html')\n\n\tinstanceSignTextCompiled = SpacebarsCompiler.compile(instanceSignTextHtml, {isBody: true});\n\n\tinstanceSignTextRenderFunction = eval(instanceSignTextCompiled);\n\n\tTemplate.instanceSignText = new Blaze.Template(\"instanceSignText\", instanceSignTextRenderFunction);\n\tTemplate.instanceSignText.steedosData = steedosData\n\tTemplate.instanceSignText.helpers InstanceSignText.helpers\n\nInstanceReadOnlyTemplate.createImageSign = (steedosData) ->\n\timageSignHtml = _getViewHtml('client/views/instance/image_sign.html')\n\timageSignCompiled = SpacebarsCompiler.compile(imageSignHtml, {isBody: true});\n\timageSignRenderFunction = eval(imageSignCompiled);\n\tTemplate.imageSign = new Blaze.Template(\"imageSign\", imageSignRenderFunction);\n\tTemplate.imageSign.steedosData = steedosData\n\tTemplate.imageSign.helpers ImageSign.helpers\n\nInstanceReadOnlyTemplate.createTracesHanlder = (steedosData) ->\n\ttracesHanlderHtml = _getViewHtml('client/views/instance/traces_handler.html')\n\ttracesHanlderCompiled = SpacebarsCompiler.compile(tracesHanlderHtml, {isBody: true});\n\ttracesHanlderRenderFunction = eval(tracesHanlderCompiled);\n\tTemplate.instance_traces_handler = new Blaze.Template(\"instance_traces_handler\", tracesHanlderRenderFunction);\n\tTemplate.instance_traces_handler.steedosData = steedosData\n\tTemplate.instance_traces_handler.helpers TracesHandler.helpers\n\n\nInstanceReadOnlyTemplate.init = (steedosData) ->\n\tInstanceReadOnlyTemplate.create(\"afSelectUserRead\", steedosData);\n\n\tif Meteor.isServer\n\t\tInstanceReadOnlyTemplate.create(\"afFormGroup\", steedosData);\n\n\tInstanceReadOnlyTemplate.create(\"afFormGroupRead\", steedosData);\n\tif Meteor.isServer\n\t\tInstanceReadOnlyTemplate.create(\"instance_attachment\", {absolute: steedosData.absolute});\n\t\tInstanceReadOnlyTemplate.createImageSign(steedosData)\n\t\tInstanceReadOnlyTemplate.createTracesHanlder(steedosData);\n\t\tInstanceReadOnlyTemplate.createInstanceSignText(steedosData)\n\ngetLinkText = (item, label, detail_url)->\n\tif detail_url\n\t\tdetail_url = detail_url.replace(\"{_id}\", item._id)\n\t\tif !/^http(s?):\\/\\//.test(detail_url)\n\t\t\tdetail_url = Steedos.absoluteUrl(detail_url)\n\t\treturn '<a href=\"'+detail_url+'\" target=\"_blank\">'+label+'</a>';\n\telse\n\t\treturn label\n\nInstanceReadOnlyTemplate.getValue = (value, field, locale, utcOffset) ->\n\tif !value && value != false\n\t\treturn ''\n\tif [\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1\n\t\tfieldOptions = field.options.split(\"\\n\").map (n)->\n\t\t\titemSplits = n.split(\":\")\n\t\t\treturn {\n\t\t\t\tlabel: itemSplits[0],\n\t\t\t\tvalue: itemSplits[1] || n\n\t\t\t}\n\tswitch field.type\n\t\twhen 'email'\n\t\t\tvalue = if value then '<a href=\\'mailto:' + value + '\\'>' + value + '</a>' else ''\n\t\twhen 'url'\n\t\t\tif value\n\t\t\t\tif value.indexOf(\"http\") == 0\n\t\t\t\t\ttry\n\t\t\t\t\t\tvalue = \"<a href='\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n\t\t\t\t\tcatch e\n\t\t\t\t\t\tvalue = \"<a href='' target='_blank'>\" + value + \"</a>\";\n\n\t\t\t\telse\n\t\t\t\t\tvalue = \"<a href='http://\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n\t\t\telse\n\t\t\t\tvalue = ''\n\t\twhen 'group'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = value?.getProperty(\"fullname\").toString()\n\t\t\telse\n\t\t\t\tvalue = value?.fullname\n\t\twhen 'user'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = value?.getProperty(\"name\").toString()\n\t\t\telse\n\t\t\t\tvalue = value?.name\n\t\twhen 'password'\n\t\t\tvalue = '******'\n\t\twhen 'checkbox'\n\t\t\tif value && value != 'false'\n\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\", {}, locale)\n\t\t\telse\n\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\", {}, locale)\n\t\twhen 'dateTime'\n\t\t\tif value && value.length == 16\n\t\t\t\tt = value.split(\"T\")\n\t\t\t\tt0 = t[0].split(\"-\");\n\t\t\t\tt1 = t[1].split(\":\");\n\n\t\t\t\tyear = t0[0];\n\t\t\t\tmonth = t0[1];\n\t\t\t\tdate = t0[2];\n\t\t\t\thours = t1[0];\n\t\t\t\tseconds = t1[1];\n\n\t\t\t\tvalue = new Date(year, month - 1, date, hours, seconds)\n\t\t\telse\n\t\t\t\tvalue = new Date(value)\n\n\t\t\tvalue = InstanceReadOnlyTemplate.formatDate(value, utcOffset);\n\t\twhen 'time'\n\t\t\tif value && value.length == 16\n\t\t\t\tt = value.split(\"T\")\n\t\t\t\tt0 = t[0].split(\"-\");\n\t\t\t\tt1 = t[1].split(\":\");\n\n\t\t\t\tyear = t0[0];\n\t\t\t\tmonth = t0[1];\n\t\t\t\tdate = t0[2];\n\t\t\t\thours = t1[0];\n\t\t\t\tseconds = t1[1];\n\n\t\t\t\tvalue = new Date(year, month - 1, date, hours, seconds)\n\t\t\telse\n\t\t\t\tvalue = new Date(value)\n\n\t\t\tvalue = InstanceReadOnlyTemplate.formatTime(value);\n\t\twhen 'input'\n\t\t\tif field.is_textarea\n\t\t\t\tvalue = value\n\t\twhen 'select'\n\t\t\tselectedOption = fieldOptions.find((item) -> return item.value == value)\n\t\t\tif selectedOption\n\t\t\t\tvalue = selectedOption.label\n\t\twhen 'radio'\n\t\t\tselectedOption = fieldOptions.find((item) -> return item.value == value)\n\t\t\tif selectedOption\n\t\t\t\tvalue = selectedOption.label\n\t\twhen 'multiSelect'\n\t\t\tsplitedValues = value.split(\",\")\n\t\t\tselectedOptions = fieldOptions.filter((item) -> return splitedValues.indexOf(item.value) > -1)\n\t\t\tif selectedOptions.length\n\t\t\t\tvalue = selectedOptions.map((item) -> return item.label).join(\",\")\n\t\twhen 'number'\n\t\t\tif value or value == 0\n\t\t\t\tif field.is_percent\n\t\t\t\t\tvalue = Steedos.numberToPercentString value, field.digits\n\t\t\t\telse\n\t\t\t\t\tvalue = Steedos.numberToString value, field.digits\n\t\twhen 'odata'\n\t\t\tdetail_url = field.detail_url\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = _.map value, (item)->\n\t\t\t\t\treturn getLinkText(item, item['@label'], detail_url)\n\t\t\telse\n\t\t\t\tvalue = getLinkText(value, value['@label'], detail_url)\n\t\twhen 'image'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = _.map value, (item)->\n\t\t\t\t\treturn '<div class=\"antd-ImageControl-item is-uploaded\">\n\t\t\t\t\t\t<div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\">\n\t\t\t\t\t\t\t<div class=\"antd-Image-thumbWrap\">\n\t\t\t\t\t\t\t\t<div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\"\n\t\t\t\t\t\t\t\t\t\tsrc=\"/api/files/images/'+item+'\"></div>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>'\n\t\t\t\tvalue = value.join(\"\");\n\t\t\telse\n\t\t\t\tvalue = '<div class=\"antd-ImageControl-item is-uploaded\">\n\t\t\t\t\t\t<div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\">\n\t\t\t\t\t\t\t<div class=\"antd-Image-thumbWrap\">\n\t\t\t\t\t\t\t\t<div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\"\n\t\t\t\t\t\t\t\t\t\tsrc=\"/api/files/images/'+value+'\"></div>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>'\n\t\twhen 'file'\n\t\t\tif value\n\t\t\t\tif !field.is_multiselect\n\t\t\t\t\tvalue = [value]\n\t\t\t\tif Meteor.isClient\n\t\t\t\t\tres = Steedos.authRequest('/api/v1/cfs_files_filerecord?filters=[[\"_id\",\"in\", '+JSON.stringify(value)+']]&fields=[\"_id\",\"original\"]', {async:false})\n\t\t\t\t\trecords = res.data.items\n\t\t\t\telse if Meteor.isServer\n\t\t\t\t\trecords = Steedos.objectFind(\"cfs_files_filerecord\", { filters: [[\"_id\", 'in', value]], fields: [\"_id\", \"original\"] });\n\n\t\t\t\tvalue = _.map records, (item)->\n\t\t\t\t\tfileName = item.original.name;\n\t\t\t\t\tfileUrl = Steedos.absoluteUrl('/api/files/files/'+item._id);\n\t\t\t\t\tfilePreviewHtml = '';\n\t\t\t\t\tif [\".pdf\", \".jpg\", \".jpeg\", \".png\", \".gif\"].indexOf(fileName.toLowerCase().slice(-4)) > -1\n\t\t\t\t\t\tfilePreviewHtml = \"&ensp;<a href='#{fileUrl}' target='_blank' class='antd-Link'><span class='antd-TplField'><span>预览</span></span></a>\"\n\t\t\t\t\treturn \"<div><a href='#{fileUrl+'?download=true'}' target='_blank'>#{fileName}</a> #{filePreviewHtml ? filePreviewHtml : ''}</div>\"\n\n\t\t\t\tvalue = value.join(\"\");\n\t\twhen 'lookup'\n\t\t\tif value\n\t\t\t\tif !field.is_multiselect\n\t\t\t\t\tvalue = [value]\n\t\t\t\tif Meteor.isClient\n\t\t\t\t\tuiSchema = Creator.getObject(field.reference_to)\n\t\t\t\t\tnameField = uiSchema?.NAME_FIELD_KEY || 'name'\n\t\t\t\t\tres = Steedos.authRequest('/api/v1/'+field.reference_to+'?filters=[[\"'+(field.reference_to_field || '_id')+'\",\"in\", '+JSON.stringify(value)+']]&fields=[\"_id\",\"'+nameField+'\"]', {async:false})\n\t\t\t\t\trecords = res.data.items\n\t\t\t\telse if Meteor.isServer\n\t\t\t\t\tnameField = Steedos.getObjectNameFieldKey(field.reference_to);\n\t\t\t\t\trecords = Steedos.objectFind(field.reference_to, { filters: [[(field.reference_to_field || '_id'), 'in', value]], fields: [\"_id\", nameField] });\n\t\t\t\tvalue = _.map records, (item)->\n\t\t\t\t\treturn \"<a href='#{Steedos.absoluteUrl('/app/-/'+field.reference_to+'/view/'+item._id)}' target='_blank'>#{item[nameField]}</a>\"\n\n\t\t\t\tvalue = value.join(\" , \");\t\n\t\twhen 'html'\n\t\t\tvalue = if value then \"<div class=\\\"steedos-html\\\">#{value}</div>\" else ''\n\n\treturn value;\n\nInstanceReadOnlyTemplate.getLabel = (fields, code) ->\n\tfield = fields.findPropertyByPK(\"code\", code)\n\tif field\n\t\tif field.name\n\t\t\treturn field.name\n\t\telse\n\t\t\treturn field.code\n\n\nInstanceReadOnlyTemplate.getInstanceFormVersion = (instance)->\n\tform = db.forms.findOne(instance.form);\n\n\tform_version = {}\n\n\tform_fields = [];\n\n\tif form.current._id == instance.form_version\n\t\tform_version = form.current\n\telse\n\t\tform_version = _.where(form.historys, {_id: instance.form_version})[0]\n\n\tform_version.fields.forEach (field)->\n\t\tif field.type == 'section'\n\t\t\tform_fields.push(field);\n\t\t\tif field.fields\n\t\t\t\tfield.fields.forEach (f) ->\n\t\t\t\t\tform_fields.push(f);\n\t\telse if field.type == 'table'\n\t\t\tfield['sfields'] = field['fields']\n\t\t\tdelete field['fields']\n\t\t\tform_fields.push(field);\n\t\telse\n\t\t\tform_fields.push(field);\n\n\tform_version.fields = form_fields;\n\n\treturn form_version;\n\nInstanceReadOnlyTemplate.getFlowVersion = (instance)->\n\tflow = db.flows.findOne(instance.flow);\n\tflow_version = {}\n\tif flow.current._id == instance.flow_version\n\t\tflow_version = flow.current\n\telse\n\t\tflow_version = _.where(flow.historys, {_id: instance.flow_version})[0]\n\n\treturn flow_version;\n\n\n_getViewHtml = (path) ->\n\tviewHtml = Assets.getText(path)\n\n\tif viewHtml\n\t\tviewHtml = viewHtml.replace(/<template[\\w\\s\\\"\\=']+>/i,\"\").replace(/<\\/template>/i,\"\")\n\n\treturn viewHtml;\n\n_getLocale = (user)->\n\tif user?.locale?.toLocaleLowerCase() == 'zh-cn'\n\t\tlocale = \"zh-CN\"\n\telse if user?.locale?.toLocaleLowerCase() == 'en-us'\n\t\tlocale = \"en\"\n\telse\n\t\tlocale = \"zh-CN\"\n\treturn locale\n\n\n_getRequiredFields = (fields, rev)->\n\tif !rev\n\t\trev = [];\n\n\tfields.forEach (field)->\n\t\tif field.type == 'section'\n\t\t\t_getRequiredFields(field.fields, rev)\n\t\telse if field.type == 'table'\n\n\t\telse\n\t\t\tif field.is_required\n\t\t\t\trev.push field.code\n\treturn rev;\n\n_getStartStepEditableFields = (fields, steps)->\n\tstartStep = steps.findPropertyByPK(\"step_type\",\"start\")\n\n\teditableCode = []\n\n\t_.keys(startStep.permissions).forEach (key)->\n\t\tif startStep.permissions[key] == 'editable'\n\t\t\teditableCode.push key\n\n\treturn editableCode\n\n_getStartStepRequiredFields = (fields, steps)->\n\trequiredFields = _getRequiredFields(fields)\n\n\teditableCode = _getStartStepEditableFields(fields, steps)\n\n\treturn _.intersection(requiredFields, editableCode)\n\n_getTemplateData = (user, space, instance, options)->\n\tif Meteor.isServer\n\t\tform_version = InstanceReadOnlyTemplate.getInstanceFormVersion(instance)\n\telse\n\t\tform_version = WorkflowManager.getInstanceFormVersion(instance)\n\n\tlocale = _getLocale(user)\n\n\tsteedosData = {}\n\n\tif Meteor.isClient\n\t\tsteedosData = _.clone(WorkflowManager_format.getAutoformSchemaValues())\n\t\tsteedosData.insname = instance.name\n\t\tsteedosData.ins_state = instance.state\n\t\tsteedosData.ins_final_decision = instance.ins_final_decision\n\t\tsteedosData.ins_code = instance.code\n\t\tsteedosData.ins_is_archived = instance.is_archived\n\t\tsteedosData.ins_is_deleted = instance.ins_is_deleted\n\t\tsteedosData.applicant_name = instance.applicant_name\n\t\tsteedosData.applicantContext = instance.applicant_name\n\n\tsteedosData.instance = instance\n\tsteedosData.form_version = form_version\n\tsteedosData.locale = locale\n\tsteedosData.utcOffset = user.utcOffset\n\tsteedosData.space = instance.space\n\tsteedosData.sessionUserId = user._id\n\n\tif Meteor.isServer\n\t\tif options?.editable\n\t\t\tform = db.forms.findOne({_id: instance.form})\n\n\t\t\tflow = db.flows.findOne({_id: instance.flow})\n\n\t\t\tsteedosData.startStepEditableFields = _getStartStepEditableFields(form.current.fields, flow.current.steps);\n\n\treturn steedosData;\n\nInstanceReadOnlyTemplate.formatDate = (date, utcOffset)->\n\tif Meteor.isServer\n\t\tpassing = false;\n\telse\n\t\tpassing = true;\n\n\tif !utcOffset && utcOffset !=0\n\t\tutcOffset = 8\n\n\treturn moment(date).utcOffset(utcOffset, passing).format(\"YYYY-MM-DD HH:mm\");\n\nInstanceReadOnlyTemplate.formatTime = (date)->\n\tutcOffset = 0\n\treturn moment(date).utcOffset(utcOffset).format(\"HH:mm\");\n\nInstanceReadOnlyTemplate.getInstanceView = (user, space, instance, options)->\n\n\tsteedosData = _getTemplateData(user, space, instance, options)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\tinstanceTemplate = TemplateManager.getTemplate(instance, options?.templateName);\n\n\tinstanceTemplate = instanceTemplate.replace(/afSelectUser/g,\"afSelectUserRead\")\n\n\tif !options?.editable\n\t\tinstanceTemplate = instanceTemplate.replace(/afFormGroup/g,\"afFormGroupRead\")\n\n\tinstanceCompiled = SpacebarsCompiler.compile(instanceTemplate, {isBody: true});\n\n\tinstanceRenderFunction = eval(instanceCompiled);\n\n\tTemplate.instance_readonly_view = new Blaze.Template(\"instance_readonly_view\", instanceRenderFunction);\n\n\tTemplate.instance_readonly_view.steedosData = steedosData\n\n\tTemplate.instance_readonly_view.helpers InstanceformTemplate.helpers\n\n\tInstanceReadOnlyTemplate.init(steedosData);\n\n\tbody = Blaze.toHTMLWithData(Template.instance_readonly_view, steedosData)\n\n\treturn \"\"\"\n\t\t<div id='instanceform' >\n\t\t\t#{body}\n\t\t</div>\n\t\"\"\"\n\nInstanceReadOnlyTemplate.getTracesView = (user, space, instance, options)->\n\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tform = db.forms.findOne(instance.form);\n\tif form.instance_style == \"table\" || options?.templateName == \"table\"\n\t\ttracesHtml = _getViewHtml('client/views/instance/traces_table.html')\n\telse\n\t\ttracesHtml = _getViewHtml('client/views/instance/traces.html')\n\n\ttraceCompiled = SpacebarsCompiler.compile(tracesHtml, {isBody: true});\n\n\ttraceRenderFunction = eval(traceCompiled);\n\n\tTemplate.trace_readonly_view = new Blaze.Template(\"trace_readonly_view\", traceRenderFunction);\n\n\tTemplate.trace_readonly_view.steedosData = steedosData\n\n\tTemplate.trace_readonly_view.helpers TracesTemplate.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.trace_readonly_view, instance.traces)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getAttachmentView = (user, space, instance)->\n\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tattachmentHtml = _getViewHtml('client/views/instance/instance_attachments.html')\n\n\tattachmentCompiled = SpacebarsCompiler.compile(attachmentHtml, {isBody: true});\n\n\tattachmentRenderFunction = eval(attachmentCompiled);\n\n\tTemplate.attachments_readonly_view = new Blaze.Template(\"attachments_readonly_view\", attachmentRenderFunction);\n\n\tTemplate.attachments_readonly_view.steedosData = steedosData\n\n\tTemplate.attachments_readonly_view.helpers InstanceAttachmentTemplate.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.attachments_readonly_view)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getRelatedInstancesView = (user, space, instance, options)->\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\trelatedInstancesHtml = _getViewHtml('client/views/instance/related_instances.html')\n\n\trelatedInstancesCompiled = SpacebarsCompiler.compile(relatedInstancesHtml, {isBody: true});\n\n\trelatedInstancesRenderFunction = eval(relatedInstancesCompiled);\n\n\tTemplate.related_instances_view = new Blaze.Template(\"related_instances_view\", relatedInstancesRenderFunction);\n\n\tTemplate.related_instances_view.steedosData = steedosData\n\n\tTemplate.related_instances_view.helpers RelatedInstances.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.related_instances_view, steedosData)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getRelatedRecordsView = (user, space, instance, options)->\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\trelatedRecordsHtml = _getViewHtml('client/views/instance/related_records.html')\n\n\trelatedRecordsCompiled = SpacebarsCompiler.compile(relatedRecordsHtml, {isBody: true});\n\n\trelatedRecordsRenderFunction = eval(relatedRecordsCompiled);\n\n\tTemplate.related_records_view = new Blaze.Template(\"related_records_view\", relatedRecordsRenderFunction);\n\n\tTemplate.related_records_view.steedosData = steedosData\n\n\tTemplate.related_records_view.helpers RelatedRecords.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.related_records_view, steedosData)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getOnLoadScript = (instance)->\n\tform_version = WorkflowManager.getFormVersion(instance.form, instance.form_version)\n\n\tform_script = form_version.form_script;\n\n\tif form_script && form_script.replace(/\\n/g,\"\").replace(/\\s/g,\"\").length > 0\n\t\tform_script = \"CoreForm = {};CoreForm.instanceform = {};\" + form_script\n\t\tform_script += \";if(CoreForm.form_OnLoad){window.onload = CoreForm.form_OnLoad();}\"\n\telse\n\t\tform_script = \"\"\n\n\n\nInstanceReadOnlyTemplate.getInstanceHtml = (user, space, instance, options)->\n\n\tbody = InstanceReadOnlyTemplate.getInstanceView(user, space, instance, options);\n\n\tonLoadScript = InstanceReadOnlyTemplate.getOnLoadScript(instance);\n\n\tcreatorService = Meteor.settings.public.webservices?.creator?.url\n\tins_record_ids = instance.record_ids\n\tlocale = _getLocale(user);\n\topenFileScript = \"\"\"\n\t\t\tif(window.isNode && isNode()){\n\t\t\t\tattachs = document.getElementsByClassName(\"ins_attach_href\");\n\t\t\t\tfor(var i = 0; i < attachs.length; i++){\n\t\t\t\t\tattach = attachs[i];\n\t\t\t\t\tattach.addEventListener(\"click\", function(e){\n\t\t\t\t\t\tif(isImage(this.dataset.type) || isHtml(this.dataset.type)){\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\topenWindow(\"/api/files/instances/\" + this.dataset.id);\n\t\t\t\t\t\t}else if(nw_core.canOpenFile(this.dataset.name)){\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\tnw_core.openFile(this.href, this.dataset.name)\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar flow = \"#{instance.flow}\";\n\t\t\tvar space = \"#{instance.space}\";\n\n\t\t\tfunction getCookie(name){\n\t\t\t\tlet pattern = RegExp(name + \"=.[^;]*\")\n\t\t\t\tlet matched = document.cookie.match(pattern)\n\t\t\t\tif(matched){\n\t\t\t\t\tlet cookie = matched[0].split('=')\n\t\t\t\t\treturn cookie[1]\n\t\t\t\t}\n\t\t\t\treturn ''\n\t\t\t}\n\n\t\t\tvar records = document.getElementsByClassName(\"ins-related-records\");\n\t\t\tfor(var i = 0; i < records.length; i++){\n\t\t\t\t\tvar record = records[i];\n\t\t\t\t\trecord.addEventListener(\"click\", function(e){\n\t\t\t\t\t\tvar creatorService = \"#{creatorService}\"\n\t\t\t\t\t\tvar ins_record_ids = #{JSON.stringify(ins_record_ids)}\n\t\t\t\t\t\tif(creatorService && ins_record_ids && ins_record_ids.length > 0){\n\t\t\t\t\t\t\tvar objcetName = ins_record_ids[0].o\n\t\t\t\t\t\t\tvar id = ins_record_ids[0].ids[0]\n\t\t\t\t\t\t\tvar uobj = {};\n\t\t\t\t\t\t\tuobj[\"X-User-Id\"] = getCookie(\"X-User-Id\");\n\t\t\t\t\t\t\tuobj[\"X-Auth-Token\"] = getCookie(\"X-Auth-Token\");\n\t\t\t\t\t\t\tredirectUrl = creatorService + \"app/-/\" + objcetName + \"/view/\" + id + \"?\" + $.param(uobj);\n\t\t\t\t\t\t\topenWindow(redirectUrl);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\"\"\";\n\n\n\tif !Steedos.isMobile()\n\t\tform = db.forms.findOne(instance.form);\n\t\tif form?.instance_style == 'table'\n\t\t\tinstance_style = \"instance-table\"\n\n\tif options?.templateName == 'table'\n\t\tinstance_style = \"instance-table\"\n\n\tif options?.instance_style\n\t\tinstance_style = options.instance_style\n\n\tif !options || options.showTrace == true\n\t\ttrace = InstanceReadOnlyTemplate.getTracesView(user, space, instance)\n\telse\n\t\ttrace = \"\"\n\n\tinstanceBoxStyle = \"\";\n\n\tif instance && instance.final_decision\n\t\tif instance.final_decision == \"approved\"\n\t\t\tinstanceBoxStyle = \"box-success\"\n\t\telse if (instance.final_decision == \"rejected\")\n\t\t\tinstanceBoxStyle = \"box-danger\"\n\tif !options || options.showAttachments == true\n\t\tattachment = InstanceReadOnlyTemplate.getAttachmentView(user, space, instance)\n\t\trelated_instances = InstanceReadOnlyTemplate.getRelatedInstancesView(user, space, instance, options)\n\t\trelated_records = InstanceReadOnlyTemplate.getRelatedRecordsView(user, space, instance, options)\n\telse\n\t\tattachment = \"\"\n\t\trelated_instances = \"\"\n\t\trelated_records = \"\"\n\n\n\twidth = \"960px\"\n\t#\t如果给table的parent设置width，则会导致阿里云邮箱显示table 异常\n\tif options?.width\n\t\twidth = \"\"\n\n\tcssHref = Meteor.absoluteUrl(\"steedos-css\")\n\t\n\tjqHref = Meteor.absoluteUrl(\"website/libs/jquery.min.js\")\n\n\tallCssLink = \"\"\"<link rel=\"stylesheet\" type=\"text/css\" class=\"__meteor-css__\" href=\"#{cssHref}\">\"\"\"\n\n\ttraceCheck = \"\"\n\tif !_.isEmpty(trace)\n\t\ttraceCheck = \"checked\"\n\tif options?.tagger == 'email' || options?.editable\n\t\tshowTracesBtn = \"\"\n\telse\n\t\tshowTracesBtn = \"\"\"\n\t\t\t<div class=\"navigation-bar btn-group no-print\" style=\"min-width: 600px; z-index: 999; box-sizing: border-box;\">\n\t\t\t\t<div class=\"print-tool\">\n\t\t\t\t\t<label class=\"cbx-label\"><input type=\"checkbox\" class=\"cbx-print cbx-print-attachments\" id=\"cbx-print-attachments\" checked=\"checked\"><span>#{TAPi18n.__('instance_attachment', {}, locale)}</span></label>\n\t\t\t\t\t<label class=\"cbx-label\"><input type=\"checkbox\" class=\"cbx-print cbx-print-traces\" id=\"cbx-print-traces\" checked=\"#{traceCheck}\"><span>#{TAPi18n.__('instance_approval_history', {}, locale)}</span></label>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\t\"\"\"\n\n\tshowTracesScript = \"\"\"\n\t\t$( document ).ready(function(){\n\t\t\tvar b = document.getElementById('cbx-print-traces');\n\t\t\tvar t = document.getElementsByClassName('instance-traces')[0];\n\t\t\tif (b && b.checked && t){\n\t\t\t\tt.style = 'display: block;'\n\t\t\t} else if(t){\n\t\t\t\tt.style = 'display: none;'\n\t\t\t}\n\t\t\tif(b){\n\t\t\t\tb.addEventListener('change', function(e){\n\t\t\t\t\tif (e.target.checked){\n\t\t\t\t\t\tt.style = 'display: block;'\n\t\t\t\t\t} else {\n\t\t\t\t\t\tt.style = 'display: none;'\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\n\n\t\t\tvar attachmentsCheckbox = document.getElementById('cbx-print-attachments');\n\t\t\tvar attachmentsView = document.getElementsByClassName('attachments-section')[0];\n\t\t\tif (attachmentsCheckbox && attachmentsCheckbox.checked && attachmentsView){\n\t\t\t\tattachmentsView.style = 'display: block;'\n\t\t\t} else if(attachmentsView){\n\t\t\t\tattachmentsView.style = 'display: none;'\n\t\t\t}\n\t\t\tif(attachmentsCheckbox){\n\t\t\t\tattachmentsCheckbox.addEventListener('change', function(e){\n\t\t\t\t\tif (e.target.checked){\n\t\t\t\t\t\tattachmentsView.style = 'display: block;'\n\t\t\t\t\t} else {\n\t\t\t\t\t\tattachmentsView.style = 'display: none;'\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\"\"\"\n\n\tif options?.styles\n\t\tallCssLink = \"\"\n\n\tform = db.forms.findOne({_id: instance.form});\n\tformDescriptionHtml = \"\"\n\tif form\n\t\tformDescription = form.description\n\t\tif formDescription\n\t\t\tformDescription = formDescription.replace(/\\n/g,\"<br/>\")\n\t\t\tformDescriptionHtml = \"\"\"\n\t\t\t\t<div class=\"box-header  with-border instance-header\">\n\t\t\t\t\t<div>\n\t\t\t\t\t\t#{formDescription}\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t\t\"\"\"\n\n\thtml = \"\"\"\n\t\t<!DOCTYPE html>\n\t\t<html>\n\t\t\t<head>\n\t\t\t\t<meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\"/>\n\t\t\t\t#{allCssLink}\n\t\t\t\t<script src=\"#{jqHref}\" type=\"text/javascript\"></script>\n\t\t\t\t<script src=\"/js/nw_core.js\" type=\"text/javascript\"></script>\n\t\t\t\t#{options.plugins || \"\"}\n\n\t\t\t\t<style>\n\t\t\t\t\t.steedos{\n\t\t\t\t\t\twidth: #{width};\n\t\t\t\t\t\tmargin-left: auto;\n\t\t\t\t\t\tmargin-right: auto;\n\t\t\t\t\t}\n\n\t\t\t\t\t.instance-view .instance-name{\n\t\t\t\t\t\tdisplay: inline !important\n\t\t\t\t\t}\n\t\t\t\t\t.box-tools{\n\t\t\t\t\t\tdisplay: none;\n\t\t\t\t\t}\n\t\t\t\t\t.box.collapsed-box .box-body,.box.collapsed-box .box-footer {\n\t\t\t\t\t  display: block;\n\t\t\t\t\t}\n\n\t\t\t\t\tbody{\n\t\t\t\t\t\tbackground: azure !important;\n\t\t\t\t\t}\n\n\t\t\t\t\t.instance-view .instance-traces{\n\t\t\t\t\t\tpadding-left: 15px;\n\t\t\t\t\t\tpadding-right: 15px;\n\t\t\t\t\t}\n\n\t\t\t\t\t.antd-ImageControl-item {\n\t\t\t\t\tborder-radius: var(--ImageControl-addBtn-borderRadius);\n\t\t\t\t\tvertical-align: top;\n\t\t\t\t\tpadding: var(--gap-xs);\n\t\t\t\t\tdisplay: inline-block;\n\t\t\t\t\tmargin-right: var(--gap-base);\n\t\t\t\t\tmargin-bottom: var(--gap-base);\n\t\t\t\t\tposition: relative;\n\t\t\t\t\twidth: 7.5rem;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item.is-invalid {\n\t\t\t\t\tpadding: 0;\n\t\t\t\t\tborder-color: var(--FileControl-danger-color);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item svg.icon-refresh {\n\t\t\t\t\ttransform: rotate(180deg);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-filename {\n\t\t\t\t\tdisplay: inline-flex;\n\t\t\t\t\tflex-direction: column;\n\t\t\t\t\tjustify-content: center;\n\t\t\t\t\talign-items: center;\n\t\t\t\t\tcolor: var(--FileControl-danger-color);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-filename > svg.icon-image {\n\t\t\t\t\tmargin-bottom: 8px;\n\t\t\t\t\twidth: 24px;\n\t\t\t\t\theight: 24px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-filename > span {\n\t\t\t\t\tmax-width: 100%;\n\t\t\t\t\toverflow: hidden;\n\t\t\t\t\twhite-space: nowrap;\n\t\t\t\t\ttext-overflow: ellipsis;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-image {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\theight: 100%;\n\t\t\t\t\tpadding: 0;\n\t\t\t\t\tborder: none;\n\t\t\t\t\tdisplay: block;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemClear {\n\t\t\t\t\tposition: absolute;\n\t\t\t\t\tcursor: pointer;\n\t\t\t\t\tcolor: #999;\n\t\t\t\t\ttop: 5px;\n\t\t\t\t\tright: 5px;\n\t\t\t\t\tline-height: 1;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemClear > svg {\n\t\t\t\t\ttop: 0;\n\t\t\t\t\twidth: 10px;\n\t\t\t\t\theight: 10px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemInfo {\n\t\t\t\t\tdisplay: inline-flex;\n\t\t\t\t\twidth: 110px;\n\t\t\t\t\theight: 110px;\n\t\t\t\t\tjustify-content: center;\n\t\t\t\t\talign-items: center;\n\t\t\t\t\talign-content: center;\n\t\t\t\t\tflex-wrap: wrap;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-itemInfo > p {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\ttext-align: center;\n\t\t\t\t\tfont-size: 12px;\n\t\t\t\t\tmargin-bottom: 5px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-progress {\n\t\t\t\t\twidth: 70px;\n\t\t\t\t\theight: 5px;\n\t\t\t\t\tbackground: #ebebeb;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-progressValue {\n\t\t\t\t\theight: 5px;\n\t\t\t\t\tborder-radius: var(--ImageControl-progress-borderRadius);\n\t\t\t\t\tdisplay: block;\n\t\t\t\t\tbackground: var(--info);\n\t\t\t\t\tmin-width: 10%;\n\t\t\t\t\ttransition: ease-out width var(--animation-duration);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item.is-invalid .antd-ImageControl-itemClear {\n\t\t\t\t\tdisplay: none;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-item.is-invalid:hover .antd-ImageControl-itemClear {\n\t\t\t\t\tdisplay: block;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-errorMsg {\n\t\t\t\t\tcolor: var(--danger);\n\t\t\t\t\tmargin: 5px 0 0;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-uploadBtn {\n\t\t\t\t\tmargin-top: 5px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-cropperWrapper {\n\t\t\t\t\tposition: relative;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-cropperWrapper img {\n\t\t\t\t\tmax-width: 100%;\n\t\t\t\t\tmax-height: 400px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-croperToolbar {\n\t\t\t\t\tdisplay: inline-flex;\n\t\t\t\t\tposition: absolute;\n\t\t\t\t\tright: 0;\n\t\t\t\t\tbottom: 0;\n\t\t\t\t\tflex-direction: column;\n\t\t\t\t\talign-items: flex-end;\n\t\t\t\t\tbackground: #fff;\n\t\t\t\t\tborder-radius: 4px;\n\t\t\t\t\tmargin: 0.5rem;\n\t\t\t\t\tbox-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.1);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-croperToolbar > a {\n\t\t\t\t\tcolor: var(--Form-item-fontColor);\n\t\t\t\t\tpadding: 2px 5px;\n\t\t\t\t\tcursor: pointer;\n\t\t\t\t\tfont-size: 18px;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-croperToolbar > a:hover {\n\t\t\t\t\tcolor: var(--link-color);\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-acceptTip {\n\t\t\t\t\theight: 120px;\n\t\t\t\t\tcolor: #999;\n\t\t\t\t\tborder: 2px dashed var(--borderColor);\n\t\t\t\t\tborder-color: var(--info);\n\t\t\t\t\tbackground: #f3f9fe;\n\t\t\t\t\tborder-radius: var(--borderRadius);\n\t\t\t\t\tline-height: 120px;\n\t\t\t\t\ttext-align: center;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-fixed-size {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\theight: 100%;\n\t\t\t\t\tpadding: 0;\n\t\t\t\t\t}\n\t\t\t\t\t.antd-ImageControl-fixed-size .antd-ImageControl-itemOverlay {\n\t\t\t\t\twidth: 100%;\n\t\t\t\t\theight: 100%;\n\t\t\t\t\t}\n\n\t\t\t\t\t.antd-Images {\n\t\t\t\t\t\tdisplay: flex;\n\t\t\t\t\t\tflex-wrap: wrap;\n\t\t\t\t\t\tmargin: calc(var(--gap-xs) * -1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Images-item {\n\t\t\t\t\t\tdisplay: flex;\n\t\t\t\t\t\tmargin: var(--gap-xs);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image {\n\t\t\t\t\t\tborder: var(--borderWidth) solid var(--borderColor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image--thumb {\n\t\t\t\t\t\tdisplay: inline-block;\n\t\t\t\t\t\tpadding: var(--gap-xs);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumbWrap {\n\t\t\t\t\t\tposition: relative;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-image {\n\t\t\t\t\t\tdisplay: block;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-image--loading {\n\t\t\t\t\t\tvisibility: hidden;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image--original .antd-Image-image {\n\t\t\t\t\t\tmax-width: 100%;\n\t\t\t\t\t\tmax-height: 100%;\n\t\t\t\t\t\twidth: auto;\n\t\t\t\t\t\tmargin: auto;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb {\n\t\t\t\t\t\twidth: 6.875rem;\n\t\t\t\t\t\theight: 6.875rem;\n\t\t\t\t\t\tposition: relative;\n\t\t\t\t\t\toverflow: hidden;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb > img {\n\t\t\t\t\t\tposition: absolute;\n\t\t\t\t\t\tleft: 50%;\n\t\t\t\t\t\ttop: 50%;\n\t\t\t\t\t\tmax-height: 100%;\n\t\t\t\t\t\twidth: auto;\n\t\t\t\t\t\ttransform: translate(-50%, -50%);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-info {\n\t\t\t\t\t\tpadding: 5px 10px;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image--thumb .antd-Image-info {\n\t\t\t\t\t\twidth: 6.875rem;\n\t\t\t\t\t\tpadding: 0;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--4-3 {\n\t\t\t\t\t\theight: 5.15625rem;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--16-9 {\n\t\t\t\t\t\theight: 3.8671875rem;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--fixed-size {\n\t\t\t\t\t\tmin-width: 6.875rem;\n\t\t\t\t\t\tmin-height: 6.875rem;\n\t\t\t\t\t\twidth: 100%;\n\t\t\t\t\t\tpadding: 0;\n\t\t\t\t\t\theight: 100%;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb {\n\t\t\t\t\t\twidth: 100%;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb > img {\n\t\t\t\t\t\twidth: auto;\n\t\t\t\t\t\theight: 100%;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t.antd-Image-thumb--w-full > img {\n\t\t\t\t\t\twidth: 100%;\n\t\t\t\t\t\theight: auto;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t#{options?.styles || \"\"}\n\n\t\t\t\t\t#{options?.add_styles || \"\"}\n\t\t\t\t</style>\n\t\t\t</head>\n\t\t\t<body>\n\t\t\t\t<div class=\"steedos workflow instance-print\">\n\t\t\t\t\t<div class=\"skin-green skin-admin-lte\">\n\t\t\t\t\t\t<div class=\"wrapper\">\n\t\t\t\t\t\t\t<div class=\"content-wrapper\">\n\t\t\t\t\t\t\t\t#{showTracesBtn}\n\t\t\t\t\t\t\t\t<div class=\"instance-print\">\n\t\t\t\t\t\t\t\t\t<div class=\"instance #{instance_style}\">\n\t\t\t\t\t\t\t\t\t\t<form name=\"instanceForm\">\n\t\t\t\t\t\t\t\t\t\t\t<div class=\"instance-form box #{instanceBoxStyle}\">\n\t\t\t\t\t\t\t\t\t\t\t\t#{formDescriptionHtml}\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"box-body\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\"col-md-12\" style=\"box-sizing: border-box;\">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class='attachments-section'>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{attachment}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{related_instances}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{related_records}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{body}\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t\t</form>\n\t\t\t\t\t\t\t\t\t\t#{trace}\n\t\t\t\t\t\t\t\t\t</div>\n\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</body>\n\t\t\t<script>#{openFileScript};#{onLoadScript};#{showTracesScript}</script>\n\t\t</html>\n\t\"\"\"\n\n\treturn html","var _getLocale, _getRequiredFields, _getStartStepEditableFields, _getStartStepRequiredFields, _getTemplateData, _getViewHtml, getLinkText, marked;                          \n\nmarked = require(\"marked\");\n\nInstanceReadOnlyTemplate = {};\n\nInstanceReadOnlyTemplate.instance_attachment = \"<tr>\\n\t<td class=\\\"ins-attach-view\\\">\\n\t\t<a href=\\\"{{ins_attach_download_url _id absolute}}\\\" class=\\\"ins_attach_href\\\" target=\\\"_parent\\\" data-name=\\\"{{this.name}}\\\" data-type=\\\"{{this.original.type}}\\\" data-id=\\\"{{_id}}\\\">{{this.name}}</a>\\n\t</td>\\n</tr>\";\n\nInstanceReadOnlyTemplate.afSelectUserRead = \"<div class='selectUser form-control ins_applicant'>{{value}}</div>\";\n\nInstanceReadOnlyTemplate.afFormGroupRead = \"<div class='form-group'>\\n\t{{#with getField this.name}}\\n\t\t{{#if equals type 'section'}}\\n\t\t\t\t<div class='section callout callout-default'>\\n\t\t\t\t\t<label class=\\\"control-label\\\">{{f_label this}}</label>\\n\t\t\t\t\t<p>{{{description}}}</p>\\n\t\t\t\t</div>\\n\t\t{{else}}\\n\t\t\t{{#if equals type 'table'}}\\n\t\t\t\t<div class=\\\"panel panel-default steedos-table\\\">\\n\t\t\t\t\t<div class=\\\"panel-body\\\" style=\\\"padding:0px;\\\">\\n\t\t\t\t\t\t<div class=\\\"panel-heading\\\" >\\n\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\\n\t\t\t\t\t\t\t<span class=\\\"description\\\">{{{description}}}</span>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t<div class=\\\"readonly-table\\\" style=\\\"padding:0px;overflow-x:auto;\\\">\\n\t\t\t\t\t\t\t\t<table type='table' class=\\\"table table-bordered table-condensed autoform-table\\\" style='margin-bottom:0px;' {{this.atts}} id=\\\"{{this.code}}Table\\\" name=\\\"{{this.code}}\\\" data-schema-key=\\\"{{this.name}}\\\">\\n\t\t\t\t\t\t\t\t\t<thead id=\\\"{{this.name}}Thead\\\" name=\\\"{{this.name}}Thead\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\\n\t\t\t\t\t\t\t\t\t</thead>\\n\t\t\t\t\t\t\t\t\t<tbody id=\\\"{{this.name}}Tbody\\\" name=\\\"{{this.name}}Tbody\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\\n\t\t\t\t\t\t\t\t\t</tbody>\\n\t\t\t\t\t\t\t\t</table>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t{{else}}\\n\t\t\t\t{{#if showLabel}}\\n\t\t\t\t\t<label>{{getLabel code}}</label>\\n\t\t\t\t{{/if}}\\n\t\t\t\t{{#if isTextarea this}}\\n\t\t\t\t\t<p class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</p>\\n\t\t\t\t{{else}}\\n\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\\n\t\t\t\t{{/if}}\\n\t\t\t{{/if}}\\n\t\t{{/if}}\\n\t{{/with}}\\n</div>\";\n\nInstanceReadOnlyTemplate.afFormGroup = \"\\n{{#with getField this.name}}\\n\t\t{{#if equals type 'section'}}\\n\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t<div class='section callout callout-default'>\\n\t\t\t\t\t<label class=\\\"control-label\\\">{{f_label this}}</label>\\n\t\t\t\t\t<p>{{{description}}}</p>\\n\t\t\t\t</div>\\n  \t\t\t\t</div>\\n\t\t{{else}}\\n\t\t\t{{#if equals type 'table'}}\\n\t\t\t\t<div class=\\\"panel panel-default steedos-table\\\">\\n\t\t\t\t\t<div class=\\\"panel-body\\\" style=\\\"padding:0px;\\\">\\n\t\t\t\t\t\t<div class=\\\"panel-heading\\\" >\\n\t\t\t\t\t\t\t<label class='control-label'>{{getLabel code}}</label>\\n\t\t\t\t\t\t\t<span class=\\\"description\\\">{{{description}}}</span>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t<div class=\\\"readonly-table\\\" style=\\\"padding:0px;overflow-x:auto;\\\">\\n\t\t\t\t\t\t\t\t<table type='table' class=\\\"table table-bordered table-condensed autoform-table\\\" style='margin-bottom:0px;' {{this.atts}} id=\\\"{{this.code}}Table\\\" name=\\\"{{this.code}}\\\" data-schema-key=\\\"{{this.name}}\\\">\\n\t\t\t\t\t\t\t\t\t<thead id=\\\"{{this.name}}Thead\\\" name=\\\"{{this.name}}Thead\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\\n\t\t\t\t\t\t\t\t\t</thead>\\n\t\t\t\t\t\t\t\t\t<tbody id=\\\"{{this.name}}Tbody\\\" name=\\\"{{this.name}}Tbody\\\">\\n\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\\n\t\t\t\t\t\t\t\t\t</tbody>\\n\t\t\t\t\t\t\t\t</table>\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t{{else}}\\n\t\t\t\t{{#if equals type 'input'}}\\n\t\t\t\t\t<div class=\\\"form-group\\\" data-required=\\\"{{#if is_required}}true{{/if}}\\\">\\n\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t{{#if is_textarea}}\\n\t\t\t\t\t\t\t<textarea title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" {{getPermissions code}} data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\"></textarea>\\n\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t{{#unless is_textarea}}\\n\t\t\t\t\t\t\t<input type=\\\"text\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" {{getPermissions code}} data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t{{/unless}}\\n\t\t\t\t\t</div>\\n\t\t\t\t{{else}}\\n\t\t\t\t\t{{#if equals type 'number'}}\\n\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t<input type=\\\"number\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t{{#if equals type 'date'}}\\n\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t<input type=\\\"text\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-type=\\\"date\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t{{#if equals type 'dateTime'}}\\n\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t<input type=\\\"text\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-type='datetime' data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t{{#if equals type 'password'}}\\n\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t<input type=\\\"password\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t{{#if equals type 'select'}}\\n\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t<select name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<option value=\\\"{{value}}\\\">{{label}}</option>\\n\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n\t\t\t\t\t\t\t\t\t\t\t</select>\\n\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t{{#if equals type 'radio'}}\\n\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"af-radio-group\\\" data-schema-key=\\\"{{getLabel code}}\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n        \t\t\t\t\t\t\t\t\t\t\t\t<label class=\\\"radio-inline fix-indent\\\"><input type=\\\"radio\\\" value=\\\"{{value}}\\\" name=\\\"{{../code}}\\\" class=\\\"radio-inline fix-indent\\\"> {{label}}</label>\\n    \t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n    \t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'multiSelect'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"af-checkbox-group\\\" data-schema-key=\\\"{{getLabel code}}\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label class=\\\"checkbox-inline fix-indent\\\"><input type=\\\"checkbox\\\" value=\\\"{{value}}\\\" name=\\\"{{../code}}\\\" class=\\\"checkbox-inline fix-indent\\\"> {{label}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'url'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\\\"url\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'email'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<input type=\\\"email\\\" title=\\\"{{getLabel code}}\\\" name=\\\"{{code}}\\\" data-schema-key=\\\"{{getLabel code}}\\\" class=\\\"form-control\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'checkbox'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"checkbox\\\" data-schema-key=\\\"{{getLabel code}}\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label style=\\\"width: 100%;\\\"><input type=\\\"checkbox\\\" value=\\\"true\\\" name=\\\"{{code}}\\\" class=\\\"checkbox-inline fix-indent\\\"></label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<label for=\\\"7ZQnDsXBGohZMetA5\\\" class=\\\"control-label\\\">{{getLabel code}}</label>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t<div class='{{getCfClass this}} form-control' readonly disabled>{{{getValue code}}}</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t{{/if}}\\n\t\t\t\t{{/if}}\\n\t\t\t{{/if}}\\n\t\t{{/if}}\\n\t{{/with}}\";\n\nInstanceReadOnlyTemplate.create = function(tempalteName, steedosData) {\n  var template, templateCompiled, templateRenderFunction;\n  template = InstanceReadOnlyTemplate[tempalteName];\n  templateCompiled = SpacebarsCompiler.compile(template, {\n    isBody: true\n  });\n  templateRenderFunction = eval(templateCompiled);\n  Template[tempalteName] = new Blaze.Template(tempalteName, templateRenderFunction);\n  Template[tempalteName].steedosData = steedosData;\n  return Template[tempalteName].helpers(InstanceformTemplate.helpers);\n};\n\nInstanceReadOnlyTemplate.createInstanceSignText = function(steedosData) {\n  var instanceSignTextCompiled, instanceSignTextHtml, instanceSignTextRenderFunction;\n  instanceSignTextHtml = _getViewHtml('client/views/instance/instance_sign_text.html');\n  instanceSignTextCompiled = SpacebarsCompiler.compile(instanceSignTextHtml, {\n    isBody: true\n  });\n  instanceSignTextRenderFunction = eval(instanceSignTextCompiled);\n  Template.instanceSignText = new Blaze.Template(\"instanceSignText\", instanceSignTextRenderFunction);\n  Template.instanceSignText.steedosData = steedosData;\n  return Template.instanceSignText.helpers(InstanceSignText.helpers);\n};\n\nInstanceReadOnlyTemplate.createImageSign = function(steedosData) {\n  var imageSignCompiled, imageSignHtml, imageSignRenderFunction;\n  imageSignHtml = _getViewHtml('client/views/instance/image_sign.html');\n  imageSignCompiled = SpacebarsCompiler.compile(imageSignHtml, {\n    isBody: true\n  });\n  imageSignRenderFunction = eval(imageSignCompiled);\n  Template.imageSign = new Blaze.Template(\"imageSign\", imageSignRenderFunction);\n  Template.imageSign.steedosData = steedosData;\n  return Template.imageSign.helpers(ImageSign.helpers);\n};\n\nInstanceReadOnlyTemplate.createTracesHanlder = function(steedosData) {\n  var tracesHanlderCompiled, tracesHanlderHtml, tracesHanlderRenderFunction;\n  tracesHanlderHtml = _getViewHtml('client/views/instance/traces_handler.html');\n  tracesHanlderCompiled = SpacebarsCompiler.compile(tracesHanlderHtml, {\n    isBody: true\n  });\n  tracesHanlderRenderFunction = eval(tracesHanlderCompiled);\n  Template.instance_traces_handler = new Blaze.Template(\"instance_traces_handler\", tracesHanlderRenderFunction);\n  Template.instance_traces_handler.steedosData = steedosData;\n  return Template.instance_traces_handler.helpers(TracesHandler.helpers);\n};\n\nInstanceReadOnlyTemplate.init = function(steedosData) {\n  InstanceReadOnlyTemplate.create(\"afSelectUserRead\", steedosData);\n  if (Meteor.isServer) {\n    InstanceReadOnlyTemplate.create(\"afFormGroup\", steedosData);\n  }\n  InstanceReadOnlyTemplate.create(\"afFormGroupRead\", steedosData);\n  if (Meteor.isServer) {\n    InstanceReadOnlyTemplate.create(\"instance_attachment\", {\n      absolute: steedosData.absolute\n    });\n    InstanceReadOnlyTemplate.createImageSign(steedosData);\n    InstanceReadOnlyTemplate.createTracesHanlder(steedosData);\n    return InstanceReadOnlyTemplate.createInstanceSignText(steedosData);\n  }\n};\n\ngetLinkText = function(item, label, detail_url) {\n  if (detail_url) {\n    detail_url = detail_url.replace(\"{_id}\", item._id);\n    if (!/^http(s?):\\/\\//.test(detail_url)) {\n      detail_url = Steedos.absoluteUrl(detail_url);\n    }\n    return '<a href=\"' + detail_url + '\" target=\"_blank\">' + label + '</a>';\n  } else {\n    return label;\n  }\n};\n\nInstanceReadOnlyTemplate.getValue = function(value, field, locale, utcOffset) {\n  var date, detail_url, e, fieldOptions, hours, month, nameField, records, res, seconds, selectedOption, selectedOptions, splitedValues, t, t0, t1, uiSchema, year;\n  if (!value && value !== false) {\n    return '';\n  }\n  if ([\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1) {\n    fieldOptions = field.options.split(\"\\n\").map(function(n) {\n      var itemSplits;\n      itemSplits = n.split(\":\");\n      return {\n        label: itemSplits[0],\n        value: itemSplits[1] || n\n      };\n    });\n  }\n  switch (field.type) {\n    case 'email':\n      value = value ? '<a href=\\'mailto:' + value + '\\'>' + value + '</a>' : '';\n      break;\n    case 'url':\n      if (value) {\n        if (value.indexOf(\"http\") === 0) {\n          try {\n            value = \"<a href='\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n          } catch (error) {\n            e = error;\n            value = \"<a href='' target='_blank'>\" + value + \"</a>\";\n          }\n        } else {\n          value = \"<a href='http://\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n        }\n      } else {\n        value = '';\n      }\n      break;\n    case 'group':\n      if (field.is_multiselect) {\n        value = value != null ? value.getProperty(\"fullname\").toString() : void 0;\n      } else {\n        value = value != null ? value.fullname : void 0;\n      }\n      break;\n    case 'user':\n      if (field.is_multiselect) {\n        value = value != null ? value.getProperty(\"name\").toString() : void 0;\n      } else {\n        value = value != null ? value.name : void 0;\n      }\n      break;\n    case 'password':\n      value = '******';\n      break;\n    case 'checkbox':\n      if (value && value !== 'false') {\n        value = TAPi18n.__(\"form_field_checkbox_yes\", {}, locale);\n      } else {\n        value = TAPi18n.__(\"form_field_checkbox_no\", {}, locale);\n      }\n      break;\n    case 'dateTime':\n      if (value && value.length === 16) {\n        t = value.split(\"T\");\n        t0 = t[0].split(\"-\");\n        t1 = t[1].split(\":\");\n        year = t0[0];\n        month = t0[1];\n        date = t0[2];\n        hours = t1[0];\n        seconds = t1[1];\n        value = new Date(year, month - 1, date, hours, seconds);\n      } else {\n        value = new Date(value);\n      }\n      value = InstanceReadOnlyTemplate.formatDate(value, utcOffset);\n      break;\n    case 'time':\n      if (value && value.length === 16) {\n        t = value.split(\"T\");\n        t0 = t[0].split(\"-\");\n        t1 = t[1].split(\":\");\n        year = t0[0];\n        month = t0[1];\n        date = t0[2];\n        hours = t1[0];\n        seconds = t1[1];\n        value = new Date(year, month - 1, date, hours, seconds);\n      } else {\n        value = new Date(value);\n      }\n      value = InstanceReadOnlyTemplate.formatTime(value);\n      break;\n    case 'input':\n      if (field.is_textarea) {\n        value = value;\n      }\n      break;\n    case 'select':\n      selectedOption = fieldOptions.find(function(item) {\n        return item.value === value;\n      });\n      if (selectedOption) {\n        value = selectedOption.label;\n      }\n      break;\n    case 'radio':\n      selectedOption = fieldOptions.find(function(item) {\n        return item.value === value;\n      });\n      if (selectedOption) {\n        value = selectedOption.label;\n      }\n      break;\n    case 'multiSelect':\n      splitedValues = value.split(\",\");\n      selectedOptions = fieldOptions.filter(function(item) {\n        return splitedValues.indexOf(item.value) > -1;\n      });\n      if (selectedOptions.length) {\n        value = selectedOptions.map(function(item) {\n          return item.label;\n        }).join(\",\");\n      }\n      break;\n    case 'number':\n      if (value || value === 0) {\n        if (field.is_percent) {\n          value = Steedos.numberToPercentString(value, field.digits);\n        } else {\n          value = Steedos.numberToString(value, field.digits);\n        }\n      }\n      break;\n    case 'odata':\n      detail_url = field.detail_url;\n      if (field.is_multiselect) {\n        value = _.map(value, function(item) {\n          return getLinkText(item, item['@label'], detail_url);\n        });\n      } else {\n        value = getLinkText(value, value['@label'], detail_url);\n      }\n      break;\n    case 'image':\n      if (field.is_multiselect) {\n        value = _.map(value, function(item) {\n          return '<div class=\"antd-ImageControl-item is-uploaded\"> <div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\"> <div class=\"antd-Image-thumbWrap\"> <div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\" src=\"/api/files/images/' + item + '\"></div> </div> </div> </div>';\n        });\n        value = value.join(\"\");\n      } else {\n        value = '<div class=\"antd-ImageControl-item is-uploaded\"> <div class=\"antd-Image antd-Image--thumb antd-ImageControl-image\"> <div class=\"antd-Image-thumbWrap\"> <div class=\"antd-Image-thumb\"><img class=\"antd-Image-image\" src=\"/api/files/images/' + value + '\"></div> </div> </div> </div>';\n      }\n      break;\n    case 'file':\n      if (value) {\n        if (!field.is_multiselect) {\n          value = [value];\n        }\n        if (Meteor.isClient) {\n          res = Steedos.authRequest('/api/v1/cfs_files_filerecord?filters=[[\"_id\",\"in\", ' + JSON.stringify(value) + ']]&fields=[\"_id\",\"original\"]', {\n            async: false\n          });\n          records = res.data.items;\n        } else if (Meteor.isServer) {\n          records = Steedos.objectFind(\"cfs_files_filerecord\", {\n            filters: [[\"_id\", 'in', value]],\n            fields: [\"_id\", \"original\"]\n          });\n        }\n        value = _.map(records, function(item) {\n          var fileName, filePreviewHtml, fileUrl;\n          fileName = item.original.name;\n          fileUrl = Steedos.absoluteUrl('/api/files/files/' + item._id);\n          filePreviewHtml = '';\n          if ([\".pdf\", \".jpg\", \".jpeg\", \".png\", \".gif\"].indexOf(fileName.toLowerCase().slice(-4)) > -1) {\n            filePreviewHtml = \"&ensp;<a href='\" + fileUrl + \"' target='_blank' class='antd-Link'><span class='antd-TplField'><span>预览</span></span></a>\";\n          }\n          return \"<div><a href='\" + (fileUrl + '?download=true') + \"' target='_blank'>\" + fileName + \"</a> \" + (filePreviewHtml != null ? filePreviewHtml : {\n            filePreviewHtml: ''\n          }) + \"</div>\";\n        });\n        value = value.join(\"\");\n      }\n      break;\n    case 'lookup':\n      if (value) {\n        if (!field.is_multiselect) {\n          value = [value];\n        }\n        if (Meteor.isClient) {\n          uiSchema = Creator.getObject(field.reference_to);\n          nameField = (uiSchema != null ? uiSchema.NAME_FIELD_KEY : void 0) || 'name';\n          res = Steedos.authRequest('/api/v1/' + field.reference_to + '?filters=[[\"' + (field.reference_to_field || '_id') + '\",\"in\", ' + JSON.stringify(value) + ']]&fields=[\"_id\",\"' + nameField + '\"]', {\n            async: false\n          });\n          records = res.data.items;\n        } else if (Meteor.isServer) {\n          nameField = Steedos.getObjectNameFieldKey(field.reference_to);\n          records = Steedos.objectFind(field.reference_to, {\n            filters: [[field.reference_to_field || '_id', 'in', value]],\n            fields: [\"_id\", nameField]\n          });\n        }\n        value = _.map(records, function(item) {\n          return \"<a href='\" + (Steedos.absoluteUrl('/app/-/' + field.reference_to + '/view/' + item._id)) + \"' target='_blank'>\" + item[nameField] + \"</a>\";\n        });\n        value = value.join(\" , \");\n      }\n      break;\n    case 'html':\n      value = value ? \"<div class=\\\"steedos-html\\\">\" + value + \"</div>\" : '';\n  }\n  return value;\n};\n\nInstanceReadOnlyTemplate.getLabel = function(fields, code) {\n  var field;\n  field = fields.findPropertyByPK(\"code\", code);\n  if (field) {\n    if (field.name) {\n      return field.name;\n    } else {\n      return field.code;\n    }\n  }\n};\n\nInstanceReadOnlyTemplate.getInstanceFormVersion = function(instance) {\n  var form, form_fields, form_version;\n  form = db.forms.findOne(instance.form);\n  form_version = {};\n  form_fields = [];\n  if (form.current._id === instance.form_version) {\n    form_version = form.current;\n  } else {\n    form_version = _.where(form.historys, {\n      _id: instance.form_version\n    })[0];\n  }\n  form_version.fields.forEach(function(field) {\n    if (field.type === 'section') {\n      form_fields.push(field);\n      if (field.fields) {\n        return field.fields.forEach(function(f) {\n          return form_fields.push(f);\n        });\n      }\n    } else if (field.type === 'table') {\n      field['sfields'] = field['fields'];\n      delete field['fields'];\n      return form_fields.push(field);\n    } else {\n      return form_fields.push(field);\n    }\n  });\n  form_version.fields = form_fields;\n  return form_version;\n};\n\nInstanceReadOnlyTemplate.getFlowVersion = function(instance) {\n  var flow, flow_version;\n  flow = db.flows.findOne(instance.flow);\n  flow_version = {};\n  if (flow.current._id === instance.flow_version) {\n    flow_version = flow.current;\n  } else {\n    flow_version = _.where(flow.historys, {\n      _id: instance.flow_version\n    })[0];\n  }\n  return flow_version;\n};\n\n_getViewHtml = function(path) {\n  var viewHtml;\n  viewHtml = Assets.getText(path);\n  if (viewHtml) {\n    viewHtml = viewHtml.replace(/<template[\\w\\s\\\"\\=']+>/i, \"\").replace(/<\\/template>/i, \"\");\n  }\n  return viewHtml;\n};\n\n_getLocale = function(user) {\n  var locale, ref, ref1;\n  if ((user != null ? (ref = user.locale) != null ? ref.toLocaleLowerCase() : void 0 : void 0) === 'zh-cn') {\n    locale = \"zh-CN\";\n  } else if ((user != null ? (ref1 = user.locale) != null ? ref1.toLocaleLowerCase() : void 0 : void 0) === 'en-us') {\n    locale = \"en\";\n  } else {\n    locale = \"zh-CN\";\n  }\n  return locale;\n};\n\n_getRequiredFields = function(fields, rev) {\n  if (!rev) {\n    rev = [];\n  }\n  fields.forEach(function(field) {\n    if (field.type === 'section') {\n      return _getRequiredFields(field.fields, rev);\n    } else if (field.type === 'table') {\n\n    } else {\n      if (field.is_required) {\n        return rev.push(field.code);\n      }\n    }\n  });\n  return rev;\n};\n\n_getStartStepEditableFields = function(fields, steps) {\n  var editableCode, startStep;\n  startStep = steps.findPropertyByPK(\"step_type\", \"start\");\n  editableCode = [];\n  _.keys(startStep.permissions).forEach(function(key) {\n    if (startStep.permissions[key] === 'editable') {\n      return editableCode.push(key);\n    }\n  });\n  return editableCode;\n};\n\n_getStartStepRequiredFields = function(fields, steps) {\n  var editableCode, requiredFields;\n  requiredFields = _getRequiredFields(fields);\n  editableCode = _getStartStepEditableFields(fields, steps);\n  return _.intersection(requiredFields, editableCode);\n};\n\n_getTemplateData = function(user, space, instance, options) {\n  var flow, form, form_version, locale, steedosData;\n  if (Meteor.isServer) {\n    form_version = InstanceReadOnlyTemplate.getInstanceFormVersion(instance);\n  } else {\n    form_version = WorkflowManager.getInstanceFormVersion(instance);\n  }\n  locale = _getLocale(user);\n  steedosData = {};\n  if (Meteor.isClient) {\n    steedosData = _.clone(WorkflowManager_format.getAutoformSchemaValues());\n    steedosData.insname = instance.name;\n    steedosData.ins_state = instance.state;\n    steedosData.ins_final_decision = instance.ins_final_decision;\n    steedosData.ins_code = instance.code;\n    steedosData.ins_is_archived = instance.is_archived;\n    steedosData.ins_is_deleted = instance.ins_is_deleted;\n    steedosData.applicant_name = instance.applicant_name;\n    steedosData.applicantContext = instance.applicant_name;\n  }\n  steedosData.instance = instance;\n  steedosData.form_version = form_version;\n  steedosData.locale = locale;\n  steedosData.utcOffset = user.utcOffset;\n  steedosData.space = instance.space;\n  steedosData.sessionUserId = user._id;\n  if (Meteor.isServer) {\n    if (options != null ? options.editable : void 0) {\n      form = db.forms.findOne({\n        _id: instance.form\n      });\n      flow = db.flows.findOne({\n        _id: instance.flow\n      });\n      steedosData.startStepEditableFields = _getStartStepEditableFields(form.current.fields, flow.current.steps);\n    }\n  }\n  return steedosData;\n};\n\nInstanceReadOnlyTemplate.formatDate = function(date, utcOffset) {\n  var passing;\n  if (Meteor.isServer) {\n    passing = false;\n  } else {\n    passing = true;\n  }\n  if (!utcOffset && utcOffset !== 0) {\n    utcOffset = 8;\n  }\n  return moment(date).utcOffset(utcOffset, passing).format(\"YYYY-MM-DD HH:mm\");\n};\n\nInstanceReadOnlyTemplate.formatTime = function(date) {\n  var utcOffset;\n  utcOffset = 0;\n  return moment(date).utcOffset(utcOffset).format(\"HH:mm\");\n};\n\nInstanceReadOnlyTemplate.getInstanceView = function(user, space, instance, options) {\n  var body, instanceCompiled, instanceRenderFunction, instanceTemplate, steedosData;\n  steedosData = _getTemplateData(user, space, instance, options);\n  steedosData.absolute = false;\n  if (options != null ? options.absolute : void 0) {\n    steedosData.absolute = true;\n  }\n  instanceTemplate = TemplateManager.getTemplate(instance, options != null ? options.templateName : void 0);\n  instanceTemplate = instanceTemplate.replace(/afSelectUser/g, \"afSelectUserRead\");\n  if (!(options != null ? options.editable : void 0)) {\n    instanceTemplate = instanceTemplate.replace(/afFormGroup/g, \"afFormGroupRead\");\n  }\n  instanceCompiled = SpacebarsCompiler.compile(instanceTemplate, {\n    isBody: true\n  });\n  instanceRenderFunction = eval(instanceCompiled);\n  Template.instance_readonly_view = new Blaze.Template(\"instance_readonly_view\", instanceRenderFunction);\n  Template.instance_readonly_view.steedosData = steedosData;\n  Template.instance_readonly_view.helpers(InstanceformTemplate.helpers);\n  InstanceReadOnlyTemplate.init(steedosData);\n  body = Blaze.toHTMLWithData(Template.instance_readonly_view, steedosData);\n  return \"<div id='instanceform' >\\n\t\" + body + \"\\n</div>\";\n};\n\nInstanceReadOnlyTemplate.getTracesView = function(user, space, instance, options) {\n  var body, form, steedosData, traceCompiled, traceRenderFunction, tracesHtml;\n  steedosData = _getTemplateData(user, space, instance);\n  form = db.forms.findOne(instance.form);\n  if (form.instance_style === \"table\" || (options != null ? options.templateName : void 0) === \"table\") {\n    tracesHtml = _getViewHtml('client/views/instance/traces_table.html');\n  } else {\n    tracesHtml = _getViewHtml('client/views/instance/traces.html');\n  }\n  traceCompiled = SpacebarsCompiler.compile(tracesHtml, {\n    isBody: true\n  });\n  traceRenderFunction = eval(traceCompiled);\n  Template.trace_readonly_view = new Blaze.Template(\"trace_readonly_view\", traceRenderFunction);\n  Template.trace_readonly_view.steedosData = steedosData;\n  Template.trace_readonly_view.helpers(TracesTemplate.helpers);\n  body = Blaze.toHTMLWithData(Template.trace_readonly_view, instance.traces);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getAttachmentView = function(user, space, instance) {\n  var attachmentCompiled, attachmentHtml, attachmentRenderFunction, body, steedosData;\n  steedosData = _getTemplateData(user, space, instance);\n  attachmentHtml = _getViewHtml('client/views/instance/instance_attachments.html');\n  attachmentCompiled = SpacebarsCompiler.compile(attachmentHtml, {\n    isBody: true\n  });\n  attachmentRenderFunction = eval(attachmentCompiled);\n  Template.attachments_readonly_view = new Blaze.Template(\"attachments_readonly_view\", attachmentRenderFunction);\n  Template.attachments_readonly_view.steedosData = steedosData;\n  Template.attachments_readonly_view.helpers(InstanceAttachmentTemplate.helpers);\n  body = Blaze.toHTMLWithData(Template.attachments_readonly_view);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getRelatedInstancesView = function(user, space, instance, options) {\n  var body, relatedInstancesCompiled, relatedInstancesHtml, relatedInstancesRenderFunction, steedosData;\n  steedosData = _getTemplateData(user, space, instance);\n  steedosData.absolute = false;\n  if (options != null ? options.absolute : void 0) {\n    steedosData.absolute = true;\n  }\n  relatedInstancesHtml = _getViewHtml('client/views/instance/related_instances.html');\n  relatedInstancesCompiled = SpacebarsCompiler.compile(relatedInstancesHtml, {\n    isBody: true\n  });\n  relatedInstancesRenderFunction = eval(relatedInstancesCompiled);\n  Template.related_instances_view = new Blaze.Template(\"related_instances_view\", relatedInstancesRenderFunction);\n  Template.related_instances_view.steedosData = steedosData;\n  Template.related_instances_view.helpers(RelatedInstances.helpers);\n  body = Blaze.toHTMLWithData(Template.related_instances_view, steedosData);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getRelatedRecordsView = function(user, space, instance, options) {\n  var body, relatedRecordsCompiled, relatedRecordsHtml, relatedRecordsRenderFunction, steedosData;\n  steedosData = _getTemplateData(user, space, instance);\n  steedosData.absolute = false;\n  if (options != null ? options.absolute : void 0) {\n    steedosData.absolute = true;\n  }\n  relatedRecordsHtml = _getViewHtml('client/views/instance/related_records.html');\n  relatedRecordsCompiled = SpacebarsCompiler.compile(relatedRecordsHtml, {\n    isBody: true\n  });\n  relatedRecordsRenderFunction = eval(relatedRecordsCompiled);\n  Template.related_records_view = new Blaze.Template(\"related_records_view\", relatedRecordsRenderFunction);\n  Template.related_records_view.steedosData = steedosData;\n  Template.related_records_view.helpers(RelatedRecords.helpers);\n  body = Blaze.toHTMLWithData(Template.related_records_view, steedosData);\n  return body;\n};\n\nInstanceReadOnlyTemplate.getOnLoadScript = function(instance) {\n  var form_script, form_version;\n  form_version = WorkflowManager.getFormVersion(instance.form, instance.form_version);\n  form_script = form_version.form_script;\n  if (form_script && form_script.replace(/\\n/g, \"\").replace(/\\s/g, \"\").length > 0) {\n    form_script = \"CoreForm = {};CoreForm.instanceform = {};\" + form_script;\n    return form_script += \";if(CoreForm.form_OnLoad){window.onload = CoreForm.form_OnLoad();}\";\n  } else {\n    return form_script = \"\";\n  }\n};\n\nInstanceReadOnlyTemplate.getInstanceHtml = function(user, space, instance, options) {\n  var allCssLink, attachment, body, creatorService, cssHref, form, formDescription, formDescriptionHtml, html, ins_record_ids, instanceBoxStyle, instance_style, jqHref, locale, onLoadScript, openFileScript, ref, ref1, related_instances, related_records, showTracesBtn, showTracesScript, trace, traceCheck, width;\n  body = InstanceReadOnlyTemplate.getInstanceView(user, space, instance, options);\n  onLoadScript = InstanceReadOnlyTemplate.getOnLoadScript(instance);\n  creatorService = (ref = Meteor.settings[\"public\"].webservices) != null ? (ref1 = ref.creator) != null ? ref1.url : void 0 : void 0;\n  ins_record_ids = instance.record_ids;\n  locale = _getLocale(user);\n  openFileScript = \"if(window.isNode && isNode()){\\n\tattachs = document.getElementsByClassName(\\\"ins_attach_href\\\");\\n\tfor(var i = 0; i < attachs.length; i++){\\n\t\tattach = attachs[i];\\n\t\tattach.addEventListener(\\\"click\\\", function(e){\\n\t\t\tif(isImage(this.dataset.type) || isHtml(this.dataset.type)){\\n\t\t\t\te.preventDefault();\\n\t\t\t\topenWindow(\\\"/api/files/instances/\\\" + this.dataset.id);\\n\t\t\t}else if(nw_core.canOpenFile(this.dataset.name)){\\n\t\t\t\te.preventDefault();\\n\t\t\t\tnw_core.openFile(this.href, this.dataset.name)\\n\t\t\t}\\n\t\t});\\n\t}\\n}\\n\\nvar flow = \\\"\" + instance.flow + \"\\\";\\nvar space = \\\"\" + instance.space + \"\\\";\\n\\nfunction getCookie(name){\\n\tlet pattern = RegExp(name + \\\"=.[^;]*\\\")\\n\tlet matched = document.cookie.match(pattern)\\n\tif(matched){\\n\t\tlet cookie = matched[0].split('=')\\n\t\treturn cookie[1]\\n\t}\\n\treturn ''\\n}\\n\\nvar records = document.getElementsByClassName(\\\"ins-related-records\\\");\\nfor(var i = 0; i < records.length; i++){\\n\t\tvar record = records[i];\\n\t\trecord.addEventListener(\\\"click\\\", function(e){\\n\t\t\tvar creatorService = \\\"\" + creatorService + \"\\\"\\n\t\t\tvar ins_record_ids = \" + (JSON.stringify(ins_record_ids)) + \"\\n\t\t\tif(creatorService && ins_record_ids && ins_record_ids.length > 0){\\n\t\t\t\tvar objcetName = ins_record_ids[0].o\\n\t\t\t\tvar id = ins_record_ids[0].ids[0]\\n\t\t\t\tvar uobj = {};\\n\t\t\t\tuobj[\\\"X-User-Id\\\"] = getCookie(\\\"X-User-Id\\\");\\n\t\t\t\tuobj[\\\"X-Auth-Token\\\"] = getCookie(\\\"X-Auth-Token\\\");\\n\t\t\t\tredirectUrl = creatorService + \\\"app/-/\\\" + objcetName + \\\"/view/\\\" + id + \\\"?\\\" + $.param(uobj);\\n\t\t\t\topenWindow(redirectUrl);\\n\t\t\t}\\n\t\t});\\n\t}\\n\";\n  if (!Steedos.isMobile()) {\n    form = db.forms.findOne(instance.form);\n    if ((form != null ? form.instance_style : void 0) === 'table') {\n      instance_style = \"instance-table\";\n    }\n  }\n  if ((options != null ? options.templateName : void 0) === 'table') {\n    instance_style = \"instance-table\";\n  }\n  if (options != null ? options.instance_style : void 0) {\n    instance_style = options.instance_style;\n  }\n  if (!options || options.showTrace === true) {\n    trace = InstanceReadOnlyTemplate.getTracesView(user, space, instance);\n  } else {\n    trace = \"\";\n  }\n  instanceBoxStyle = \"\";\n  if (instance && instance.final_decision) {\n    if (instance.final_decision === \"approved\") {\n      instanceBoxStyle = \"box-success\";\n    } else if (instance.final_decision === \"rejected\") {\n      instanceBoxStyle = \"box-danger\";\n    }\n  }\n  if (!options || options.showAttachments === true) {\n    attachment = InstanceReadOnlyTemplate.getAttachmentView(user, space, instance);\n    related_instances = InstanceReadOnlyTemplate.getRelatedInstancesView(user, space, instance, options);\n    related_records = InstanceReadOnlyTemplate.getRelatedRecordsView(user, space, instance, options);\n  } else {\n    attachment = \"\";\n    related_instances = \"\";\n    related_records = \"\";\n  }\n  width = \"960px\";\n  if (options != null ? options.width : void 0) {\n    width = \"\";\n  }\n  cssHref = Meteor.absoluteUrl(\"steedos-css\");\n  jqHref = Meteor.absoluteUrl(\"website/libs/jquery.min.js\");\n  allCssLink = \"<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" class=\\\"__meteor-css__\\\" href=\\\"\" + cssHref + \"\\\">\";\n  traceCheck = \"\";\n  if (!_.isEmpty(trace)) {\n    traceCheck = \"checked\";\n  }\n  if ((options != null ? options.tagger : void 0) === 'email' || (options != null ? options.editable : void 0)) {\n    showTracesBtn = \"\";\n  } else {\n    showTracesBtn = \"<div class=\\\"navigation-bar btn-group no-print\\\" style=\\\"min-width: 600px; z-index: 999; box-sizing: border-box;\\\">\\n\t<div class=\\\"print-tool\\\">\\n\t\t<label class=\\\"cbx-label\\\"><input type=\\\"checkbox\\\" class=\\\"cbx-print cbx-print-attachments\\\" id=\\\"cbx-print-attachments\\\" checked=\\\"checked\\\"><span>\" + (TAPi18n.__('instance_attachment', {}, locale)) + \"</span></label>\\n\t\t<label class=\\\"cbx-label\\\"><input type=\\\"checkbox\\\" class=\\\"cbx-print cbx-print-traces\\\" id=\\\"cbx-print-traces\\\" checked=\\\"\" + traceCheck + \"\\\"><span>\" + (TAPi18n.__('instance_approval_history', {}, locale)) + \"</span></label>\\n\t</div>\\n</div>\";\n  }\n  showTracesScript = \"$( document ).ready(function(){\\n\tvar b = document.getElementById('cbx-print-traces');\\n\tvar t = document.getElementsByClassName('instance-traces')[0];\\n\tif (b && b.checked && t){\\n\t\tt.style = 'display: block;'\\n\t} else if(t){\\n\t\tt.style = 'display: none;'\\n\t}\\n\tif(b){\\n\t\tb.addEventListener('change', function(e){\\n\t\t\tif (e.target.checked){\\n\t\t\t\tt.style = 'display: block;'\\n\t\t\t} else {\\n\t\t\t\tt.style = 'display: none;'\\n\t\t\t}\\n\t\t});\\n\t}\\n\\n\\n\tvar attachmentsCheckbox = document.getElementById('cbx-print-attachments');\\n\tvar attachmentsView = document.getElementsByClassName('attachments-section')[0];\\n\tif (attachmentsCheckbox && attachmentsCheckbox.checked && attachmentsView){\\n\t\tattachmentsView.style = 'display: block;'\\n\t} else if(attachmentsView){\\n\t\tattachmentsView.style = 'display: none;'\\n\t}\\n\tif(attachmentsCheckbox){\\n\t\tattachmentsCheckbox.addEventListener('change', function(e){\\n\t\t\tif (e.target.checked){\\n\t\t\t\tattachmentsView.style = 'display: block;'\\n\t\t\t} else {\\n\t\t\t\tattachmentsView.style = 'display: none;'\\n\t\t\t}\\n\t\t});\\n\t}\\n});\\n\";\n  if (options != null ? options.styles : void 0) {\n    allCssLink = \"\";\n  }\n  form = db.forms.findOne({\n    _id: instance.form\n  });\n  formDescriptionHtml = \"\";\n  if (form) {\n    formDescription = form.description;\n    if (formDescription) {\n      formDescription = formDescription.replace(/\\n/g, \"<br/>\");\n      formDescriptionHtml = \"<div class=\\\"box-header  with-border instance-header\\\">\\n\t<div>\\n\t\t\" + formDescription + \"\\n\t</div>\\n</div>\";\n    }\n  }\n  html = \"<!DOCTYPE html>\\n<html>\\n\t<head>\\n\t\t<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html; charset=UTF-8\\\"/>\\n\t\t\" + allCssLink + \"\\n\t\t<script src=\\\"\" + jqHref + \"\\\" type=\\\"text/javascript\\\"></script>\\n\t\t<script src=\\\"/js/nw_core.js\\\" type=\\\"text/javascript\\\"></script>\\n\t\t\" + (options.plugins || \"\") + \"\\n\\n\t\t<style>\\n\t\t\t.steedos{\\n\t\t\t\twidth: \" + width + \";\\n\t\t\t\tmargin-left: auto;\\n\t\t\t\tmargin-right: auto;\\n\t\t\t}\\n\\n\t\t\t.instance-view .instance-name{\\n\t\t\t\tdisplay: inline !important\\n\t\t\t}\\n\t\t\t.box-tools{\\n\t\t\t\tdisplay: none;\\n\t\t\t}\\n\t\t\t.box.collapsed-box .box-body,.box.collapsed-box .box-footer {\\n\t\t\t  display: block;\\n\t\t\t}\\n\\n\t\t\tbody{\\n\t\t\t\tbackground: azure !important;\\n\t\t\t}\\n\\n\t\t\t.instance-view .instance-traces{\\n\t\t\t\tpadding-left: 15px;\\n\t\t\t\tpadding-right: 15px;\\n\t\t\t}\\n\\n\t\t\t.antd-ImageControl-item {\\n\t\t\tborder-radius: var(--ImageControl-addBtn-borderRadius);\\n\t\t\tvertical-align: top;\\n\t\t\tpadding: var(--gap-xs);\\n\t\t\tdisplay: inline-block;\\n\t\t\tmargin-right: var(--gap-base);\\n\t\t\tmargin-bottom: var(--gap-base);\\n\t\t\tposition: relative;\\n\t\t\twidth: 7.5rem;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item.is-invalid {\\n\t\t\tpadding: 0;\\n\t\t\tborder-color: var(--FileControl-danger-color);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item svg.icon-refresh {\\n\t\t\ttransform: rotate(180deg);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-filename {\\n\t\t\tdisplay: inline-flex;\\n\t\t\tflex-direction: column;\\n\t\t\tjustify-content: center;\\n\t\t\talign-items: center;\\n\t\t\tcolor: var(--FileControl-danger-color);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-filename > svg.icon-image {\\n\t\t\tmargin-bottom: 8px;\\n\t\t\twidth: 24px;\\n\t\t\theight: 24px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-filename > span {\\n\t\t\tmax-width: 100%;\\n\t\t\toverflow: hidden;\\n\t\t\twhite-space: nowrap;\\n\t\t\ttext-overflow: ellipsis;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-image {\\n\t\t\twidth: 100%;\\n\t\t\theight: 100%;\\n\t\t\tpadding: 0;\\n\t\t\tborder: none;\\n\t\t\tdisplay: block;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemClear {\\n\t\t\tposition: absolute;\\n\t\t\tcursor: pointer;\\n\t\t\tcolor: #999;\\n\t\t\ttop: 5px;\\n\t\t\tright: 5px;\\n\t\t\tline-height: 1;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemClear > svg {\\n\t\t\ttop: 0;\\n\t\t\twidth: 10px;\\n\t\t\theight: 10px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemInfo {\\n\t\t\tdisplay: inline-flex;\\n\t\t\twidth: 110px;\\n\t\t\theight: 110px;\\n\t\t\tjustify-content: center;\\n\t\t\talign-items: center;\\n\t\t\talign-content: center;\\n\t\t\tflex-wrap: wrap;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-itemInfo > p {\\n\t\t\twidth: 100%;\\n\t\t\ttext-align: center;\\n\t\t\tfont-size: 12px;\\n\t\t\tmargin-bottom: 5px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-progress {\\n\t\t\twidth: 70px;\\n\t\t\theight: 5px;\\n\t\t\tbackground: #ebebeb;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-progressValue {\\n\t\t\theight: 5px;\\n\t\t\tborder-radius: var(--ImageControl-progress-borderRadius);\\n\t\t\tdisplay: block;\\n\t\t\tbackground: var(--info);\\n\t\t\tmin-width: 10%;\\n\t\t\ttransition: ease-out width var(--animation-duration);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item.is-invalid .antd-ImageControl-itemClear {\\n\t\t\tdisplay: none;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-item.is-invalid:hover .antd-ImageControl-itemClear {\\n\t\t\tdisplay: block;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-errorMsg {\\n\t\t\tcolor: var(--danger);\\n\t\t\tmargin: 5px 0 0;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-uploadBtn {\\n\t\t\tmargin-top: 5px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-cropperWrapper {\\n\t\t\tposition: relative;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-cropperWrapper img {\\n\t\t\tmax-width: 100%;\\n\t\t\tmax-height: 400px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-croperToolbar {\\n\t\t\tdisplay: inline-flex;\\n\t\t\tposition: absolute;\\n\t\t\tright: 0;\\n\t\t\tbottom: 0;\\n\t\t\tflex-direction: column;\\n\t\t\talign-items: flex-end;\\n\t\t\tbackground: #fff;\\n\t\t\tborder-radius: 4px;\\n\t\t\tmargin: 0.5rem;\\n\t\t\tbox-shadow: 0 0 4px 0 rgba(0, 0, 0, 0.1);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-croperToolbar > a {\\n\t\t\tcolor: var(--Form-item-fontColor);\\n\t\t\tpadding: 2px 5px;\\n\t\t\tcursor: pointer;\\n\t\t\tfont-size: 18px;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-croperToolbar > a:hover {\\n\t\t\tcolor: var(--link-color);\\n\t\t\t}\\n\t\t\t.antd-ImageControl-acceptTip {\\n\t\t\theight: 120px;\\n\t\t\tcolor: #999;\\n\t\t\tborder: 2px dashed var(--borderColor);\\n\t\t\tborder-color: var(--info);\\n\t\t\tbackground: #f3f9fe;\\n\t\t\tborder-radius: var(--borderRadius);\\n\t\t\tline-height: 120px;\\n\t\t\ttext-align: center;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-fixed-size {\\n\t\t\twidth: 100%;\\n\t\t\theight: 100%;\\n\t\t\tpadding: 0;\\n\t\t\t}\\n\t\t\t.antd-ImageControl-fixed-size .antd-ImageControl-itemOverlay {\\n\t\t\twidth: 100%;\\n\t\t\theight: 100%;\\n\t\t\t}\\n\\n\t\t\t.antd-Images {\\n\t\t\t\tdisplay: flex;\\n\t\t\t\tflex-wrap: wrap;\\n\t\t\t\tmargin: calc(var(--gap-xs) * -1);\\n\t\t\t\t}\\n\t\t\t\t.antd-Images-item {\\n\t\t\t\tdisplay: flex;\\n\t\t\t\tmargin: var(--gap-xs);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image {\\n\t\t\t\tborder: var(--borderWidth) solid var(--borderColor);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image--thumb {\\n\t\t\t\tdisplay: inline-block;\\n\t\t\t\tpadding: var(--gap-xs);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumbWrap {\\n\t\t\t\tposition: relative;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-image {\\n\t\t\t\tdisplay: block;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-image--loading {\\n\t\t\t\tvisibility: hidden;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image--original .antd-Image-image {\\n\t\t\t\tmax-width: 100%;\\n\t\t\t\tmax-height: 100%;\\n\t\t\t\twidth: auto;\\n\t\t\t\tmargin: auto;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb {\\n\t\t\t\twidth: 6.875rem;\\n\t\t\t\theight: 6.875rem;\\n\t\t\t\tposition: relative;\\n\t\t\t\toverflow: hidden;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb > img {\\n\t\t\t\tposition: absolute;\\n\t\t\t\tleft: 50%;\\n\t\t\t\ttop: 50%;\\n\t\t\t\tmax-height: 100%;\\n\t\t\t\twidth: auto;\\n\t\t\t\ttransform: translate(-50%, -50%);\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-info {\\n\t\t\t\tpadding: 5px 10px;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image--thumb .antd-Image-info {\\n\t\t\t\twidth: 6.875rem;\\n\t\t\t\tpadding: 0;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--4-3 {\\n\t\t\t\theight: 5.15625rem;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--16-9 {\\n\t\t\t\theight: 3.8671875rem;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--fixed-size {\\n\t\t\t\tmin-width: 6.875rem;\\n\t\t\t\tmin-height: 6.875rem;\\n\t\t\t\twidth: 100%;\\n\t\t\t\tpadding: 0;\\n\t\t\t\theight: 100%;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb {\\n\t\t\t\twidth: 100%;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--fixed-size .antd-Image-thumb > img {\\n\t\t\t\twidth: auto;\\n\t\t\t\theight: 100%;\\n\t\t\t\t}\\n\t\t\t\t.antd-Image-thumb--w-full > img {\\n\t\t\t\twidth: 100%;\\n\t\t\t\theight: auto;\\n\t\t\t\t}\\n\\n\t\t\t\" + ((options != null ? options.styles : void 0) || \"\") + \"\\n\\n\t\t\t\" + ((options != null ? options.add_styles : void 0) || \"\") + \"\\n\t\t</style>\\n\t</head>\\n\t<body>\\n\t\t<div class=\\\"steedos workflow instance-print\\\">\\n\t\t\t<div class=\\\"skin-green skin-admin-lte\\\">\\n\t\t\t\t<div class=\\\"wrapper\\\">\\n\t\t\t\t\t<div class=\\\"content-wrapper\\\">\\n\t\t\t\t\t\t\" + showTracesBtn + \"\\n\t\t\t\t\t\t<div class=\\\"instance-print\\\">\\n\t\t\t\t\t\t\t<div class=\\\"instance \" + instance_style + \"\\\">\\n\t\t\t\t\t\t\t\t<form name=\\\"instanceForm\\\">\\n\t\t\t\t\t\t\t\t\t<div class=\\\"instance-form box \" + instanceBoxStyle + \"\\\">\\n\t\t\t\t\t\t\t\t\t\t\" + formDescriptionHtml + \"\\n\t\t\t\t\t\t\t\t\t\t<div class=\\\"box-body\\\">\\n\t\t\t\t\t\t\t\t\t\t\t<div class=\\\"col-md-12\\\" style=\\\"box-sizing: border-box;\\\">\\n\t\t\t\t\t\t\t\t\t\t\t\t<div class='attachments-section'>\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + attachment + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + related_instances + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + related_records + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t\t\t\" + body + \"\\n\t\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t\t</div>\\n\t\t\t\t\t\t\t\t</form>\\n\t\t\t\t\t\t\t\t\" + trace + \"\\n\t\t\t\t\t\t\t</div>\\n\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t</div>\\n\t\t</div>\\n\t</body>\\n\t<script>\" + openFileScript + \";\" + onLoadScript + \";\" + showTracesScript + \"</script>\\n</html>\";\n  return html;\n};\n","TemplateManager = {};\n\nformId = 'instanceform';\n\n\nTemplateManager.instance_title = ()->\n\tpageTitle = \"\"\"\n\t\t{{instance.name}}\n\t\"\"\"\n\n\tpageTitleTrClass = \"instance-name\"\n\n\tif CoreForm?.pageTitleFieldName\n\t\tpageTitle = \"\"\"\n\t\t\t\t{{> afFormGroup name=\"#{CoreForm.pageTitleFieldName}\" label=false}}\n\t\t\"\"\"\n\t\tpageTitleTrClass = \"\"\n\n\tif CoreForm?.pageTitle\n\t\tpageTitle = \"\"\"\n\t\t\t#{CoreForm.pageTitle}\n\t\t\"\"\"\n\t\tpageTitleTrClass = \"\"\n\n\tval =\n\t\tpageTitle: pageTitle\n\t\tpageTitleTrClass: pageTitleTrClass\n\n\treturn val\n\nTemplateManager.handleTableTemplate = (instance, _export) ->\n\n\ttemplate = \"\"\"\n\t<div class='instance-template'>\n\t\t<table class=\"table-page-title form-table no-border text-align-center\" style=\"width: 100%;display: inline-table;\">\n\t\t\t<tr class=\"#{this.instance_title().pageTitleTrClass}\">\n\t\t\t\t<td class=\"instance-table-name-td page-title\">\n\t\t\t\t\t#{this.instance_title().pageTitle}\n\t\t\t\t</td>\n\t\t\t</tr>\n\n\t\t</table>\n\t\t<table class=\"table-page-body form-table\">\n\t\t\t\t<tr style=\"height:0px\">\n\t\t\t\t\t<th style='width: 16%'></th>\n\t\t\t\t\t<th></th>\n\t\t\t\t\t<th style='width: 16%'></th>\n\t\t\t\t\t<th></th>\n\t\t\t\t</tr>\n\t\"\"\";\n\n\ttable_fields = InstanceformTemplate.helpers.table_fields(instance)\n\n\ttable_fields && table_fields.forEach (table_field)->\n\n\t\trequired = \"\"\n\t\tif !CoreForm?.pageTitleFieldName || CoreForm?.pageTitleFieldName != table_field.code\n\t\t\tif table_field.is_required\n\t\t\t\trequired = \"is-required\"\n\n\t\t\tif _export\n\t\t\t\trequired = \"\";\n\n\t\t\tpureCode = Steedos.removeSpecialCharacter(table_field.code);\n\n\t\t\tif InstanceformTemplate.helpers.isOpinionField(table_field)\n\t\t\t\ttemplate += table_field.tr_start\n\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t<td class=\"td-title #{required}\">\n\t\t\t\t\t\t{{afFieldLabelText name=\"#{table_field.code}\"}}\n\t\t\t\t\t</td>\n\t\t\t\t\t<td class=\"td-field opinion-field opinion-field-#{pureCode} automatic\" colspan = \"#{table_field.td_colspan}\">\n\t\t\t\t\t\t{{> instanceSignText name=\"#{table_field.code}\"}}\n\t\t\t\t\t</td>\n\t\t\t\t\"\"\"\n\t\t\t\ttemplate += table_field.tr_end\n\t\t\telse\n\t\t\t\tif InstanceformTemplate.helpers.includes(table_field.type, 'section,table')\n\t\t\t\t\ttemplate += table_field.tr_start\n\t\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\t<td class=\"td-childfield td-childfield-#{pureCode}\" colspan = \"#{table_field.td_colspan}\">\n\t\t\t\t\t\t   {{> afFormGroup name=\"#{table_field.code}\" label=false}}\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\"\"\"\n\t\t\t\t\ttemplate += table_field.tr_end\n\t\t\t\telse\n\t\t\t\t\ttemplate += table_field.tr_start\n\n\t\t\t\t\tif _export\n\t\t\t\t\t\ttitle_permission = \"\"\n\t\t\t\t\t\tfield_permission = \"\"\n\t\t\t\t\telse\n\t\t\t\t\t\ttitle_permission = \"title-\" + table_field.permission\n\t\t\t\t\t\tfield_permission = \"field-\" + table_field.permission\n\n\t\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\t<td class=\"td-title td-title-#{pureCode} #{title_permission} #{required}\">\n\t\t\t\t\t\t\t{{afFieldLabelText name=\"#{table_field.code}\"}}\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\t<td class=\"td-field td-field-#{pureCode} #{field_permission}\" colspan = \"#{table_field.td_colspan}\">\n\t\t\t\t\t\t\t{{> afFormGroup name=\"#{table_field.code}\" label=false}}\n\t\t\t\t\t\t</td>\n\t\t\t\t\t\"\"\"\n\t\t\t\t\ttemplate += table_field.tr_end\n\n\ttemplate += \"\"\"\n\t\t</table>\n\n\t\t<table class=\"table-page-footer form-table no-border\">\n\t\t\t<tr class=\"applicant-wrapper\">\n\t\t\t\t<td class=\"nowrap\">\n\t\t\t\t\t<div class='inline-left'>\n\t\t\t\t\t\t<label class=\"control-label\">{{_t \"instance_initiator\"}}：</label>\n\t\t\t\t\t</div>\n\t\t\t\t\t<div class='instance-table-wrapper-td inline-left'>\n\t\t\t\t\t\t{{>Template.dynamic  template=\"afSelectUser\" data=applicantContext}}\n\t\t\t\t\t</div>\n\t\t\t\t</td>\n\t\t\t\t<td class=\"nowrap\">\n\t\t\t\t\t<div class='pull-left'>\n\t\t\t\t\t\t<div class='inline-left'>\n\t\t\t\t\t\t\t<label>{{_t \"instance_submit_date\"}}：</label>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<div class='inline-right'>\n\t\t\t\t\t\t\t<div class=\"form-group\">\n\t\t\t\t\t\t\t\t{{formatDate instance.submit_date '{\"format\":\"YYYY-MM-DD\"}'}}\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t</td>\n\t\t\t</tr>\n\t\t</table>\n\t</div>\n\t\"\"\"\n\treturn template\n\n#此处模板公用与：instance 编辑、查看、打印、转发时生成附件、发送邮件body部分(table 模板)\n#如果有修改，请测试确认其他功能是否正常。\nTemplateManager._template =\n\tdefault: (instance)->\n\n\t\ttemplate = \"\"\"\n\t\t\t<div class=\"with-border col-md-12\">\n\t\t\t\t<div class=\"instance-name\">\n\t\t\t\t\t<h3 class=\"box-title\">#{TemplateManager.instance_title().pageTitle}</h3>\n\t\t\t\t\t<span class=\"help-block\"></span>\n\t\t\t\t</div>\n\t\t\t\t<span class=\"help-block\"></span>\n\t\t\t</div>\n\t\t\t{{#each steedos_form.fields}}\n\t\t\t\t{{#if isOpinionField this}}\n\t\t\t\t\t<div class=\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\">\n\t\t\t\t\t\t<div class=\"form-group automatic opinion-field-{{this.code}}\">\n\t\t\t\t\t\t\t<label class=\"control-label\">{{afFieldLabelText name=this.code}}</label>\n\n\t\t\t\t\t\t\t{{> instanceSignText name=this.code}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if includes this.type 'section,table'}}\n\t\t\t\t\t\t<div class=\"col-md-12 field-{{this.code}}\">\n\t\t\t\t\t\t\t{{> afFormGroup name=this.code label=false}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t<div class=\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\">\n\t\t\t\t\t\t{{> afFormGroup name=this.code}}\n\t\t\t\t\t\t</div>\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/each}}\n\t\t\t<div class=\"col-md-12\">\n\t\t\t\t<div class=\"applicant-wrapper form-group form-horizontal\">\n\t\t\t\t<div class=\"input-group\">\n\t\t\t\t\t<div class=\"input-group-addon\">\n\t\t\t\t\t  {{_t \"instance_initiator\"}}&nbsp;:\n\t\t\t\t\t</div>\n\t\t\t\t\t{{>Template.dynamic  template=\"afSelectUser\" data=applicantContext}}\n\t\t\t\t  </div>\n\t\t\t\t</div>\n\t\t\t</div>\n\t\t\"\"\"\n\t\treturn template\n\n\ttable: (instance)->\n\t\treturn TemplateManager.handleTableTemplate(instance)\n#\ttable: '''\n#\t\t<table class=\"box-header  with-border\" style=\"width: 100%;display: inline-table;\">\n#\t\t\t<tr class=\"instance-name\">\n#\t\t\t\t<td class=\"instance-table-name-td\">\n#\t\t\t\t\t<h3 class=\"box-title\">{{instance.name}}</h3>\n#\t\t\t\t\t<span class=\"help-block\"></span>\n#\t\t\t\t</td>\n#\t\t\t</tr>\n#            <tr class=\"applicant-wrapper\">\n#\t\t\t\t<td class=\"instance-table-wrapper-td\">\n#\t\t\t\t\t<label class=\"control-label\">{{_t \"instance_initiator\"}}&nbsp;:</label>\n#\t\t\t\t\t{{>Template.dynamic  template=\"afSelectUser\" data=applicantContext}}\n#\t\t\t\t</td>\n#\t\t\t</tr>\n#        </table>\n#\t\t<table class=\"form-table\">\n#\t\t    {{#each table_fields}}\n#\t\t\t\t{{#if isOpinionField this}}\n#\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t<td class=\"td-title {{#if is_required}}is-required{{/if}}\">\n#\t\t\t\t\t\t\t{{afFieldLabelText name=this.code}}\n#\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t<td class=\"td-field opinion-field\" colspan = '{{td_colspan}}'>\n#\t\t\t\t\t\t\t{{> instanceSignText step=(getOpinionFieldStepName this) default=''}}\n#\t\t\t\t\t\t</td>\n#\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t{{else}}\n#\t\t\t\t\t{{#if includes this.type 'section,table'}}\n#\t\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\t<td class=\"td-childfield\" colspan = '{{td_colspan}}'>\n#\t\t\t\t\t\t\t   {{> afFormGroup name=this.code label=false}}\n#\t\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t\t{{else}}\n#\t\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\t<td class=\"td-title {{#if is_required}}is-required{{/if}}\">\n#\t\t\t\t\t\t\t\t{{afFieldLabelText name=this.code}}\n#\t\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t\t<td class=\"td-field {{permission}}\" colspan = '{{td_colspan}}'>\n#\t\t\t\t\t\t\t\t{{> afFormGroup name=this.code label=false}}\n#\t\t\t\t\t\t\t</td>\n#\t\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t\t{{/if}}\n#\t\t\t\t{{/if}}\n#\n#\t\t    {{/each}}\n#\t\t</table>\n#\t'''\n\nTemplateManager._templateHelps =\n\tapplicantContext: ->\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {\n\t\t\t\tname: 'ins_applicant',\n\t\t\t\tid: 'ins_applicant',\n\t\t\t\tclass: 'selectUser form-control',\n\t\t\t\tstyle: 'padding:6px 12px;width:140px;display:inline'\n\t\t\t}\n\t\t}\n#\t\tif not steedos_instance || steedos_instance.state != \"draft\"\n\t\tdata.atts.disabled = true\n\t\treturn data;\n\ninstanceId: ->\n\treturn 'instanceform';#\"instance_\" + Session.get(\"instanceId\");\n\nform_types: ->\n\tif ApproveManager.isReadOnly()\n\t\treturn 'disabled';\n\telse\n\t\treturn 'method';\n\nsteedos_form: ->\n\tform_version = WorkflowManager.getInstanceFormVersion();\n\tif form_version\n\t\treturn form_version\n\ninnersubformContext: (obj)->\n\tdoc_values = WorkflowManager_format.getAutoformSchemaValues();\n\tobj[\"tableValues\"] = if doc_values then doc_values[obj.code] else []\n\tobj[\"formId\"] = formId;\n\treturn obj;\n\ninstance: ->\n\tSession.get(\"change_date\")\n\tif (Session.get(\"instanceId\"))\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\treturn steedos_instance;\n\nequals: (a, b) ->\n\treturn (a == b)\n\nincludes: (a, b) ->\n\treturn b.split(',').includes(a);\n\nfields: ->\n\tform_version = WorkflowManager.getInstanceFormVersion();\n\tif form_version\n\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\ndoc_values: ->\n\tWorkflowManager_format.getAutoformSchemaValues();\n\ninstance_box_style: ->\n\tbox = Session.get(\"box\")\n\tif box == \"inbox\" || box == \"draft\"\n\t\tjudge = Session.get(\"judge\")\n\t\tif judge\n\t\t\tif (judge == \"approved\")\n\t\t\t\treturn \"box-success\"\n\t\t\telse if (judge == \"rejected\")\n\t\t\t\treturn \"box-danger\"\n\tins = WorkflowManager.getInstance();\n\tif ins && ins.final_decision\n\t\tif ins.final_decision == \"approved\"\n\t\t\treturn \"box-success\"\n\t\telse if (ins.final_decision == \"rejected\")\n\t\t\treturn \"box-danger\"\n\n\nTemplateManager.getTemplate = (instance, templateName) ->\n\tflow = db.flows.findOne(instance.flow);\n\tform = db.forms.findOne(instance.form);\n\n\tif templateName\n\t\tif templateName == 'table'\n\t\t\treturn TemplateManager._template.table(instance)\n\t\treturn TemplateManager._template.default(instance)\n\n\tif Session?.get(\"instancePrint\")\n\t\tif flow?.print_template\n\t\t\treturn \"<div class='instance-template'>\" + flow.print_template + \"</div>\"\n\t\telse\n\t\t\tif flow?.instance_template\n\t\t\t\treturn \"<div class='instance-template'>\" + flow.instance_template + \"</div>\"\n\t\t\telse\n\t\t\t\treturn TemplateManager._template.table(instance)\n\telse\n\t\tif Steedos.isMobile()\n\t\t\treturn TemplateManager._template.default(instance)\n\n\t\tif flow?.instance_template\n\t\t\treturn \"<div class='instance-template'>\" + flow.instance_template + \"</div>\"\n\n\t\tif form?.instance_style\n\t\t\tif form.instance_style == 'table'\n\t\t\t\treturn TemplateManager._template.table(instance)\n\t\t\treturn TemplateManager._template.default(instance)\n\t\telse\n\t\t\treturn TemplateManager._template.default(instance)\n\n#TemplateManager.exportTemplate = (flowId) ->\n#\ttemplate = TemplateManager.getTemplate(flowId);\n#\n#\tflow = WorkflowManager.getFlow(flowId);\n#\n#\tif flow?.instance_template\n#\t\treturn template;\n#\n#\treturn template;\n\n","var formId;                 \n\nTemplateManager = {};\n\nformId = 'instanceform';\n\nTemplateManager.instance_title = function() {\n  var pageTitle, pageTitleTrClass, val;\n  pageTitle = \"{{instance.name}}\";\n  pageTitleTrClass = \"instance-name\";\n  if (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) {\n    pageTitle = \"{{> afFormGroup name=\\\"\" + CoreForm.pageTitleFieldName + \"\\\" label=false}}\";\n    pageTitleTrClass = \"\";\n  }\n  if (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitle : void 0) {\n    pageTitle = \"\" + CoreForm.pageTitle;\n    pageTitleTrClass = \"\";\n  }\n  val = {\n    pageTitle: pageTitle,\n    pageTitleTrClass: pageTitleTrClass\n  };\n  return val;\n};\n\nTemplateManager.handleTableTemplate = function(instance, _export) {\n  var table_fields, template;\n  template = \"<div class='instance-template'>\\n\t<table class=\\\"table-page-title form-table no-border text-align-center\\\" style=\\\"width: 100%;display: inline-table;\\\">\\n\t\t<tr class=\\\"\" + (this.instance_title().pageTitleTrClass) + \"\\\">\\n\t\t\t<td class=\\\"instance-table-name-td page-title\\\">\\n\t\t\t\t\" + (this.instance_title().pageTitle) + \"\\n\t\t\t</td>\\n\t\t</tr>\\n\\n\t</table>\\n\t<table class=\\\"table-page-body form-table\\\">\\n\t\t\t<tr style=\\\"height:0px\\\">\\n\t\t\t\t<th style='width: 16%'></th>\\n\t\t\t\t<th></th>\\n\t\t\t\t<th style='width: 16%'></th>\\n\t\t\t\t<th></th>\\n\t\t\t</tr>\";\n  table_fields = InstanceformTemplate.helpers.table_fields(instance);\n  table_fields && table_fields.forEach(function(table_field) {\n    var field_permission, pureCode, required, title_permission;\n    required = \"\";\n    if (!(typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) || (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) !== table_field.code) {\n      if (table_field.is_required) {\n        required = \"is-required\";\n      }\n      if (_export) {\n        required = \"\";\n      }\n      pureCode = Steedos.removeSpecialCharacter(table_field.code);\n      if (InstanceformTemplate.helpers.isOpinionField(table_field)) {\n        template += table_field.tr_start;\n        template += \"<td class=\\\"td-title \" + required + \"\\\">\\n\t{{afFieldLabelText name=\\\"\" + table_field.code + \"\\\"}}\\n</td>\\n<td class=\\\"td-field opinion-field opinion-field-\" + pureCode + \" automatic\\\" colspan = \\\"\" + table_field.td_colspan + \"\\\">\\n\t{{> instanceSignText name=\\\"\" + table_field.code + \"\\\"}}\\n</td>\";\n        return template += table_field.tr_end;\n      } else {\n        if (InstanceformTemplate.helpers.includes(table_field.type, 'section,table')) {\n          template += table_field.tr_start;\n          template += \"<td class=\\\"td-childfield td-childfield-\" + pureCode + \"\\\" colspan = \\\"\" + table_field.td_colspan + \"\\\">\\n   {{> afFormGroup name=\\\"\" + table_field.code + \"\\\" label=false}}\\n</td>\";\n          return template += table_field.tr_end;\n        } else {\n          template += table_field.tr_start;\n          if (_export) {\n            title_permission = \"\";\n            field_permission = \"\";\n          } else {\n            title_permission = \"title-\" + table_field.permission;\n            field_permission = \"field-\" + table_field.permission;\n          }\n          template += \"<td class=\\\"td-title td-title-\" + pureCode + \" \" + title_permission + \" \" + required + \"\\\">\\n\t{{afFieldLabelText name=\\\"\" + table_field.code + \"\\\"}}\\n</td>\\n<td class=\\\"td-field td-field-\" + pureCode + \" \" + field_permission + \"\\\" colspan = \\\"\" + table_field.td_colspan + \"\\\">\\n\t{{> afFormGroup name=\\\"\" + table_field.code + \"\\\" label=false}}\\n</td>\";\n          return template += table_field.tr_end;\n        }\n      }\n    }\n  });\n  template += \"\t</table>\\n\\n\t<table class=\\\"table-page-footer form-table no-border\\\">\\n\t\t<tr class=\\\"applicant-wrapper\\\">\\n\t\t\t<td class=\\\"nowrap\\\">\\n\t\t\t\t<div class='inline-left'>\\n\t\t\t\t\t<label class=\\\"control-label\\\">{{_t \\\"instance_initiator\\\"}}：</label>\\n\t\t\t\t</div>\\n\t\t\t\t<div class='instance-table-wrapper-td inline-left'>\\n\t\t\t\t\t{{>Template.dynamic  template=\\\"afSelectUser\\\" data=applicantContext}}\\n\t\t\t\t</div>\\n\t\t\t</td>\\n\t\t\t<td class=\\\"nowrap\\\">\\n\t\t\t\t<div class='pull-left'>\\n\t\t\t\t\t<div class='inline-left'>\\n\t\t\t\t\t\t<label>{{_t \\\"instance_submit_date\\\"}}：</label>\\n\t\t\t\t\t</div>\\n\t\t\t\t\t<div class='inline-right'>\\n\t\t\t\t\t\t<div class=\\\"form-group\\\">\\n\t\t\t\t\t\t\t{{formatDate instance.submit_date '{\\\"format\\\":\\\"YYYY-MM-DD\\\"}'}}\\n\t\t\t\t\t\t</div>\\n\t\t\t\t\t</div>\\n\t\t\t\t</div>\\n\t\t\t</td>\\n\t\t</tr>\\n\t</table>\\n</div>\";\n  return template;\n};\n\nTemplateManager._template = {\n  \"default\": function(instance) {\n    var template;\n    template = \"<div class=\\\"with-border col-md-12\\\">\\n\t<div class=\\\"instance-name\\\">\\n\t\t<h3 class=\\\"box-title\\\">\" + (TemplateManager.instance_title().pageTitle) + \"</h3>\\n\t\t<span class=\\\"help-block\\\"></span>\\n\t</div>\\n\t<span class=\\\"help-block\\\"></span>\\n</div>\\n{{#each steedos_form.fields}}\\n\t{{#if isOpinionField this}}\\n\t\t<div class=\\\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\\\">\\n\t\t\t<div class=\\\"form-group automatic opinion-field-{{this.code}}\\\">\\n\t\t\t\t<label class=\\\"control-label\\\">{{afFieldLabelText name=this.code}}</label>\\n\\n\t\t\t\t{{> instanceSignText name=this.code}}\\n\t\t\t</div>\\n\t\t</div>\\n\t{{else}}\\n\t\t{{#if includes this.type 'section,table'}}\\n\t\t\t<div class=\\\"col-md-12 field-{{this.code}}\\\">\\n\t\t\t\t{{> afFormGroup name=this.code label=false}}\\n\t\t\t</div>\\n\t\t{{else}}\\n\t\t\t<div class=\\\"{{#if this.is_wide}}col-md-12{{else}}col-md-6{{/if}} field-{{this.code}}\\\">\\n\t\t\t{{> afFormGroup name=this.code}}\\n\t\t\t</div>\\n\t\t{{/if}}\\n\t{{/if}}\\n{{/each}}\\n<div class=\\\"col-md-12\\\">\\n\t<div class=\\\"applicant-wrapper form-group form-horizontal\\\">\\n\t<div class=\\\"input-group\\\">\\n\t\t<div class=\\\"input-group-addon\\\">\\n\t\t  {{_t \\\"instance_initiator\\\"}}&nbsp;:\\n\t\t</div>\\n\t\t{{>Template.dynamic  template=\\\"afSelectUser\\\" data=applicantContext}}\\n\t  </div>\\n\t</div>\\n</div>\";\n    return template;\n  },\n  table: function(instance) {\n    return TemplateManager.handleTableTemplate(instance);\n  }\n};\n\nTemplateManager._templateHelps = {\n  applicantContext: function() {\n    var data, steedos_instance;\n    steedos_instance = WorkflowManager.getInstance();\n    data = {\n      name: 'ins_applicant',\n      atts: {\n        name: 'ins_applicant',\n        id: 'ins_applicant',\n        \"class\": 'selectUser form-control',\n        style: 'padding:6px 12px;width:140px;display:inline'\n      }\n    };\n    data.atts.disabled = true;\n    return data;\n  }\n};\n\n({\n  instanceId: function() {\n    return 'instanceform';\n  },\n  form_types: function() {\n    if (ApproveManager.isReadOnly()) {\n      return 'disabled';\n    } else {\n      return 'method';\n    }\n  },\n  steedos_form: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return form_version;\n    }\n  },\n  innersubformContext: function(obj) {\n    var doc_values;\n    doc_values = WorkflowManager_format.getAutoformSchemaValues();\n    obj[\"tableValues\"] = doc_values ? doc_values[obj.code] : [];\n    obj[\"formId\"] = formId;\n    return obj;\n  },\n  instance: function() {\n    var steedos_instance;\n    Session.get(\"change_date\");\n    if (Session.get(\"instanceId\")) {\n      steedos_instance = WorkflowManager.getInstance();\n      return steedos_instance;\n    }\n  },\n  equals: function(a, b) {\n    return a === b;\n  },\n  includes: function(a, b) {\n    return b.split(',').includes(a);\n  },\n  fields: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n    }\n  },\n  doc_values: function() {\n    return WorkflowManager_format.getAutoformSchemaValues();\n  },\n  instance_box_style: function() {\n    var box, ins, judge;\n    box = Session.get(\"box\");\n    if (box === \"inbox\" || box === \"draft\") {\n      judge = Session.get(\"judge\");\n      if (judge) {\n        if (judge === \"approved\") {\n          return \"box-success\";\n        } else if (judge === \"rejected\") {\n          return \"box-danger\";\n        }\n      }\n    }\n    ins = WorkflowManager.getInstance();\n    if (ins && ins.final_decision) {\n      if (ins.final_decision === \"approved\") {\n        return \"box-success\";\n      } else if (ins.final_decision === \"rejected\") {\n        return \"box-danger\";\n      }\n    }\n  }\n});\n\nTemplateManager.getTemplate = function(instance, templateName) {\n  var flow, form;\n  flow = db.flows.findOne(instance.flow);\n  form = db.forms.findOne(instance.form);\n  if (templateName) {\n    if (templateName === 'table') {\n      return TemplateManager._template.table(instance);\n    }\n    return TemplateManager._template[\"default\"](instance);\n  }\n  if (typeof Session !== \"undefined\" && Session !== null ? Session.get(\"instancePrint\") : void 0) {\n    if (flow != null ? flow.print_template : void 0) {\n      return \"<div class='instance-template'>\" + flow.print_template + \"</div>\";\n    } else {\n      if (flow != null ? flow.instance_template : void 0) {\n        return \"<div class='instance-template'>\" + flow.instance_template + \"</div>\";\n      } else {\n        return TemplateManager._template.table(instance);\n      }\n    }\n  } else {\n    if (Steedos.isMobile()) {\n      return TemplateManager._template[\"default\"](instance);\n    }\n    if (flow != null ? flow.instance_template : void 0) {\n      return \"<div class='instance-template'>\" + flow.instance_template + \"</div>\";\n    }\n    if (form != null ? form.instance_style : void 0) {\n      if (form.instance_style === 'table') {\n        return TemplateManager._template.table(instance);\n      }\n      return TemplateManager._template[\"default\"](instance);\n    } else {\n      return TemplateManager._template[\"default\"](instance);\n    }\n  }\n};\n","SteedosTable = {};\n\nSteedosTable.formId = \"instanceform\";\n\nSteedosTable.checkItem = function (field, item_index) {\n    var fieldObj = SteedosTable.getField(field);\n\n    var fieldVal = SteedosTable.getItemModalValue(field, item_index);\n\n    var sf_name = '';\n    var rev = true;\n    fieldObj.sfields.forEach(function (sf) {\n        if (sf.permission == 'editable') {\n            sf_name = fieldObj.code + \".\" + sf.code;\n            if (!InstanceManager.checkFormFieldValue($(\"[name='\" + sf_name + \"']\")[0], sf_name, fieldVal[sf.code])) {\n                rev = false;\n            }\n        }\n    });\n\n    return rev;\n}\n\nSteedosTable.setTableItemValue = function (field, item_index, item_value) {\n\n    var tableValue = SteedosTable.getTableValue(field);\n    tableValue[item_index] = item_value;\n}\n\nSteedosTable.getTableItemValue = function (field, item_index) {\n    return SteedosTable.getTableValue(field)[item_index];\n}\n\nSteedosTable.removeTableItem = function (field, item_index) {\n    var item_value = SteedosTable.getTableItemValue(field, item_index);\n    item_value.removed = true;\n}\n\nSteedosTable.setTableValue = function (field, value) {\n    $(\"table[name='\" + field + \"']\").val({\n        val: value\n    });\n}\n\nSteedosTable.getTableValue = function (field) {\n    return $(\"table[name='\" + field + \"']\").val().val;\n}\n\nSteedosTable.getValidValue = function (field) {\n    var value = SteedosTable.getTableValue(field);\n\n    if (!value) {\n        return\n    }\n\n    var validValue = [];\n\n    value.forEach(function (v) {\n        if (!v.removed) {\n            validValue.push(v);\n        }\n    });\n    return validValue;\n}\n\n\nSteedosTable.handleData = function (field, values) {\n\n    if (!values || !(values instanceof Array)) {\n        return values;\n    }\n\n    var fieldObj = SteedosTable.getField(field);\n\n    values.forEach(function (v) {\n        fieldObj.sfields.forEach(function (f) {\n            if (f.type == 'user' || f.type == 'group') {\n                var value = v[f.code]\n                if (f.is_multiselect) {\n                    if (value && value.length > 0 && typeof (value[0]) == 'object') {\n                        v[f.code] = v[f.code].getProperty(\"id\");\n                    }\n                } else {\n                    if (value && typeof (value) == 'object') {\n                        v[f.code] = v[f.code].id;\n                    }\n                }\n            } else if (f.type == 'dateTime') {\n                var value = v[f.code]\n                if (value) {\n                    if (value.length == 16) {\n                        var t = value.split(\"T\");\n                        var t0 = t[0].split(\"-\");\n                        var t1 = t[1].split(\":\");\n\n                        year = t0[0];\n                        month = t0[1];\n                        date = t0[2];\n                        hours = t1[0];\n                        seconds = t1[1];\n                        value = new Date(year, month - 1, date, hours, seconds);\n                        v[f.code] = value;\n                    }\n\n                }\n            }\n        });\n    });\n    return values;\n}\n\nSteedosTable.getField = function (field) {\n    var instanceFields = WorkflowManager.getInstanceFields();\n    if (!instanceFields)\n        return;\n\n    var fieldObj = instanceFields.findPropertyByPK(\"code\", field);\n\n    return fieldObj;\n}\n\n\nSteedosTable.getModalData = function (field, index) {\n\n    var data = {};\n\n    var fieldObj = SteedosTable.getField(field);\n\n    if (!fieldObj) {\n        return;\n    }\n\n    data.field = fieldObj;\n\n    data.field.formula = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", fieldObj.sfields);\n\n    data.value = {};\n\n    data.value[field] = SteedosTable.getTableItemValue(field, index);\n\n    data.index = index;\n\n    return data;\n}\n\n\n\nSteedosTable.getItemModalValue = function (field, item_index) {\n\n    if (!AutoForm.getFormValues(\"steedos_table_modal_\" + field + \"_\" + item_index)) {\n        return {}\n    }\n\n    var item_value = AutoForm.getFormValues(\"steedos_table_modal_\" + field + \"_\" + item_index).insertDoc[field];\n    return item_value;\n}\n\n\nSteedosTable.addItem = function (field, index, _item_value) {\n    var keys = SteedosTable.getKeys(field);\n    var item_value = _item_value || SteedosTable.getItemModalValue(field, index);\n    $(\"tbody[name='\" + field + \"Tbody']\").append(SteedosTable.getTr(keys, item_value, index, field, true))\n\n}\n\nSteedosTable.updateItem = function (field, index, _item_value) {\n\n    var item = $(\"tr[name='\" + field + \"_item_\" + index + \"']\");\n\n    var item_value = _item_value || SteedosTable.getItemModalValue(field, index);\n\n    if (item && item.length > 0) {\n        var keys = SteedosTable.getKeys(field);\n        var tds = SteedosTable.getRemoveTd(field, index);\n\n        var sfields = SteedosTable.getField(field).sfields;\n\n        keys.forEach(function (key) {\n            var sfield = sfields.findPropertyByPK(\"code\", key);\n\n            var value = item_value[key];\n\n            tds = tds + SteedosTable.getTd(sfield, index, value);\n\n        });\n\n        item.empty();\n\n        item.append(tds);\n\n    } else {\n\n        SteedosTable.addItem(field, index);\n    }\n\n    if (SteedosTable.getTableValue(field)) {\n\n        SteedosTable.setTableItemValue(field, index, item_value);\n\n        //SteedosTable.valueHash[field][index] = item_value;\n\n    } else {\n        //SteedosTable.valueHash[field] = [item_value];\n\n        SteedosTable.setTableValue(field, [item_value])\n\n    }\n\n    //执行主表公式计算\n    InstanceManager.runFormula(field);\n\n}\n\nSteedosTable.removeItem = function (field, index) {\n\n    $(\"tr[name='\" + field + \"_item_\" + index + \"']\").hide();\n\n    SteedosTable.removeTableItem(field, index);\n\n    InstanceManager.runFormula(field);\n}\n\nSteedosTable.showModal = function (field, index, method) {\n\n\n    var modalData = SteedosTable.getModalData(field, index);\n\n    modalData.method = method;\n    setTimeout(function(){\n        Modal.show(\"steedosTableModal\", modalData);\n    }, 300)\n}\n\nSteedosTable.getKeys = function (field) {\n    if (!AutoForm.getCurrentDataForForm(SteedosTable.formId)) {\n        return [];\n    }\n\n    var ss = AutoForm.getFormSchema(SteedosTable.formId);\n\n    var keys = [];\n\n    if (ss.schema(field + \".$\").type === Object) {\n        keys = ss.objectKeys(SimpleSchema._makeGeneric(field) + '.$')\n    }\n\n    return keys;\n\n}\n\nSteedosTable.getThead = function (field, editable) {\n\n    var fieldObj = field;\n    if (!_.isObject(field))\n        fieldObj = SteedosTable.getField(field);\n\n    if (!fieldObj) {\n        return '';\n    }\n\n    var thead = '',\n        trs = '',\n        label = '',\n        width = 100;\n\n    if (editable) {\n        // trs = \"<th class='removed'></th>\"\n        trs = \"\"\n    }\n\n    var sfields = fieldObj.sfields;\n\n    if (!sfields) {\n        return thead;\n    }\n\n    var sf_length = sfields.length;\n\n    if (sf_length > 0) {\n        var wide_fields = sfields.filterProperty(\"is_wide\", true);\n\n        width = 100 / (sf_length + wide_fields.length);\n    }\n\n    sfields.forEach(function (sf, index) {\n\n        label = (sf.name != null && sf.name.length > 0) ? sf.name : sf.code;\n\n        trs = trs + \"<td \"; // nowrap='nowrap'\n\n        trs = trs + \" class='title \" + sf.type + \"'\";\n\n        if (index != (sf_length - 1)) {\n            if (sf.is_wide) {\n                trs = trs + \"style='width:\" + width * 2 + \"%'\"\n            } else {\n                trs = trs + \"style='width:\" + width + \"%'\"\n            }\n        }\n\n        trs = trs + \">\" + label + \"</td>\"\n    });\n\n    thead = '<tr>' + trs + '</tr>';\n\n    return thead;\n}\n\nSteedosTable.getTbody = function (keys, field, values, editable, sfieldsEditable) {\n    var tbody = \"\";\n\n    if (values instanceof Array) {\n        values.forEach(function (value, index) {\n            tbody = tbody + SteedosTable.getTr(keys, value, index, field, editable, sfieldsEditable);\n        });\n    }\n\n    return tbody;\n}\n\nSteedosTable.getTr = function (keys, item_value, index, field, editable, sfieldsEditable) {\n\n    var fieldObj = field;\n    if (!_.isObject(field))\n        fieldObj = SteedosTable.getField(field);\n\n    var tr = \"<tr id='\" + fieldObj.code + \"_item_\" + index + \"' name='\" + fieldObj.code + \"_item_\" + index + \"' data-index='\" + index + \"'\"\n\n    if (editable || sfieldsEditable) {\n        tr = tr + \"' class='item edit'\"\n    } else {\n        if (Steedos.isMobile()) {\n            tr = tr + \" class='item item-readonly'\"\n        } else {\n            tr = tr + \" class='item '\"\n        }\n    }\n\n    if (item_value.removed) {\n        tr = tr + \" style='display:none' \";\n    }\n\n    tr = tr + \"'>\";\n\n    var tds = \"\";\n\n    if (editable) {\n        tds = SteedosTable.getRemoveTd(fieldObj.code, index);\n    }\n\n    var sfields = fieldObj.sfields;\n\n    keys.forEach(function (key) {\n        var sfield = sfields.findPropertyByPK(\"code\", key);\n\n        var value = item_value[key];\n\n        tds = tds + SteedosTable.getTd(sfield, index, value);\n\n    });\n\n    tr = tr + tds + \"</tr>\";\n    return tr;\n}\n\nSteedosTable.getRemoveTd = function (field, index) {\n    // return \"<td class='steedosTable-item-remove removed' data-index='\" + index + \"'><i class='fa fa-times' aria-hidden='true'></td>\";\n    return \"\"\n}\n\nSteedosTable.getTd = function (field, index, value) {\n    var td = \"<td \";\n\n    td = td + \" class='steedosTable-item-field \" + field.type + \"' \";\n\n    var td_value = \"\";\n\n    if (Meteor.isClient) {\n        td_value = SteedosTable.getTDValue(field, value)\n    } else {\n        locale = Template.instance().view.template.steedosData.locale\n\n        utcOffset = Template.instance().view.template.steedosData.utcOffset\n\n        td_value = InstanceReadOnlyTemplate.getValue(value, field, locale, utcOffset)\n    }\n\n    td = td + \" data-index='\" + index + \"'>\" + td_value + \"</td>\"\n\n    return td;\n}\n\n\nSteedosTable.getTDValue = function (field, value) {\n    var td_value = \"\";\n    if (!field) {\n        return td_value\n    }\n    try {\n        var fieldOptions = [];\n        if([\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1){\n            fieldOptions = field.options.split(\"\\n\").map(function(n){\n                var itemSplits = n.split(\":\")\n                return {\n                    label: itemSplits[0],\n                    value: itemSplits[1] || n\n                }\n            });\n        }\n\n        switch (field.type) {\n            case 'user':\n                if (value) {\n                    if (field.is_multiselect) {\n                        if (value.length > 0) {\n                            if (\"string\" == typeof (value[0])) {\n                                td_value = CFDataManager.getFormulaSpaceUsers(value).getProperty(\"name\").toString();\n                            } else {\n                                td_value = value.getProperty(\"name\").toString();\n                            }\n                        }\n                    } else {\n                        if (\"string\" == typeof (value)) {\n                            var u = CFDataManager.getFormulaSpaceUsers(value);\n                            td_value = u ? u.name : '';\n                        } else {\n                            td_value = value.name;\n                        }\n                    }\n                }\n                break;\n            case 'group':\n                if (value) {\n                    if (field.is_multiselect) {\n                        if (value.length > 0) {\n                            if (\"string\" == typeof (value[0])) {\n                                td_value = CFDataManager.getFormulaOrganizations(value).getProperty(\"name\").toString();\n                            } else {\n                                td_value = value.getProperty(\"name\").toString();\n                            }\n                        }\n                    } else {\n                        if (\"string\" == typeof (value)) {\n                            var o = CFDataManager.getFormulaOrganization(value);\n                            td_value = o ? o.name : '';\n                        } else {\n                            td_value = value.name;\n                        }\n                    }\n                }\n                break;\n            case 'checkbox':\n                if (value === true || value == 'true') {\n                    td_value = TAPi18n.__(\"form_field_checkbox_yes\");\n                } else {\n                    td_value = TAPi18n.__(\"form_field_checkbox_no\");\n                }\n                break;\n            case 'email':\n                td_value = value ? \"<a href='mailto:\" + value + \"'>\" + value + \"</a>\" : \"\";\n                break;\n            case 'url':\n                if (value) {\n                    if (value.indexOf(\"http\") == 0) {\n                        try {\n                            td_value = \"<a href='\" + encodeURI(value) + \"' target='_blank'>\" + value + \"</a>\";\n                        } catch (e) {\n                            td_value = \"<a href='' target='_blank'>\" + value + \"</a>\";\n                        }\n\n                    } else {\n                        td_value = \"<a href='http://\" + encodeURI(value) + \"' target='_blank'>http://\" + value + \"</a>\";\n                    }\n                } else {\n                    td_value = \"\";\n                }\n                break;\n            case 'password':\n                td_value = '******';\n                break;\n            case 'date':\n                if (value) {\n                    if (value.length == 10) {\n                        var t = value.split(\"-\");\n                        year = t[0];\n                        month = t[1];\n                        date = t[2];\n                        value = new Date(year, month - 1, date);\n                    } else {\n                        value = new Date(value)\n                    }\n                    td_value = $.format.date(value, 'yyyy-MM-dd');\n                }\n                break;\n            case 'dateTime':\n                if (value) {\n                    if (value.length == 16) {\n                        var t = value.split(\"T\");\n                        var t0 = t[0].split(\"-\");\n                        var t1 = t[1].split(\":\");\n\n                        year = t0[0];\n                        month = t0[1];\n                        date = t0[2];\n                        hours = t1[0];\n                        seconds = t1[1];\n\n                        value = new Date(year, month - 1, date, hours, seconds);\n\n                    } else {\n\n                        value = new Date(value)\n                    }\n                    td_value = $.format.date(value, 'yyyy-MM-dd HH:mm');\n                }\n                break;\n            case 'select':\n                var selectedOption = fieldOptions.find(function(item){ return item.value == value; })\n                if(selectedOption){\n                    td_value = selectedOption.label\n                }\n                break;\n            case 'radio':\n                var selectedOption = fieldOptions.find(function(item){ return item.value == value; })\n                if(selectedOption){\n                    td_value = selectedOption.label\n                }\n                break;\n            case 'multiSelect':\n                var splitedValues = value.split(\",\");\n                var selectedOptions = fieldOptions.filter(function(item){ return splitedValues.indexOf(item.value) > -1; });\n                if(selectedOptions.length){\n                    td_value = selectedOptions.map(function(item){ return item.label; }).join(\",\");\n                }\n                break;\n            case 'number':\n                if (value || value == 0) {\n                    if (field.is_percent) {\n                        td_value = Steedos.numberToPercentString(value, field.digits);\n                    } else {\n                        td_value = Steedos.numberToString(value, field.digits);\n                    }\n                }\n                break;\n            case 'odata':\n                if (value) {\n                    if (field.is_multiselect) {\n                        td_value = _.pluck(value, '@label').toString()\n                    } else {\n                        td_value = value['@label']\n                    }\n                }\n                break;\n            case 'file':\n            case 'lookup':\n            case 'image':\n            case 'time':\n                td_value = InstanceReadOnlyTemplate.getValue(value, field);\n                break\n            default:\n                td_value = value ? value : '';\n                break;\n        }\n    } catch (e) {\n        e;\n\n        return '';\n    }\n    return td_value;\n};\n\nif (Meteor.isClient) {\n    AutoForm.addInputType(\"table\", {\n        template: \"afTable\",\n        valueOut: function () {\n            var name = this.data(\"schemaKey\");\n            return SteedosTable.getValidValue(name);\n        },\n        valueConverters: {\n            \"stringArray\": AutoForm.valueConverters.stringToStringArray,\n            \"number\": AutoForm.valueConverters.stringToNumber,\n            \"numerArray\": AutoForm.valueConverters.stringToNumberArray,\n            \"boolean\": AutoForm.valueConverters.stringToBoolean,\n            \"booleanArray\": AutoForm.valueConverters.stringToBooleanArray,\n            \"date\": AutoForm.valueConverters.stringToDate,\n            \"dateArray\": AutoForm.valueConverters.stringToDateArray\n        },\n        contextAdjust: function (context) {\n            if (typeof context.atts.maxlength === 'undefined' && typeof context.max === 'number') {\n                context.atts.maxlength = context.max;\n            }\n            return context;\n        }\n    });\n\n    Template.afTable.events({\n        'tap .steedos-table .steedosTable-item-add,.add-item-tr': function (event, template) {\n            var name = template.data.name;\n\n            var tableValue = SteedosTable.getTableValue(name);\n\n            var new_item_index = tableValue ? tableValue.length : 0;\n\n            SteedosTable.showModal(name, new_item_index, \"add\");\n        },\n\n        'tap .steedos-table .steedosTable-item-field': function (event, template) {\n            if (template.data.atts.editable || template.data.atts.sfieldsEditable) {\n                var field = template.data.name;\n                var index = event.currentTarget.dataset.index;\n                SteedosTable.showModal(field, index, \"edit\");\n            }\n        },\n\n        'tap .steedos-table .steedosTable-item-remove': function (event, template) {\n            var field = template.data.name;\n            var item_index = event.currentTarget.dataset.index;\n            Session.set(\"instance_change\", true);\n            SteedosTable.removeItem(field, item_index);\n        },\n\n        'tap .steedos-table .item-readonly': function (event, template) {\n            if (!template.data.atts.editable) {\n                var field = template.data.name;\n                var index = event.currentTarget.dataset.index;\n                SteedosTable.showModal(field, index, \"read\");\n            }\n        }\n    });\n\n\n\n    Template.afTable.rendered = function () {\n\n        var field = this.data.name;\n\n        var sfieldsEditable = this.data.atts.sfieldsEditable;\n\n        var keys = SteedosTable.getKeys(field);\n        var validValue = SteedosTable.handleData(field, this.data.value);\n        SteedosTable.setTableValue(field, validValue);\n\n        $(\"thead[name='\" + field + \"Thead']\").html(SteedosTable.getThead(field, this.data.atts.editable));\n\n        $(\"tbody[name='\" + field + \"Tbody']\").html(SteedosTable.getTbody(keys, field, SteedosTable.getTableValue(field), this.data.atts.editable, sfieldsEditable));\n\n        str = t(\"steedos_table_add_item\");\n        addItemTr = \"<tr class='add-item-tr'><td colspan='\" + keys.length + \"'><i class='ion ion-plus-round'></i>\" + str + \"</td></tr>\";\n\n        if (this.data.atts.editable) {\n            $(\"tfoot[name='\" + field + \"Tfoot']\").append(addItemTr);\n        }\n\n        var c = InstanceManager.getCurrentStep();\n        if (c.step_type == 'counterSign' || InstanceManager.ccHasEditPermission()) {\n            this.autorun(function () {\n                var data = Template.currentData();\n                var field = data.name;\n                var keys = SteedosTable.getKeys(field);\n                var validValue = SteedosTable.handleData(field, data.value);\n                SteedosTable.setTableValue(field, validValue);\n                $(\"tbody[name='\" + field + \"Tbody']\").html(SteedosTable.getTbody(keys, field, SteedosTable.getTableValue(field), data.atts.editable, sfieldsEditable));\n            })\n        }\n\n    };\n}","ImageSign.helpers =\n\tspaceUserSign: (userId)->\n\t\tspace = \"\"\n\n\t\tif Meteor.isServer\n\t\t\tspace = Template.instance().view.template.steedosData.space\n\t\telse\n\t\t\tspace = Session.get(\"spaceId\")\n\n\t\tspaceUserSign = db.space_user_signs.findOne({space: space, user: userId});\n\t\treturn spaceUserSign\n\n\timageURL: (userId)->\n\n\t\tspaceUserSign = ImageSign.helpers.spaceUserSign(userId);\n\n\t\tabsolute = false\n\n\t\tif Meteor.isServer\n\t\t\tabsolute = Template.instance().view.template.steedosData.absolute\n\n\t\tif spaceUserSign?.sign\n\t\t\tif absolute\n\t\t\t\treturn Meteor.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n\t\t\telse\n\t\t\t\treturn Steedos.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n","ImageSign.helpers = {\n  spaceUserSign: function(userId) {\n    var space, spaceUserSign;\n    space = \"\";\n    if (Meteor.isServer) {\n      space = Template.instance().view.template.steedosData.space;\n    } else {\n      space = Session.get(\"spaceId\");\n    }\n    spaceUserSign = db.space_user_signs.findOne({\n      space: space,\n      user: userId\n    });\n    return spaceUserSign;\n  },\n  imageURL: function(userId) {\n    var absolute, spaceUserSign;\n    spaceUserSign = ImageSign.helpers.spaceUserSign(userId);\n    absolute = false;\n    if (Meteor.isServer) {\n      absolute = Template.instance().view.template.steedosData.absolute;\n    }\n    if (spaceUserSign != null ? spaceUserSign.sign : void 0) {\n      if (absolute) {\n        return Meteor.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n      } else {\n        return Steedos.absoluteUrl(\"api/files/avatars/\" + spaceUserSign.sign);\n      }\n    }\n  }\n};\n","TracesHandler.helpers =\n\tshowSignImage: (handler, is_finished, judge, traceShowSignImage) ->\n\t\tif traceShowSignImage == false\n\t\t\treturn false\n\t\tif !is_finished\n\t\t\treturn false\n\t\tif ['returned', 'terminated', 'retrieved'].includes(judge)\n\t\t\treturn false\n\t\tspaceUserSign = ImageSign.helpers.spaceUserSign(handler)\n\n\t\tif spaceUserSign?.sign\n\t\t\treturn true\n\t\telse\n\t\t\treturn false\n\n\tobjectUrl: (object_name, record_id, app_id)->\n\t\treturn Creator.getObjectUrl(object_name, record_id, app_id)","TracesHandler.helpers = {\n  showSignImage: function(handler, is_finished, judge, traceShowSignImage) {\n    var spaceUserSign;\n    if (traceShowSignImage === false) {\n      return false;\n    }\n    if (!is_finished) {\n      return false;\n    }\n    if (['returned', 'terminated', 'retrieved'].includes(judge)) {\n      return false;\n    }\n    spaceUserSign = ImageSign.helpers.spaceUserSign(handler);\n    if (spaceUserSign != null ? spaceUserSign.sign : void 0) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  objectUrl: function(object_name, record_id, app_id) {\n    return Creator.getObjectUrl(object_name, record_id, app_id);\n  }\n};\n","marked = require(\"marked\")\nInstanceformTemplate.helpers =\n\tapplicantContext: ->\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {name: 'ins_applicant', id: 'ins_applicant', class: 'selectUser form-control ins_applicant'},\n\t\t\tvalue: steedos_instance.applicant_name\n\t\t}\n\t\tif not steedos_instance || steedos_instance.state != \"draft\"\n\t\t\tdata.atts.disabled = true\n\t\treturn data;\n\n\tinstanceId: ->\n\t\treturn 'instanceform';#\"instance_\" + Session.get(\"instanceId\");\n\n\tform_types: ->\n\t\tif ApproveManager.isReadOnly()\n\t\t\treturn 'disabled';\n\t\telse\n\t\t\treturn 'method';\n\n\tsteedos_form: ->\n\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\t\tif form_version\n\t\t\treturn form_version\n\n\tinnersubformContext: (obj)->\n\t\tdoc_values = WorkflowManager_format.getAutoformSchemaValues();\n\t\tobj[\"tableValues\"] = if doc_values then doc_values[obj.code] else []\n\t\tobj[\"formId\"] = \"instanceform\";\n\t\treturn obj;\n\n\tinstance: ->\n\t\tSession.get(\"change_date\")\n\t\tif (Session.get(\"instanceId\"))\n\t\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\t\treturn steedos_instance;\n\n\tempty: (val) ->\n\t\tif val\n\t\t\treturn false\n\t\telse\n\t\t\treturn true;\n\n\tunempty: (val) ->\n\t\tif val\n\t\t\treturn true;\n\t\telse\n\t\t\treturn false;\n\n\tequals: (a, b) ->\n\t\treturn (a == b)\n\n\tunequals: (a, b) ->\n\t\treturn !(a == b)\n\n\tincludes: (a, b) ->\n\t\treturn b.split(',').includes(a);\n\n\tinclude: (a, b) ->\n\t\treturn b.split(',').includes(a);\n\n\tfields: ->\n\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\t\tif form_version\n\t\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\n\tformatDate: (date, options)->\n\t\tif !date\n\t\t\treturn \"\";\n\t\tif options && typeof(options) == 'string'\n\t\t\toptions = JSON.parse(options);\n\n\t\tif !options.format\n\t\t\toptions = {format: \"YYYY-MM-DD HH:mm\"}\n\n\t\treturn moment(date).format(options.format);\n\n\ttraces: ->\n\t\tif Meteor.isServer\n\t\t\tsteedosData = Template.instance()?.view?.template?.steedosData\n\t\t\tinstance = steedosData?.instance\n\t\t\tflow = InstanceReadOnlyTemplate.getFlowVersion(instance);\n\t\t\tlocale = steedosData?.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tinstance = WorkflowManager.getInstance();\n\n\t\t\tflow = WorkflowManager.getInstanceFlowVersion()\n\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\n\t\tif !instance || !flow\n\t\t\treturn {};\n\n\t\tsteps = flow.steps;\n\n\t\ttraces = {};\n\n\t\tinstance.traces?.forEach (trace)->\n\t\t\tstep = steps.findPropertyByPK(\"_id\", trace.step)\n\n\t\t\tapproves = []\n\n\t\t\ttrace.approves?.forEach (approve) ->\n\t\t\t\tif trace.is_finished == true\n# 已结束的显示为核准/驳回/取消申请\n\t\t\t\t\tif approve.judge == 'approved'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State approved\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'rejected'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State rejected\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'terminated'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State terminated\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'reassigned'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State reassigned\", {}, locale)\n\t\t\t\t\telse if approve.judge == 'relocated'\n\t\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State relocated\", {}, locale)\n\t\t\t\t\telse if approve.judge == ''\n\t\t\t\t\t\tjudge_name = \"\"\n\t\t\t\t\telse\n\t\t\t\t\t\tjudge_name = \"\"\n\n\t\t\t\telse\n\t\t\t\t\tjudge_name = TAPi18n.__(\"Instance State pending\", {}, locale)\n\n\t\t\t\tapproves.push\n\t\t\t\t\t_id: approve._id\n\t\t\t\t\thandler: approve.user\n\t\t\t\t\thandler_name: approve.handler_name\n\t\t\t\t\thandler_organization_name: approve.handler_organization_name\n\t\t\t\t\thandler_organization_fullname: approve.handler_organization_fullname\n\t\t\t\t\tfinish_date: approve.finish_date\n\t\t\t\t\tjudge: approve.judge\n\t\t\t\t\tjudge_name: judge_name\n\t\t\t\t\tdescription: approve.description\n\t\t\t\t\tis_finished: approve.is_finished\n\t\t\t\t\ttype: approve.type\n\t\t\t\t\topinion_fields_code: approve.opinion_fields_code\n\t\t\t\t\tsign_field_code: approve.sign_field_code\n\t\t\t\t\tis_read: approve.is_read\n\t\t\t\t\tsign_show: approve.sign_show\n\n\n\t\t\tif step\n\t\t\t\tif step.name of traces\n\t\t\t\t\ttraces[step.name] = traces[step.name].concat(approves)\n\t\t\t\telse\n\t\t\t\t\ttraces[step.name] = approves\n\n\t\treturn traces;\n\n\n\n\tdoc_values: ->\n\t\tWorkflowManager_format.getAutoformSchemaValues();\n\n\tinstance_box_style: ->\n\t\tbox = Session.get(\"box\")\n\t\tif box == \"inbox\" || box == \"draft\"\n\t\t\tjudge = Session.get(\"judge\")\n\t\t\tif judge\n\t\t\t\tif (judge == \"approved\")\n\t\t\t\t\treturn \"box-success\"\n\t\t\t\telse if (judge == \"rejected\")\n\t\t\t\t\treturn \"box-danger\"\n\t\tins = WorkflowManager.getInstance();\n\t\tif ins && ins.final_decision\n\t\t\tif ins.final_decision == \"approved\"\n\t\t\t\treturn \"box-success\"\n\t\t\telse if (ins.final_decision == \"rejected\")\n\t\t\t\treturn \"box-danger\"\n\n#is_disabled: ->\n#    ins = WorkflowManager.getInstance();\n#    if !ins\n#        return;\n#    if ins.state!=\"draft\"\n#        return \"disabled\";\n#    return;\n\n\ttable_fields: (instance)->\n\t\tif Meteor.isClient\n\t\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\t\telse\n\t\t\tform_version = WorkflowManager.getFormVersion(instance.form, instance.form_version)\n\t\tif form_version\n\t\t\tfields = _.clone(form_version.fields);\n\n\t\t\tfields.forEach (field, index) ->\n\t\t\t\tfield.tr_start = \"\";\n\t\t\t\tfield.tr_end = \"\";\n\t\t\t\ttd_colspan = 1;\n#\t\t\t\t强制设置标头字段为宽字段\n\t\t\t\tif CoreForm?.pageTitleFieldName == field.code\n\t\t\t\t\tfield.is_wide = true\n\n\t\t\t\tif field.formula && field.type != 'odata'\n\t\t\t\t\tfield.permission = \"readonly\";\n\n\t\t\t\tif Steedos.isMobile()\n# 如果当前字段是分组、表格、宽字段\n\t\t\t\t\tif field.type == 'section' || field.type == 'table'\n\t\t\t\t\t\tfield.td_colspan = 4;\n\t\t\t\t\telse\n\t\t\t\t\t\tfield.td_colspan = 3;\n\n\t\t\t\t\tif index != 0\n\t\t\t\t\t\tfield.tr_start = \"<tr>\";\n\t\t\t\t\t\tfield.tr_end = \"</tr>\";\n\t\t\t\telse\n\t\t\t\t\tpre_fields = fields.slice(0, index);\n\n\t\t\t\t\tpre_wide_fields = pre_fields.filterProperty(\"is_wide\", true);\n\n\t\t\t\t\ttr_start = \"\";\n\n\t\t\t\t\ttr_end = \"\";\n\n\t\t\t\t\t# 先计算当前字段是否为宽字段\n\t\t\t\t\tbefore_field = null;\n\t\t\t\t\tafter_field = null;\n\n\t\t\t\t\tif index > 0\n\t\t\t\t\t\tbefore_field = fields[index - 1]\n\n\t\t\t\t\tif index < fields.length - 1\n\t\t\t\t\t\tafter_field = fields[index + 1]\n\n\t\t\t\t\t# 如果当前字段是分组、表格、宽字段\n\t\t\t\t\tif field.type == 'section' || field.type == 'table'\n\t\t\t\t\t\ttd_colspan = 4;\n\t\t\t\t\telse if field.is_wide\n\t\t\t\t\t\ttd_colspan = 3;\n\t\t\t\t\telse\n# 前后都是宽字段\n\t\t\t\t\t\tif before_field && after_field && before_field.is_wide && after_field.is_wide\n\t\t\t\t\t\t\tfield.is_wide = true;\n\t\t\t\t\t\t\ttd_colspan = 3;\n\n\t\t\t\t\t\t# 当前是tr 下的 第一个td & 后边的字段是宽字段\n\t\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 == 0 && after_field && after_field.is_wide\n\t\t\t\t\t\t\tfield.is_wide = true;\n\t\t\t\t\t\t\ttd_colspan = 3;\n\n\t\t\t\t\t\t# 当前是tr 下的 第一个td & 当前字段是最后一个字段\n\t\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 == 0 && after_field == null\n\t\t\t\t\t\t\tfield.is_wide = true;\n\t\t\t\t\t\t\ttd_colspan = 3;\n\n\t\t\t\t\tfield.td_colspan = td_colspan;\n\n\n\t\t\t\t\tif index == 0\n# tr_start = \"<tr>\"; 由于Template的编译bug，导致每次给一个tr开始时，会自动补头或补尾。因此在第一行返回一个空字符串.\n\t\t\t\t\t\ttr_start = \"<tr>\";\n\t\t\t\t\telse\n\t\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 == 0 || field.is_wide\n\t\t\t\t\t\t\tif field.type == 'table'\n\t\t\t\t\t\t\t\ttr_start = \"<tr class = \\\"tr-child-table\\\">\";\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\ttr_start = \"<tr>\";\n\n\t\t\t\t\tfield.tr_start = tr_start;\n\n\n\t\t\t\t\tif index + 1 == fields.length || field.type == 'section' || field.type == 'table' || field.is_wide\n\t\t\t\t\t\ttr_end = \"</tr>\";\n\n\t\t\t\t\tif (pre_fields.length + pre_wide_fields.length) % 2 != 0\n\t\t\t\t\t\ttr_end = \"</tr>\";\n\n\t\t\t\t\tfield.tr_end = tr_end;\n\n\t\t\treturn fields;\n\n\tsort_approve: (approves, order)->\n\t\tif !approves\n\t\t\treturn []\n\n\t\tif !approves instanceof Array\n\t\t\treturn []\n\t\telse\n\t\t\tif order == 'desc'\n\t\t\t\tapproves.sort (p1, p2) ->\n\t\t\t\t\t_p1 = 0\n\t\t\t\t\t_p2 = 0\n\n\t\t\t\t\tif p1.finish_date\n\t\t\t\t\t\t_p1 = p1.finish_date.getTime()\n\n\t\t\t\t\tif p2.finish_date\n\t\t\t\t\t\t_p2 = p2.finish_date.getTime();\n\n\t\t\t\t\treturn _p2 - _p1\n\t\t\telse\n\t\t\t\tapproves.sort (p1, p2) ->\n\t\t\t\t\t_p1 = 0\n\t\t\t\t\t_p2 = 0\n\n\t\t\t\t\tif p1.finish_date\n\t\t\t\t\t\t_p1 = p1.finish_date.getTime()\n\n\t\t\t\t\tif p2.finish_date\n\t\t\t\t\t\t_p2 = p2.finish_date.getTime();\n\n\t\t\t\t\treturn _p1 - _p2\n\t\treturn approves\n\n\t_t: (key)->\n\t\treturn TAPi18n.__(key)\n\tgetField: (code)->\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\t\tif form_version\n\t\t\treturn form_version.fields.findPropertyByPK(\"code\", code)\n\n\tgetValue: (code)->\n\t\tinstance = Template.instance().view.template.steedosData.instance\n\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\n\t\tutcOffset = Template.instance().view.template.steedosData.utcOffset\n\n\t\tvalues = instance.values || {}\n\n\t\tif Meteor.isClient\n\t\t\tvalues = WorkflowManager_format.getAutoformSchemaValues()\n\n\t\treturn InstanceReadOnlyTemplate.getValue values[code], form_version.fields.findPropertyByPK(\"code\", code), locale, utcOffset\n\n\tgetLabel: (code)->\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\t\tInstanceReadOnlyTemplate.getLabel form_version.fields, code\n\n\tisTextarea: (field)->\n\t\tif field?.type == \"input\" && field?.is_textarea\n\t\t\treturn true\n\n\tgetCfClass: (field)->\n\t\tif field?.type == \"input\" && field?.is_textarea\n\t\t\treturn \"cfTextarea\"\n\n\tgetTableThead: (field)->\n\t\treturn SteedosTable.getThead(field, false)\n\n\tgetTableBody: (field)->\n\n\t\tif Meteor.isServer\n\t\t\tinstance = Template.instance().view.template.steedosData.instance\n\t\t\tvalues = instance.values || {}\n\t\telse\n\t\t\tvalues = WorkflowManager_format.getAutoformSchemaValues()\n\n\t\ttableValue = values[field.code];\n\t\treturn SteedosTable.getTbody(field.sfields.getProperty(\"code\"), field, tableValue, false)\n\n\tshowLabel: (field)->\n\t\ttemplateData = Template.instance().data\n\t\tif templateData.label == false\n\t\t\treturn false\n\t\treturn true\n\n#\tafFieldLabelText: (op)->\n#\t\tif !Template.instance().view.template.steedosData\n#\t\t\treturn AutoForm.getLabelForField(op.name)\n#\t\telse\n#\t\t\tform_version = Template.instance().view.template.steedosData.form_version\n#\t\t\tInstanceReadOnlyTemplate.getLabel form_version.fields, op?.hash?.name\n\n\tisOpinionField: (field)->\n\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field.formula)\n\n\tisOpinionField_from_string: (field_formula)->\n\t\treturn InstanceSignText.isOpinionField_from_string(field_formula)\n\n\tincludesOpinionField: (form, form_version)->\n\n\t\tfield_formulas = new Array();\n\n\t\tfields = db.form_versions.findOne({_id: form_version, form: form})?.fields || []\n\n\t\tfields.forEach (f)->\n\t\t\tif f.type == 'table'\n\t\t\t\tconsole.log 'ignore opinion field in table'\n\t\t\telse if f.type == 'section'\n\t\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\t\tfield_formulas.push f1.formula\n\t\t\telse\n\t\t\t\tfield_formulas.push f.formula\n\n\t\t_.some field_formulas, (field_formula)->\n\t\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\n\tgetOpinionFieldStepsName: (field_formula, top_keywords)->\n\n\t\topinionFields = new Array();\n#\t\tconsole.log(\"field_formula\", field_formula)\n\t\tif InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\t\t\tif field_formula\n\n#\t\t\t\tfoo1 = field_formula.split(\",\")\n\t\t\t\tfoo1 = field_formula.split(\";\")\n\n#\t\t\t\tif top_keywords\n#\t\t\t\t\tfoo1 = field_formula.split(\";\")\n\n\t\t\t\tfoo1.forEach (foo)->\n\t\t\t\t\tjson_formula = {}\n\n\t\t\t\t\ttry\n\t\t\t\t\t\tjson_formula = eval(\"(\" + foo + \")\")\n\t\t\t\t\tcatch\n\t\t\t\t\t\tjson_formula = {}\n\n\t\t\t\t\tif json_formula?.yijianlan\n\t\t\t\t\t\tsf = {}\n\n\t\t\t\t\t\tsf.stepName = json_formula.yijianlan.step\n\n\t\t\t\t\t\tsf.image_sign = json_formula.yijianlan.image_sign || false\n\n\t\t\t\t\t\tsf.only_cc_opinion = json_formula.yijianlan.only_cc || false\n\n\t\t\t\t\t\tsf.default_description = json_formula.yijianlan.default\n\n\t\t\t\t\t\tsf.only_handler = json_formula.yijianlan.only_handler\n\n\t\t\t\t\t\tsf.top_keywords = json_formula.yijianlan.top_keywords || top_keywords\n\n\t\t\t\t\t\topinionFields.push(sf);\n\n\t\t\t\t\telse if(field_formula?.indexOf(\"{traces.\") > -1 || field_formula?.indexOf(\"{signature.traces.\") > -1)\n\n\t\t\t\t\t\tsf = {only_cc_opinion: false, image_sign: false, top_keywords: top_keywords}\n\n\t\t\t\t\t\tif foo.indexOf(\"{signature.\") > -1\n\t\t\t\t\t\t\tsf.image_sign = true\n\t\t\t\t\t\t\tfoo = foo.replace(\"{signature.\",\"\");\n\n\t\t\t\t\t\ts1 = foo.replace(\"{\",\"\").replace(\"}\",\"\")\n\t\t\t\t\t\tif s1.split(\".\").length > 1\n\t\t\t\t\t\t\tsf.stepName = s1.split(\".\")[1]\n\t\t\t\t\t\t\tif opinionFields.filterProperty(\"stepName\",sf.stepName).length > 0\n\t\t\t\t\t\t\t\topinionFields.findPropertyByPK(\"stepName\", sf.stepName)?.only_cc_opinion = true\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tif s1.split(\".\").length > 2\n\t\t\t\t\t\t\t\t\tif s1.split(\".\")[2]?.toLocaleLowerCase() == 'cc'\n\t\t\t\t\t\t\t\t\t\tsf.only_cc_opinion = true\n\t\t\t\t\t\topinionFields.push(sf);\n\n\t\treturn opinionFields\n\n\tshowCCOpinion: (field)->\n\t\tif field.formula?.indexOf(\"{traces.\") > -1 || field.formula?.indexOf(\"{signature.traces.\") > -1\n\t\t\ts1 = field.formula.replace(\"{signature.\",\"\").replace(\"{\",\"\").replace(\"}\",\"\")\n\t\t\tif s1.split(\".\").length > 2\n\t\t\t\tif s1.split(\".\")[2]?.toLocaleLowerCase() == 'cc'\n\t\t\t\t\treturn true\n\t\treturn false\n\n\tmarkDownToHtml: (markDownString)->\n\t\tif markDownString\n\t\t\t# renderer = new Markdown.Renderer();\n\t\t\t# renderer.link = ( href, title, text ) ->\n\t\t\t# \treturn \"<a target='_blank' href='#{href}' title='#{title}'>#{text}</a>\"\n\t\t\tif Meteor.isServer\n\t\t\t\tmarked = Npm.require('marked')\n\t\t\treturn Spacebars.SafeString(marked.parse(markDownString))\n\n\tf_label: (that)->\n\t\treturn that.name || that.code\n\nif Meteor.isServer\n\tInstanceformTemplate.helpers.steedos_form = ->\n\t\treturn this.form_version\n\n\tInstanceformTemplate.helpers.isSection = (code)->\n\t\tform_version = this.form_version\n\t\treturn form_version.fields.findPropertyByPK(\"code\", code).type == 'section'\n\n\tInstanceformTemplate.helpers.doc_values = ->\n\t\tinstance = this.instance;\n\t\treturn instance.values;\n\n\tInstanceformTemplate.helpers.applicantContext = ->\n\t\tinstance = this.instance;\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {name: 'ins_applicant', id: 'ins_applicant', class: 'selectUser form-control ins_applicant'},\n\t\t\tvalue: instance.applicant_name\n\t\t}\n\n\tInstanceformTemplate.helpers.instance = ->\n\t\treturn this.instance\n\n\tInstanceformTemplate.helpers.fields = ->\n\t\tform_version = this.form_version\n\t\tif form_version\n\t\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\n\tInstanceformTemplate.helpers.form_types = ->\n\t\treturn \"disabled\"\n\n\tTemplate.registerHelper \"afFieldLabelText\", (op)->\n\t\tform_version = Template.instance().view.template.steedosData.form_version\n\t\tInstanceReadOnlyTemplate.getLabel form_version.fields, op?.hash?.name\n\n\tInstanceformTemplate.helpers._t = (key)->\n\t\tlocale = this.locale\n\n\t\treturn TAPi18n.__(key, {}, locale)\n\n\tInstanceformTemplate.helpers.ins_attach_download_url = (_id, absolute)->\n\t\tif absolute\n\t\t\treturn Meteor.absoluteUrl(\"/api/files/instances/#{_id}?download=true\");\n\t\telse\n\t\t\treturn \"/api/files/instances/#{_id}?download=true\";\n\n\tInstanceformTemplate.helpers.options = (field)->\n\t\toptions = field?.options?.split(\"\\n\")\n\t\trev = []\n\t\toptions?.forEach (item)->\n\t\t\trev.push({label: item, value: item})\n\n\t\treturn rev\n\n\tInstanceformTemplate.helpers.getPermissions = (code)->\n\t\tif !Template.instance().view.template.steedosData.startStepEditableFields?.includes(code)\n\t\t\treturn \"readonly disabled\"\n\t\treturn \"\"\n\nInstanceformTemplate.events =\n\t'change .form-control,.checkbox input,.af-radio-group input,.af-checkbox-group input': (event)->\n\t\tInstanceManager.instanceformChangeEvent(event)\n\n\t'typeahead:change .form-control': (event) ->\n\t\tInstanceManager.instanceformChangeEvent(event)\n\n\t'click .cfTextarea a': (event)->\n\t\tevent.preventDefault();\n\t\tSteedos.openWindow(event.target.href);\n\n\nInstanceformTemplate.onCreated = ()->\n\tinstance = WorkflowManager.getInstance();\n\tif !instance\n\t\treturn;\n\n\ttemplate = TemplateManager.getTemplate(instance);\n\n\ttry\n\t\tcompiled = SpacebarsCompiler.compile(template, {isBody: true});\n\tcatch e\n\t\tconsole.log \"Instance Template Error\", e\n\t\tcompiled = SpacebarsCompiler.compile(\"\", {isBody: true});\n\n\n\trenderFunction = eval(compiled);\n\n\tinstanceView = new Blaze.View(\"custom_instance_template\", renderFunction);\n\n\tinstanceCustomTemplate = new Blaze.Template(instanceView.name, renderFunction);\n\n\tTemplate.instance_custom_template = instanceCustomTemplate\n\n\tTemplate.instance_custom_template.helpers InstanceformTemplate.helpers\n\n\n\n\nInstanceformTemplate.onRendered = ()->\n\t# t = this;\n\n\t#t.subscribe \"instance_data\", Session.get(\"instanceId\"), ->\n\t#    Tracker.afterFlush ->\n\tinstance = WorkflowManager.getInstance();\n\tif !instance\n\t\treturn;\n\n\t#$(\"#ins_applicant\").select2().val(instance.applicant).trigger('change');\n\t#$(\"#ins_applicant\").val(instance.applicant);\n\tInstanceManager.setInstanceFormApplicant(instance.applicant, instance.applicant_name)\n\n\n\tApproveManager.error = {nextSteps: '', nextStepUsers: ''};\n\n\t# instance from绑定事件\n\tif Session.get(\"box\") == 'inbox' || Session.get(\"box\") == 'draft'\n\t\tInstanceEvent.initEvents(instance.flow);\n\n\tif !ApproveManager.isReadOnly()\n\n\t\tcurrentApprove = InstanceManager.getCurrentApprove();\n\n\n\t\tinstanceNumberFields = $(\"[data-formula]\", $(\"#instanceform\"))\n\n\t\tinstanceNumberFields.each ()->\n\t\t\tschemaKey = this.dataset.schemaKey\n\t\t\telement = $(this)\n\t\t\tif !$(this).val() && schemaKey && Session.get(\"instanceId\")\n\t\t\t\tMeteor.call 'getInstanceValues', Session.get(\"instanceId\"), (error, result)->\n\t\t\t\t\tif error\n\t\t\t\t\t\ttoastr.error(error.reason)\n\n\t\t\t\t\tif !result[schemaKey]\n\t\t\t\t\t\tkey = element.data(\"formula\")?.replace(\"auto_number(\", \"\").replace(\")\", \"\")\n\n\t\t\t\t\t\tkey = key.replace(/\\\"/g, \"\").replace(/\\'/g, \"\")\n\n\t\t\t\t\t\tif key.indexOf(\"{\") > -1\n\t\t\t\t\t\t\tkey = key.replace(\"{\",\"\").replace(\"}\",\"\")\n\t\t\t\t\t\t\tkey = key.trim()\n\t\t\t\t\t\t\tkey = AutoForm.getFieldValue(key, 'instanceform')\n\t\t\t\t\t\tInstanceNumberRules.instanceNumberBuilder element, key\n\t\t\t\t\telse\n\t\t\t\t\t\telement?.val(result[schemaKey]).trigger(\"change\")\n\n\t\tjudge = currentApprove.judge\n\t\tcurrentStep = InstanceManager.getCurrentStep();\n\t\tform_version = WorkflowManager.getInstanceFormVersion();\n\n\t\tunless form_version\n\t\t\treturn\n\n\t\tunless form_version.fields\n\t\t\treturn\n\n\t\tformula_fields = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", form_version.fields);\n\t\tinsertDoc = AutoForm.getFormValues(\"instanceform\", undefined, undefined, false)\n\t\tForm_formula.run(\"\", \"\", formula_fields, insertDoc, form_version.fields);\n\t\t#在此处初始化session 中的 form_values 变量，用于触发下一步步骤计算\n\t\tSession.set(\"instance_form_values\", {instanceId: instance._id, values: insertDoc});\n\n\n\n","var marked;\n\nmarked = require(\"marked\");\n\nInstanceformTemplate.helpers = {\n  applicantContext: function() {\n    var data, steedos_instance;\n    steedos_instance = WorkflowManager.getInstance();\n    data = {\n      name: 'ins_applicant',\n      atts: {\n        name: 'ins_applicant',\n        id: 'ins_applicant',\n        \"class\": 'selectUser form-control ins_applicant'\n      },\n      value: steedos_instance.applicant_name\n    };\n    if (!steedos_instance || steedos_instance.state !== \"draft\") {\n      data.atts.disabled = true;\n    }\n    return data;\n  },\n  instanceId: function() {\n    return 'instanceform';\n  },\n  form_types: function() {\n    if (ApproveManager.isReadOnly()) {\n      return 'disabled';\n    } else {\n      return 'method';\n    }\n  },\n  steedos_form: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return form_version;\n    }\n  },\n  innersubformContext: function(obj) {\n    var doc_values;\n    doc_values = WorkflowManager_format.getAutoformSchemaValues();\n    obj[\"tableValues\"] = doc_values ? doc_values[obj.code] : [];\n    obj[\"formId\"] = \"instanceform\";\n    return obj;\n  },\n  instance: function() {\n    var steedos_instance;\n    Session.get(\"change_date\");\n    if (Session.get(\"instanceId\")) {\n      steedos_instance = WorkflowManager.getInstance();\n      return steedos_instance;\n    }\n  },\n  empty: function(val) {\n    if (val) {\n      return false;\n    } else {\n      return true;\n    }\n  },\n  unempty: function(val) {\n    if (val) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  equals: function(a, b) {\n    return a === b;\n  },\n  unequals: function(a, b) {\n    return !(a === b);\n  },\n  includes: function(a, b) {\n    return b.split(',').includes(a);\n  },\n  include: function(a, b) {\n    return b.split(',').includes(a);\n  },\n  fields: function() {\n    var form_version;\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (form_version) {\n      return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n    }\n  },\n  formatDate: function(date, options) {\n    if (!date) {\n      return \"\";\n    }\n    if (options && typeof options === 'string') {\n      options = JSON.parse(options);\n    }\n    if (!options.format) {\n      options = {\n        format: \"YYYY-MM-DD HH:mm\"\n      };\n    }\n    return moment(date).format(options.format);\n  },\n  traces: function() {\n    var flow, instance, locale, ref, ref1, ref2, ref3, steedosData, steps, traces;\n    if (Meteor.isServer) {\n      steedosData = (ref = Template.instance()) != null ? (ref1 = ref.view) != null ? (ref2 = ref1.template) != null ? ref2.steedosData : void 0 : void 0 : void 0;\n      instance = steedosData != null ? steedosData.instance : void 0;\n      flow = InstanceReadOnlyTemplate.getFlowVersion(instance);\n      locale = steedosData != null ? steedosData.locale : void 0;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      instance = WorkflowManager.getInstance();\n      flow = WorkflowManager.getInstanceFlowVersion();\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    if (!instance || !flow) {\n      return {};\n    }\n    steps = flow.steps;\n    traces = {};\n    if ((ref3 = instance.traces) != null) {\n      ref3.forEach(function(trace) {\n        var approves, ref4, step;\n        step = steps.findPropertyByPK(\"_id\", trace.step);\n        approves = [];\n        if ((ref4 = trace.approves) != null) {\n          ref4.forEach(function(approve) {\n            var judge_name;\n            if (trace.is_finished === true) {\n              if (approve.judge === 'approved') {\n                judge_name = TAPi18n.__(\"Instance State approved\", {}, locale);\n              } else if (approve.judge === 'rejected') {\n                judge_name = TAPi18n.__(\"Instance State rejected\", {}, locale);\n              } else if (approve.judge === 'terminated') {\n                judge_name = TAPi18n.__(\"Instance State terminated\", {}, locale);\n              } else if (approve.judge === 'reassigned') {\n                judge_name = TAPi18n.__(\"Instance State reassigned\", {}, locale);\n              } else if (approve.judge === 'relocated') {\n                judge_name = TAPi18n.__(\"Instance State relocated\", {}, locale);\n              } else if (approve.judge === '') {\n                judge_name = \"\";\n              } else {\n                judge_name = \"\";\n              }\n            } else {\n              judge_name = TAPi18n.__(\"Instance State pending\", {}, locale);\n            }\n            return approves.push({\n              _id: approve._id,\n              handler: approve.user,\n              handler_name: approve.handler_name,\n              handler_organization_name: approve.handler_organization_name,\n              handler_organization_fullname: approve.handler_organization_fullname,\n              finish_date: approve.finish_date,\n              judge: approve.judge,\n              judge_name: judge_name,\n              description: approve.description,\n              is_finished: approve.is_finished,\n              type: approve.type,\n              opinion_fields_code: approve.opinion_fields_code,\n              sign_field_code: approve.sign_field_code,\n              is_read: approve.is_read,\n              sign_show: approve.sign_show\n            });\n          });\n        }\n        if (step) {\n          if (step.name in traces) {\n            return traces[step.name] = traces[step.name].concat(approves);\n          } else {\n            return traces[step.name] = approves;\n          }\n        }\n      });\n    }\n    return traces;\n  },\n  doc_values: function() {\n    return WorkflowManager_format.getAutoformSchemaValues();\n  },\n  instance_box_style: function() {\n    var box, ins, judge;\n    box = Session.get(\"box\");\n    if (box === \"inbox\" || box === \"draft\") {\n      judge = Session.get(\"judge\");\n      if (judge) {\n        if (judge === \"approved\") {\n          return \"box-success\";\n        } else if (judge === \"rejected\") {\n          return \"box-danger\";\n        }\n      }\n    }\n    ins = WorkflowManager.getInstance();\n    if (ins && ins.final_decision) {\n      if (ins.final_decision === \"approved\") {\n        return \"box-success\";\n      } else if (ins.final_decision === \"rejected\") {\n        return \"box-danger\";\n      }\n    }\n  },\n  table_fields: function(instance) {\n    var fields, form_version;\n    if (Meteor.isClient) {\n      form_version = WorkflowManager.getInstanceFormVersion();\n    } else {\n      form_version = WorkflowManager.getFormVersion(instance.form, instance.form_version);\n    }\n    if (form_version) {\n      fields = _.clone(form_version.fields);\n      fields.forEach(function(field, index) {\n        var after_field, before_field, pre_fields, pre_wide_fields, td_colspan, tr_end, tr_start;\n        field.tr_start = \"\";\n        field.tr_end = \"\";\n        td_colspan = 1;\n        if ((typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) === field.code) {\n          field.is_wide = true;\n        }\n        if (field.formula && field.type !== 'odata') {\n          field.permission = \"readonly\";\n        }\n        if (Steedos.isMobile()) {\n          if (field.type === 'section' || field.type === 'table') {\n            field.td_colspan = 4;\n          } else {\n            field.td_colspan = 3;\n          }\n          if (index !== 0) {\n            field.tr_start = \"<tr>\";\n            return field.tr_end = \"</tr>\";\n          }\n        } else {\n          pre_fields = fields.slice(0, index);\n          pre_wide_fields = pre_fields.filterProperty(\"is_wide\", true);\n          tr_start = \"\";\n          tr_end = \"\";\n          before_field = null;\n          after_field = null;\n          if (index > 0) {\n            before_field = fields[index - 1];\n          }\n          if (index < fields.length - 1) {\n            after_field = fields[index + 1];\n          }\n          if (field.type === 'section' || field.type === 'table') {\n            td_colspan = 4;\n          } else if (field.is_wide) {\n            td_colspan = 3;\n          } else {\n            if (before_field && after_field && before_field.is_wide && after_field.is_wide) {\n              field.is_wide = true;\n              td_colspan = 3;\n            }\n            if ((pre_fields.length + pre_wide_fields.length) % 2 === 0 && after_field && after_field.is_wide) {\n              field.is_wide = true;\n              td_colspan = 3;\n            }\n            if ((pre_fields.length + pre_wide_fields.length) % 2 === 0 && after_field === null) {\n              field.is_wide = true;\n              td_colspan = 3;\n            }\n          }\n          field.td_colspan = td_colspan;\n          if (index === 0) {\n            tr_start = \"<tr>\";\n          } else {\n            if ((pre_fields.length + pre_wide_fields.length) % 2 === 0 || field.is_wide) {\n              if (field.type === 'table') {\n                tr_start = \"<tr class = \\\"tr-child-table\\\">\";\n              } else {\n                tr_start = \"<tr>\";\n              }\n            }\n          }\n          field.tr_start = tr_start;\n          if (index + 1 === fields.length || field.type === 'section' || field.type === 'table' || field.is_wide) {\n            tr_end = \"</tr>\";\n          }\n          if ((pre_fields.length + pre_wide_fields.length) % 2 !== 0) {\n            tr_end = \"</tr>\";\n          }\n          return field.tr_end = tr_end;\n        }\n      });\n      return fields;\n    }\n  },\n  sort_approve: function(approves, order) {\n    if (!approves) {\n      return [];\n    }\n    if (!approves instanceof Array) {\n      return [];\n    } else {\n      if (order === 'desc') {\n        approves.sort(function(p1, p2) {\n          var _p1, _p2;\n          _p1 = 0;\n          _p2 = 0;\n          if (p1.finish_date) {\n            _p1 = p1.finish_date.getTime();\n          }\n          if (p2.finish_date) {\n            _p2 = p2.finish_date.getTime();\n          }\n          return _p2 - _p1;\n        });\n      } else {\n        approves.sort(function(p1, p2) {\n          var _p1, _p2;\n          _p1 = 0;\n          _p2 = 0;\n          if (p1.finish_date) {\n            _p1 = p1.finish_date.getTime();\n          }\n          if (p2.finish_date) {\n            _p2 = p2.finish_date.getTime();\n          }\n          return _p1 - _p2;\n        });\n      }\n    }\n    return approves;\n  },\n  _t: function(key) {\n    return TAPi18n.__(key);\n  },\n  getField: function(code) {\n    var form_version;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    if (form_version) {\n      return form_version.fields.findPropertyByPK(\"code\", code);\n    }\n  },\n  getValue: function(code) {\n    var form_version, instance, locale, utcOffset, values;\n    instance = Template.instance().view.template.steedosData.instance;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    locale = Template.instance().view.template.steedosData.locale;\n    utcOffset = Template.instance().view.template.steedosData.utcOffset;\n    values = instance.values || {};\n    if (Meteor.isClient) {\n      values = WorkflowManager_format.getAutoformSchemaValues();\n    }\n    return InstanceReadOnlyTemplate.getValue(values[code], form_version.fields.findPropertyByPK(\"code\", code), locale, utcOffset);\n  },\n  getLabel: function(code) {\n    var form_version;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    return InstanceReadOnlyTemplate.getLabel(form_version.fields, code);\n  },\n  isTextarea: function(field) {\n    if ((field != null ? field.type : void 0) === \"input\" && (field != null ? field.is_textarea : void 0)) {\n      return true;\n    }\n  },\n  getCfClass: function(field) {\n    if ((field != null ? field.type : void 0) === \"input\" && (field != null ? field.is_textarea : void 0)) {\n      return \"cfTextarea\";\n    }\n  },\n  getTableThead: function(field) {\n    return SteedosTable.getThead(field, false);\n  },\n  getTableBody: function(field) {\n    var instance, tableValue, values;\n    if (Meteor.isServer) {\n      instance = Template.instance().view.template.steedosData.instance;\n      values = instance.values || {};\n    } else {\n      values = WorkflowManager_format.getAutoformSchemaValues();\n    }\n    tableValue = values[field.code];\n    return SteedosTable.getTbody(field.sfields.getProperty(\"code\"), field, tableValue, false);\n  },\n  showLabel: function(field) {\n    var templateData;\n    templateData = Template.instance().data;\n    if (templateData.label === false) {\n      return false;\n    }\n    return true;\n  },\n  isOpinionField: function(field) {\n    return InstanceformTemplate.helpers.isOpinionField_from_string(field.formula);\n  },\n  isOpinionField_from_string: function(field_formula) {\n    return InstanceSignText.isOpinionField_from_string(field_formula);\n  },\n  includesOpinionField: function(form, form_version) {\n    var field_formulas, fields, ref;\n    field_formulas = new Array();\n    fields = ((ref = db.form_versions.findOne({\n      _id: form_version,\n      form: form\n    })) != null ? ref.fields : void 0) || [];\n    fields.forEach(function(f) {\n      var ref1;\n      if (f.type === 'table') {\n        return console.log('ignore opinion field in table');\n      } else if (f.type === 'section') {\n        return f != null ? (ref1 = f.fields) != null ? ref1.forEach(function(f1) {\n          return field_formulas.push(f1.formula);\n        }) : void 0 : void 0;\n      } else {\n        return field_formulas.push(f.formula);\n      }\n    });\n    return _.some(field_formulas, function(field_formula) {\n      return InstanceformTemplate.helpers.isOpinionField_from_string(field_formula);\n    });\n  },\n  getOpinionFieldStepsName: function(field_formula, top_keywords) {\n    var foo1, opinionFields;\n    opinionFields = new Array();\n    if (InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)) {\n      if (field_formula) {\n        foo1 = field_formula.split(\";\");\n        foo1.forEach(function(foo) {\n          var json_formula, ref, ref1, s1, sf;\n          json_formula = {};\n          try {\n            json_formula = eval(\"(\" + foo + \")\");\n          } catch (error1) {\n            json_formula = {};\n          }\n          if (json_formula != null ? json_formula.yijianlan : void 0) {\n            sf = {};\n            sf.stepName = json_formula.yijianlan.step;\n            sf.image_sign = json_formula.yijianlan.image_sign || false;\n            sf.only_cc_opinion = json_formula.yijianlan.only_cc || false;\n            sf.default_description = json_formula.yijianlan[\"default\"];\n            sf.only_handler = json_formula.yijianlan.only_handler;\n            sf.top_keywords = json_formula.yijianlan.top_keywords || top_keywords;\n            return opinionFields.push(sf);\n          } else if ((field_formula != null ? field_formula.indexOf(\"{traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{signature.traces.\") : void 0) > -1) {\n            sf = {\n              only_cc_opinion: false,\n              image_sign: false,\n              top_keywords: top_keywords\n            };\n            if (foo.indexOf(\"{signature.\") > -1) {\n              sf.image_sign = true;\n              foo = foo.replace(\"{signature.\", \"\");\n            }\n            s1 = foo.replace(\"{\", \"\").replace(\"}\", \"\");\n            if (s1.split(\".\").length > 1) {\n              sf.stepName = s1.split(\".\")[1];\n              if (opinionFields.filterProperty(\"stepName\", sf.stepName).length > 0) {\n                if ((ref = opinionFields.findPropertyByPK(\"stepName\", sf.stepName)) != null) {\n                  ref.only_cc_opinion = true;\n                }\n              } else {\n                if (s1.split(\".\").length > 2) {\n                  if (((ref1 = s1.split(\".\")[2]) != null ? ref1.toLocaleLowerCase() : void 0) === 'cc') {\n                    sf.only_cc_opinion = true;\n                  }\n                }\n              }\n            }\n            return opinionFields.push(sf);\n          }\n        });\n      }\n    }\n    return opinionFields;\n  },\n  showCCOpinion: function(field) {\n    var ref, ref1, ref2, s1;\n    if (((ref = field.formula) != null ? ref.indexOf(\"{traces.\") : void 0) > -1 || ((ref1 = field.formula) != null ? ref1.indexOf(\"{signature.traces.\") : void 0) > -1) {\n      s1 = field.formula.replace(\"{signature.\", \"\").replace(\"{\", \"\").replace(\"}\", \"\");\n      if (s1.split(\".\").length > 2) {\n        if (((ref2 = s1.split(\".\")[2]) != null ? ref2.toLocaleLowerCase() : void 0) === 'cc') {\n          return true;\n        }\n      }\n    }\n    return false;\n  },\n  markDownToHtml: function(markDownString) {\n    if (markDownString) {\n      if (Meteor.isServer) {\n        marked = Npm.require('marked');\n      }\n      return Spacebars.SafeString(marked.parse(markDownString));\n    }\n  },\n  f_label: function(that) {\n    return that.name || that.code;\n  }\n};\n\nif (Meteor.isServer) {\n  InstanceformTemplate.helpers.steedos_form = function() {\n    return this.form_version;\n  };\n  InstanceformTemplate.helpers.isSection = function(code) {\n    var form_version;\n    form_version = this.form_version;\n    return form_version.fields.findPropertyByPK(\"code\", code).type === 'section';\n  };\n  InstanceformTemplate.helpers.doc_values = function() {\n    var instance;\n    instance = this.instance;\n    return instance.values;\n  };\n  InstanceformTemplate.helpers.applicantContext = function() {\n    var data, instance;\n    instance = this.instance;\n    return data = {\n      name: 'ins_applicant',\n      atts: {\n        name: 'ins_applicant',\n        id: 'ins_applicant',\n        \"class\": 'selectUser form-control ins_applicant'\n      },\n      value: instance.applicant_name\n    };\n  };\n  InstanceformTemplate.helpers.instance = function() {\n    return this.instance;\n  };\n  InstanceformTemplate.helpers.fields = function() {\n    var form_version;\n    form_version = this.form_version;\n    if (form_version) {\n      return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n    }\n  };\n  InstanceformTemplate.helpers.form_types = function() {\n    return \"disabled\";\n  };\n  Template.registerHelper(\"afFieldLabelText\", function(op) {\n    var form_version, ref;\n    form_version = Template.instance().view.template.steedosData.form_version;\n    return InstanceReadOnlyTemplate.getLabel(form_version.fields, op != null ? (ref = op.hash) != null ? ref.name : void 0 : void 0);\n  });\n  InstanceformTemplate.helpers._t = function(key) {\n    var locale;\n    locale = this.locale;\n    return TAPi18n.__(key, {}, locale);\n  };\n  InstanceformTemplate.helpers.ins_attach_download_url = function(_id, absolute) {\n    if (absolute) {\n      return Meteor.absoluteUrl(\"/api/files/instances/\" + _id + \"?download=true\");\n    } else {\n      return \"/api/files/instances/\" + _id + \"?download=true\";\n    }\n  };\n  InstanceformTemplate.helpers.options = function(field) {\n    var options, ref, rev;\n    options = field != null ? (ref = field.options) != null ? ref.split(\"\\n\") : void 0 : void 0;\n    rev = [];\n    if (options != null) {\n      options.forEach(function(item) {\n        return rev.push({\n          label: item,\n          value: item\n        });\n      });\n    }\n    return rev;\n  };\n  InstanceformTemplate.helpers.getPermissions = function(code) {\n    var ref;\n    if (!((ref = Template.instance().view.template.steedosData.startStepEditableFields) != null ? ref.includes(code) : void 0)) {\n      return \"readonly disabled\";\n    }\n    return \"\";\n  };\n}\n\nInstanceformTemplate.events = {\n  'change .form-control,.checkbox input,.af-radio-group input,.af-checkbox-group input': function(event) {\n    return InstanceManager.instanceformChangeEvent(event);\n  },\n  'typeahead:change .form-control': function(event) {\n    return InstanceManager.instanceformChangeEvent(event);\n  },\n  'click .cfTextarea a': function(event) {\n    event.preventDefault();\n    return Steedos.openWindow(event.target.href);\n  }\n};\n\nInstanceformTemplate.onCreated = function() {\n  var compiled, e, instance, instanceCustomTemplate, instanceView, renderFunction, template;\n  instance = WorkflowManager.getInstance();\n  if (!instance) {\n    return;\n  }\n  template = TemplateManager.getTemplate(instance);\n  try {\n    compiled = SpacebarsCompiler.compile(template, {\n      isBody: true\n    });\n  } catch (error1) {\n    e = error1;\n    console.log(\"Instance Template Error\", e);\n    compiled = SpacebarsCompiler.compile(\"\", {\n      isBody: true\n    });\n  }\n  renderFunction = eval(compiled);\n  instanceView = new Blaze.View(\"custom_instance_template\", renderFunction);\n  instanceCustomTemplate = new Blaze.Template(instanceView.name, renderFunction);\n  Template.instance_custom_template = instanceCustomTemplate;\n  return Template.instance_custom_template.helpers(InstanceformTemplate.helpers);\n};\n\nInstanceformTemplate.onRendered = function() {\n  var currentApprove, currentStep, form_version, formula_fields, insertDoc, instance, instanceNumberFields, judge;\n  instance = WorkflowManager.getInstance();\n  if (!instance) {\n    return;\n  }\n  InstanceManager.setInstanceFormApplicant(instance.applicant, instance.applicant_name);\n  ApproveManager.error = {\n    nextSteps: '',\n    nextStepUsers: ''\n  };\n  if (Session.get(\"box\") === 'inbox' || Session.get(\"box\") === 'draft') {\n    InstanceEvent.initEvents(instance.flow);\n  }\n  if (!ApproveManager.isReadOnly()) {\n    currentApprove = InstanceManager.getCurrentApprove();\n    instanceNumberFields = $(\"[data-formula]\", $(\"#instanceform\"));\n    instanceNumberFields.each(function() {\n      var element, schemaKey;\n      schemaKey = this.dataset.schemaKey;\n      element = $(this);\n      if (!$(this).val() && schemaKey && Session.get(\"instanceId\")) {\n        return Meteor.call('getInstanceValues', Session.get(\"instanceId\"), function(error, result) {\n          var key, ref;\n          if (error) {\n            toastr.error(error.reason);\n          }\n          if (!result[schemaKey]) {\n            key = (ref = element.data(\"formula\")) != null ? ref.replace(\"auto_number(\", \"\").replace(\")\", \"\") : void 0;\n            key = key.replace(/\\\"/g, \"\").replace(/\\'/g, \"\");\n            if (key.indexOf(\"{\") > -1) {\n              key = key.replace(\"{\", \"\").replace(\"}\", \"\");\n              key = key.trim();\n              key = AutoForm.getFieldValue(key, 'instanceform');\n            }\n            return InstanceNumberRules.instanceNumberBuilder(element, key);\n          } else {\n            return element != null ? element.val(result[schemaKey]).trigger(\"change\") : void 0;\n          }\n        });\n      }\n    });\n    judge = currentApprove.judge;\n    currentStep = InstanceManager.getCurrentStep();\n    form_version = WorkflowManager.getInstanceFormVersion();\n    if (!form_version) {\n      return;\n    }\n    if (!form_version.fields) {\n      return;\n    }\n    formula_fields = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", form_version.fields);\n    insertDoc = AutoForm.getFormValues(\"instanceform\", void 0, void 0, false);\n    Form_formula.run(\"\", \"\", formula_fields, insertDoc, form_version.fields);\n    return Session.set(\"instance_form_values\", {\n      instanceId: instance._id,\n      values: insertDoc\n    });\n  }\n};\n","InstanceAttachmentTemplate.helpers = {\n\n\tshowMainTitle: function() {\n\t\treturn Template.instance().workflowMainAttachTitle.get();\n\t},\n\tisClient: function() {\n\t\treturn Meteor.isClient\n\t},\n\tenabled_add_main_attachment: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tif (Session && Session.get(\"instancePrint\"))\n\t\t\treturn false\n\n\t\tif (Session.get(\"box\") != \"draft\" && Session.get(\"box\") != \"inbox\") {\n\t\t\treturn false\n\t\t}\n\n\t\t// 已经结束的单子不能改附件\n\t\tif (ins.state == \"completed\") {\n\t\t\treturn false\n\t\t}\n\n\t\tvar current_step = InstanceManager.getCurrentStep();\n\n\t\tif (!current_step)\n\t\t\treturn false;\n\n\t\t// cc的单子，只有在当前步骤才能修改附件\n\t\tvar approve = InstanceManager.getCurrentApprove();\n\t\tif (approve && approve.type == \"cc\") {\n\t\t\tvar currentTrace = InstanceManager.getCurrentTrace();\n\t\t\tif(currentTrace && currentTrace._id != approve.trace){\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\t// 分发的正文或者附件不显示转为pdf按钮\n\t\t// 如果有正文权限则为正文，否则分发为附件\n\t\t// 分发的附件不允许修改 删除 新增版本\n\t\tvar main_attach_count = cfs.instances.find({\n\t\t\t'metadata.instance': ins._id,\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': true\n\t\t}).count();\n\n\t\tvar distribute_main_attach_count = 0;\n\n\t\tif (ins.distribute_from_instance) {\n\t\t\tvar start_step = InstanceManager.getStartStep();\n\t\t\tif (start_step.can_edit_main_attach) {\n\t\t\t\tvar distribute_main_attach_count = cfs.instances.find({\n\t\t\t\t\t'metadata.instance': ins.distribute_from_instance,\n\t\t\t\t\t'metadata.current': true,\n\t\t\t\t\t'metadata.main': true\n\t\t\t\t}).count();\n\t\t\t}\n\t\t}\n\n\t\tif (current_step.can_edit_main_attach == true && main_attach_count < 1 && distribute_main_attach_count < 1) {\n\t\t\treturn true\n\t\t}\n\n\t\t// 正文最多只能有一个\n\t\tif (main_attach_count >= 1 || distribute_main_attach_count >= 1) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// 开始节点并且设置了可以上传正文才显示上传正文的按钮\n\t\tvar current_step = InstanceManager.getCurrentStep();\n\t\tif (current_step && current_step.step_type == \"start\" && current_step.can_edit_main_attach == true)\n\t\t\treturn true\n\n\t\treturn false\n\t},\n\n\tenabled_edit_normal_attachment: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tif (Session && Session.get(\"instancePrint\"))\n\t\t\treturn false\n\n\t\tvar flow = WorkflowManager.getFlow(ins.flow);\n\t\tif (!flow)\n\t\t\treturn false\n\n\n\t\t// 分发后的 附件，不可以编辑/删除，也不让上传新的附件, 流程列表：添加属性 ‘被分发后是否允许上传附件’ #1837\n\t\tif (ins.distribute_from_instance && !flow.upload_after_being_distributed)\n\t\t\treturn false\n\n\t\tif (Session.get(\"box\") != \"draft\" && Session.get(\"box\") != \"inbox\") {\n\t\t\treturn false\n\t\t}\n\n\t\t// 已经结束的单子不能改附件\n\t\tif (ins.state == \"completed\") {\n\t\t\treturn false\n\t\t}\n\n\t\t// cc的单子，只有在当前步骤才能修改附件\n\t\tvar approve = InstanceManager.getCurrentApprove();\n\t\tif (approve && approve.type == \"cc\") {\n\t\t\tvar currentTrace = InstanceManager.getCurrentTrace();\n\t\t\tif(currentTrace && currentTrace._id != approve.trace){\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\tif (InstanceManager.isCC(ins)) {\n\t\t\tvar step = InstanceManager.getCCStep();\n\t\t\tif (step && (step.can_edit_normal_attach == true || step.can_edit_normal_attach == undefined))\n\t\t\t\treturn true\n\t\t} else {\n\t\t\tvar current_step = InstanceManager.getCurrentStep();\n\t\t\tif (current_step && (current_step.can_edit_normal_attach == true || current_step.can_edit_normal_attach == undefined))\n\t\t\t\treturn true\n\t\t}\n\n\t\treturn false\n\t},\n\n\tmain_attachment: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tvar start_step = InstanceManager.getStartStep();\n\n\t\t// 如果是被分发的申请单并且有修改正文的权限，则优先显示原申请单文件\n\t\tvar main_attach = null;\n\t\tif (ins.distribute_from_instance && start_step.can_edit_main_attach == true) {\n\t\t\tmain_attach = cfs.instances.findOne({\n\t\t\t\t'metadata.instance': ins.distribute_from_instance,\n\t\t\t\t'metadata.current': true,\n\t\t\t\t'metadata.main': true\n\t\t\t});\n\t\t}\n\n\t\tif (!main_attach) {\n\t\t\tmain_attach = cfs.instances.findOne({\n\t\t\t\t'metadata.instance': ins._id,\n\t\t\t\t'metadata.current': true,\n\t\t\t\t'metadata.main': true\n\t\t\t});\n\t\t}\n\n\t\treturn main_attach;\n\t},\n\n\tnormal_attachments: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false\n\n\t\tvar selector = {\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': {\n\t\t\t\t$ne: true\n\t\t\t},\n\t\t};\n\n\t\tvar atts = new Array();\n\n\t\tif (ins.distribute_from_instance) {\n\t\t\t// 如果是被分发的申请单，则显示原申请单文件, 如果选择了将原表单存储为附件也要显示, 同时也要显示新上传的附件\n\t\t\tvar dfis = _.clone(ins.distribute_from_instances) || [];\n\t\t\tdfis.push(ins._id);\n\t\t\tselector['metadata.instance'] = {\n\t\t\t\t$in: dfis\n\t\t\t};\n\n\n\t\t\tselector[\"$or\"] = [{\n\t\t\t\t\"metadata.instance\": ins._id\n\t\t\t}, {\n\t\t\t\t\"metadata.instance\": {\n\t\t\t\t\t$in: ins.distribute_from_instances\n\t\t\t\t},\n\t\t\t\t\"metadata.is_private\": {\n\t\t\t\t\t$ne: true\n\t\t\t\t}\n\t\t\t}]\n\n\t\t\t// 如果原申请单有正文但是分发后没有正文权限，则原申请单正文显示在附件栏\n\t\t\tvar start_step = InstanceManager.getStartStep();\n\t\t\tif (start_step && start_step.can_edit_main_attach != true) {\n\t\t\t\tvar distribute_main = cfs.instances.findOne({\n\t\t\t\t\t'metadata.instance': {\n\t\t\t\t\t\t$in: ins.distribute_from_instances\n\t\t\t\t\t},\n\t\t\t\t\t'metadata.current': true,\n\t\t\t\t\t'metadata.main': true,\n\t\t\t\t});\n\t\t\t\tif (distribute_main) {\n\t\t\t\t\tvar firstVersionMain = cfs.instances.findOne(distribute_main.metadata.parent);\n\t\t\t\t\tdistribute_main.attachmentUploadedAt = firstVersionMain ? firstVersionMain.uploadedAt : distribute_main.uploadedAt;\n\t\t\t\t\tatts.push(distribute_main);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tselector['metadata.instance'] = ins._id;\n\t\t}\n\n\t\tcfs.instances.find(selector).forEach(function(c) {\n\t\t\tvar firstVersion = cfs.instances.findOne(c.metadata.parent);\n\t\t\tc.attachmentUploadedAt = firstVersion ? firstVersion.uploadedAt : c.uploadedAt;\n\t\t\tatts.push(c);\n\t\t})\n\n\t\treturn _.sortBy(atts, 'attachmentUploadedAt');\n\t},\n\n\tshowAttachments: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false;\n\n\t\t// 如果是被分发的申请单，则显示原申请单文件 和分发后申请单文件\n\t\tvar instanceIds = _.clone(ins.distribute_from_instances) || [];\n\t\tinstanceIds.push(ins._id);\n\t\tvar attachments_count = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true\n\t\t}).count();\n\n\t\tif (Session && Session.get(\"instancePrint\") && attachments_count < 1)\n\t\t\treturn false\n\n\t\tif (Session.get(\"box\") == \"draft\" || Session.get(\"box\") == \"inbox\" || attachments_count > 0)\n\t\t\treturn true;\n\t\telse\n\t\t\treturn false;\n\t},\n\n\t_t: function(key) {\n\t\treturn TAPi18n.__(key)\n\t},\n\n\t_: function(key) {\n\t\tvar locale;\n\t\tif (Meteor.isClient) {\n\t\t\treturn TAPi18n.__(key);\n\t\t} else {\n\t\t\tlocale = Template.instance().view.template.steedosData.locale;\n\t\t\treturn TAPi18n.__(key, {}, locale);\n\t\t}\n\t},\n\n\tflow_files: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false;\n\t\treturn cfs.files.find({ 'metadata.space': ins.space, 'metadata.object_name': 'flows', 'metadata.record_id': ins.flow });\n\t},\n\n\tisDraftAndFlowfilesExist: function() {\n\t\tvar ins = WorkflowManager.getInstance();\n\t\tif (!ins)\n\t\t\treturn false;\n\t\treturn (Session.get('box') == 'draft') && !!cfs.files.find({ 'metadata.space': ins.space, 'metadata.object_name': 'flows', 'metadata.record_id': ins.flow }).count();\n\t}\n\n\n}\n\nif (Meteor.isServer) {\n\tInstanceAttachmentTemplate.helpers._t = function(key) {\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\treturn TAPi18n.__(key, {}, locale)\n\t}\n\tInstanceAttachmentTemplate.helpers.enabled_add_main_attachment = function() {\n\t\treturn false\n\t};\n\tInstanceAttachmentTemplate.helpers.enabled_edit_normal_attachment = function() {\n\t\treturn false\n\t};\n\n\tInstanceAttachmentTemplate.helpers.main_attachment = function() {\n\t\tvar instance = Template.instance().view.template.steedosData.instance;\n\t\tvar instanceIds = _.compact([instance.distribute_from_instance, instance._id]);\n\t\tvar attachment = cfs.instances.findOne({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': true\n\t\t});\n\n\t\treturn attachment;\n\t};\n\n\tInstanceAttachmentTemplate.helpers.normal_attachments = function() {\n\t\tvar steedosData = Template.instance().view.template.steedosData\n\t\tvar instance = steedosData.instance;\n\t\tvar instanceIds = _.clone(instance.distribute_from_instances) || [];\n\t\tinstanceIds.push(instance._id);\n\t\tvar attachments = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': {\n\t\t\t\t$ne: true\n\t\t\t},\n\t\t\t$or: [{\n\t\t\t\t'metadata.is_private': {\n\t\t\t\t\t$ne: true\n\t\t\t\t}\n\t\t\t}, {\n\t\t\t\t'metadata.is_private': true,\n\t\t\t\t\"metadata.owner\": steedosData.sessionUserId || steedosData.userId || '-1' // 防止数据异常时,显示了私有附件\n\t\t\t}]\n\t\t}).fetch();\n\n\t\treturn attachments;\n\t};\n\n\tInstanceAttachmentTemplate.helpers.showAttachments = function() {\n\t\tvar instance = Template.instance().view.template.steedosData.instance;\n\t\tvar instanceIds = _.clone(instance.distribute_from_instances) || [];\n\t\tinstanceIds.push(instance._id);\n\n\t\tvar attachments = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true\n\t\t}).fetch();\n\n\t\tif (attachments && attachments.length > 0) {\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n\n\tInstanceAttachmentTemplate.helpers.showMainTitle = function() {\n\t\tvar instance = Template.instance().view.template.steedosData.instance;\n\t\tvar instanceIds = _.compact([instance.distribute_from_instance, instance._id]);\n\t\tvar main_attach_count = cfs.instances.find({\n\t\t\t'metadata.instance': {\n\t\t\t\t$in: instanceIds\n\t\t\t},\n\t\t\t'metadata.current': true,\n\t\t\t'metadata.main': true\n\t\t}).count();\n\n\t\treturn main_attach_count > 0\n\t}\n}\n","marked = require(\"marked\")\nInstanceSignText.helpers =\n\tshow: (stepName)->\n\t\tif Meteor.isClient\n\t\t\tif Session.get('instancePrint')\n\t\t\t\treturn false\n\t\t\tif InstanceManager.isInbox()\n\t\t\t\tmyApprove = InstanceManager.getCurrentApprove()\n\t\t\t\tif myApprove\n\t\t\t\t\tinstance = WorkflowManager.getInstance();\n\t\t\t\t\tmyTrace = instance?.traces?.findPropertyByPK(\"_id\", myApprove.trace)\n\t\t\t\t\treturn myTrace?.name == stepName\n\t\treturn false\n\n\tdefaultDescription: ()->\n#\t\treturn Template.instance().data.default_description || TAPi18n.__(\"instance_default_opinion\")\n\t\treturn Template.instance().data.default_description\n\n\ttraces: ()->\n\t\tInstanceformTemplate.helpers.traces()\n\n\ttrace: (stepName, only_cc_opinion, image_sign, top_keywords)->\n\t\tinstance = InstanceformTemplate.helpers.instance()\n\n\t\tis_completed = instance?.state == \"completed\"\n\n\t\tcompleted_date = if is_completed then _.last(instance.traces)?.finish_date?.getTime() else 0\n\n\t\tif is_completed && instance.finish_date\n\t\t\tcompleted_date = instance.finish_date?.getTime()\n\n\t\ttraces = InstanceformTemplate.helpers.traces()\n\n\t\tapproves = _.clone(traces[stepName])\n\n\t\tapprove_sort = (approves, top_keywords)->\n\n#对Approves排序， 按照提交时间排倒序，如果没有提交则显示在最上边\n\t\t\tapproves_sorted = _.sortBy approves, (approve)->\n\t\t\t\treturn -(approve.finish_date || new Date()).getTime()\n\n\t\t\t#通过关键字排序\n\t\t\tif top_keywords\n\t\t\t\ttop_approves = new Array()\n\n\t\t\t\ttop_keywords.split(\",\").forEach (key) ->\n\t\t\t\t\ttop_approves = _.union top_approves, _.filter(approves_sorted, (approve)->\n\t\t\t\t\t\treturn approve?.handler_name?.indexOf(key) > -1\n\t\t\t\t\t)\n\t\t\t\t# 对置顶意见按照处理事件排倒序\n\t\t\t\ttop_approves = _.sortBy top_approves, (top_approve)->\n\t\t\t\t\treturn -(top_approve.finish_date || new Date()).getTime()\n\n\t\t\t\tapproves_sorted = _.union top_approves, approves_sorted\n\t\t\treturn approves_sorted || []\n\n\t\tapproves = _.filter approves, (a)->\n\t\t\treturn a.type isnt \"forward\" and a.type isnt \"distribute\" and a.type isnt \"terminated\"\n\n\t\tif only_cc_opinion\n\t\t\tapproves = approves?.filterProperty(\"type\", \"cc\")\n\n\t\tapproves_sorted = approve_sort(approves, top_keywords)\n\n\t\tapprovesGroup = _.groupBy(approves, \"handler\");\n\n\t\thasNext = (approve, approvesGroup) ->\n\t\t\thandlerApproves = approvesGroup[approve.handler]\n\t\t\treturn _.indexOf(handlerApproves, approve) + 1 < handlerApproves.length\n\n\t\thaveDescriptionApprove = (approve, approvesGroup) ->\n\t\t\thandlerApproves = approvesGroup[approve.handler]\n\n\t\t\tdescriptionApproves = _.filter handlerApproves, (a)->\n\t\t\t\tif a.description\n\t\t\t\t\treturn true\n\t\t\t\treturn false\n\n\t\t\tif descriptionApproves.length == 0\n\t\t\t\treturn false\n\n\t\t\treturn true\n\n\n\t\tapproves_sorted.forEach (approve) ->\n#\t\t\t有输入意见 或 最新一条并且用户没有输入过意见\n#\t\t\tif !approve.is_finished || approve.description || (!hasNext(approve, approvesGroup) && !haveDescriptionApprove(approve, approvesGroup))\n#\t\t\tif !hasNext(approve, approvesGroup)\n\t\t\tif approve.sign_show != false && (approve.description || (!approve.description && !hasNext(approve, approvesGroup) && !approve.is_finished) || Meteor.settings.public.workflow?.showBlankApproveDescription)\n\t\t\t\tif approve.judge isnt 'terminated'\n\t\t\t\t\tapprove._display = true\n\n\t\tapproves_sorted = _.filter approves_sorted, (a) ->\n\t\t\tif is_completed\n\t\t\t\treturn a._display == true && a.is_finished && a.finish_date?.getTime() <= completed_date\n\t\t\telse\n\t\t\t\treturn a._display == true\n\t\treturn approves_sorted\n\n\tinclude: (a, b) ->\n\t\treturn InstanceformTemplate.helpers.include(a, b)\n\n\tunempty: (val)->\n\t\treturn InstanceformTemplate.helpers.unempty(val) || Meteor.settings.public.workflow?.showBlankApproveDescription\n\n\tformatDate: (date, options)->\n\t\tif !options\n\t\t\toptions = {\"format\": \"YYYY-MM-DD\"}\n\n\t\treturn InstanceformTemplate.helpers.formatDate(date, options)\n\n\tisMyApprove: (approve, only_cc_opinion) ->\n\t\tif Meteor.isClient\n\t\t\tif Session.get(\"box\") != 'inbox'\n\t\t\t\treturn false;\n\t\t\tins = WorkflowManager.getInstance();\n\n\t\t\tcurrentApprove = InstanceManager.getCurrentApprove()\n\n\t\t\tif !approve?._id\n\t\t\t\tapprove = currentApprove\n\n\t\t\tif approve._id == currentApprove?._id && currentApprove?.type == 'cc' && Template.instance().data.name\n\t\t\t\tif _.indexOf(currentApprove?.opinion_fields_code, Template.instance().data.name) > -1\n\t\t\t\t\treturn true\n\t\t\t\telse\n\t\t\t\t\treturn false\n\n\t\t\tif !(currentApprove?.type == 'cc') && only_cc_opinion\n\t\t\t\treturn false\n\n\t\t\tif currentApprove && approve._id == currentApprove._id\n\t\t\t\treturn true\n\t\treturn false\n\n\tmyApproveDescription: (approveId)->\n\t\tif Meteor.isClient\n\t\t\tif Session.get(\"box\") == 'inbox'\n\t\t\t\tmyApprove = Template.instance()?.myApprove?.get()\n\t\t\t\tif myApprove && myApprove.id == approveId\n\t\t\t\t\tif !myApprove.sign_field_code || myApprove.sign_field_code == Template.instance()?.data?.name\n\t\t\t\t\t\tif !Session.get(\"instance_my_approve_description\")\n\t\t\t\t\t\t\treturn myApprove?.description || \"\"\n\t\t\t\t\t\treturn Session.get(\"instance_my_approve_description\")\n\n\tnow: ()->\n\t\treturn new Date();\n\n\tisReadOnly: ()->\n\t\tif Meteor.isClient\n\t\t\treturn ApproveManager.isReadOnly()\n\t\treturn false\n\n\tisOpinionOfField: (approve)->\n\t\tif approve.type == \"cc\" && Template.instance().data.name\n\t\t\tif Template.instance().data.name == approve.sign_field_code\n\t\t\t\treturn true\n\t\t\telse\n\t\t\t\treturn false\n\t\telse\n\t\t\treturn true;\n\n\tmarkDownToHtml: (markDownString)->\n\t\tif markDownString\n\t\t\t# renderer = new Markdown.Renderer();\n\t\t\t# renderer.link = (href, title, text) ->\n\t\t\t# \treturn \"<a target='_blank' href='#{href}' title='#{title}'>#{text}</a>\"\n\t\t\tif Meteor.isServer\n\t\t\t\tmarked = Npm.require('marked')\n\t\t\treturn Spacebars.SafeString(marked.parse(markDownString))\n\n\tsteps: (field_formula, step, only_cc_opinion, image_sign)->\n\t\tsteps = []\n\t\tif !step\n\t\t\tif !field_formula\n\t\t\t\tfield_formula = WorkflowManager.getInstanceFormVersion()?.fields?.findPropertyByPK(\"code\", this.name).formula\n\t\t\tsteps = InstanceformTemplate.helpers.getOpinionFieldStepsName(field_formula, Template.instance()?.data.top_keywords)\n\t\telse\n\t\t\tsteps = [{stepName: step, only_cc_opinion: only_cc_opinion, image_sign: image_sign}]\n\t\treturn steps\n\n\timageSignData: (handler) ->\n\t\treturn {user: handler}\n\n\tshowSignImage: (handler, image_sign, judge) ->\n\t\tif ['returned', 'terminated', 'retrieved'].includes(judge)\n\t\t\treturn false\n\t\tspaceUserSign = ImageSign.helpers.spaceUserSign(handler)\n\n\t\tif spaceUserSign?.sign && image_sign\n\t\t\treturn true\n\t\telse\n\t\t\treturn false\n\n\tgetLastSignApprove: ()->\n\t\tins = WorkflowManager.getInstance();\n\n\t\treturn _.last(TracesManager.getHandlerSignShowApproves ins, Meteor.userId())\n\n\n\tlastMyApproveDescription: ()->\n\t\ttraces = InstanceformTemplate.helpers.traces()\n\t\tcurrentStep = InstanceManager.getCurrentStep();\n\t\tapproves = _.clone(traces[currentStep.name])\n\n\t\tapproves = approves.filterProperty(\"handler\", Meteor.userId())\n\n\t\tif approves.length > 1\n\t\t\treturn approves[approves.length - 2]?.description\n\n\t\treturn \"\";\n\n\tshowApprove: (approve)->\n\t\tif !approve.sign_field_code || approve.sign_field_code == Template.instance()?.data?.name\n\t\t\tif approve?.is_read\n\t\t\t\tif approve.is_finished\n\t\t\t\t\treturn [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(approve.judge)\n\t\treturn false;\n\n\tjudge_description: (judge)->\n\t\treturn t(judge + \"_description\")\n\n\tis_approved: (judge)->\n\t\treturn \"approved\" == judge\n\n\tis_rejected: (judge)->\n\t\treturn \"rejected\" == judge\n\n\tis_readed: (judge)->\n\t\treturn [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(judge)\n\n\taddClass: ()->\n\t\tname = Template.instance()?.data?.name\n\t\tsetTimeout () ->\n\t\t\ttry\n\t\t\t\telement = $(\".automatic.opinion-field-\" + name)\n\t\t\t\tif element.length > 0\n\t\t\t\t\tif element?.is(\"td\")\n\t\t\t\t\t\telement.addClass('field-editable')\n\t\t\t\t\telse\n\t\t\t\t\t\t$(\".instance-sign\", element).addClass('field-editable')\n\t\t\tcatch e\n\t\t\t\tconsole.log e\n\t\t, 1\n\t\treturn ''\n\nif Meteor.isServer\n\tInstanceSignText.helpers.defaultDescription = ->\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\treturn Template.instance().data.default_description || TAPi18n.__(\"instance_default_opinion\", {}, locale)","var marked;\n\nmarked = require(\"marked\");\n\nInstanceSignText.helpers = {\n  show: function(stepName) {\n    var instance, myApprove, myTrace, ref;\n    if (Meteor.isClient) {\n      if (Session.get('instancePrint')) {\n        return false;\n      }\n      if (InstanceManager.isInbox()) {\n        myApprove = InstanceManager.getCurrentApprove();\n        if (myApprove) {\n          instance = WorkflowManager.getInstance();\n          myTrace = instance != null ? (ref = instance.traces) != null ? ref.findPropertyByPK(\"_id\", myApprove.trace) : void 0 : void 0;\n          return (myTrace != null ? myTrace.name : void 0) === stepName;\n        }\n      }\n    }\n    return false;\n  },\n  defaultDescription: function() {\n    return Template.instance().data.default_description;\n  },\n  traces: function() {\n    return InstanceformTemplate.helpers.traces();\n  },\n  trace: function(stepName, only_cc_opinion, image_sign, top_keywords) {\n    var approve_sort, approves, approvesGroup, approves_sorted, completed_date, hasNext, haveDescriptionApprove, instance, is_completed, ref, ref1, ref2, traces;\n    instance = InstanceformTemplate.helpers.instance();\n    is_completed = (instance != null ? instance.state : void 0) === \"completed\";\n    completed_date = is_completed ? (ref = _.last(instance.traces)) != null ? (ref1 = ref.finish_date) != null ? ref1.getTime() : void 0 : void 0 : 0;\n    if (is_completed && instance.finish_date) {\n      completed_date = (ref2 = instance.finish_date) != null ? ref2.getTime() : void 0;\n    }\n    traces = InstanceformTemplate.helpers.traces();\n    approves = _.clone(traces[stepName]);\n    approve_sort = function(approves, top_keywords) {\n      var approves_sorted, top_approves;\n      approves_sorted = _.sortBy(approves, function(approve) {\n        return -(approve.finish_date || new Date()).getTime();\n      });\n      if (top_keywords) {\n        top_approves = new Array();\n        top_keywords.split(\",\").forEach(function(key) {\n          return top_approves = _.union(top_approves, _.filter(approves_sorted, function(approve) {\n            var ref3;\n            return (approve != null ? (ref3 = approve.handler_name) != null ? ref3.indexOf(key) : void 0 : void 0) > -1;\n          }));\n        });\n        top_approves = _.sortBy(top_approves, function(top_approve) {\n          return -(top_approve.finish_date || new Date()).getTime();\n        });\n        approves_sorted = _.union(top_approves, approves_sorted);\n      }\n      return approves_sorted || [];\n    };\n    approves = _.filter(approves, function(a) {\n      return a.type !== \"forward\" && a.type !== \"distribute\" && a.type !== \"terminated\";\n    });\n    if (only_cc_opinion) {\n      approves = approves != null ? approves.filterProperty(\"type\", \"cc\") : void 0;\n    }\n    approves_sorted = approve_sort(approves, top_keywords);\n    approvesGroup = _.groupBy(approves, \"handler\");\n    hasNext = function(approve, approvesGroup) {\n      var handlerApproves;\n      handlerApproves = approvesGroup[approve.handler];\n      return _.indexOf(handlerApproves, approve) + 1 < handlerApproves.length;\n    };\n    haveDescriptionApprove = function(approve, approvesGroup) {\n      var descriptionApproves, handlerApproves;\n      handlerApproves = approvesGroup[approve.handler];\n      descriptionApproves = _.filter(handlerApproves, function(a) {\n        if (a.description) {\n          return true;\n        }\n        return false;\n      });\n      if (descriptionApproves.length === 0) {\n        return false;\n      }\n      return true;\n    };\n    approves_sorted.forEach(function(approve) {\n      var ref3;\n      if (approve.sign_show !== false && (approve.description || (!approve.description && !hasNext(approve, approvesGroup) && !approve.is_finished) || ((ref3 = Meteor.settings[\"public\"].workflow) != null ? ref3.showBlankApproveDescription : void 0))) {\n        if (approve.judge !== 'terminated') {\n          return approve._display = true;\n        }\n      }\n    });\n    approves_sorted = _.filter(approves_sorted, function(a) {\n      var ref3;\n      if (is_completed) {\n        return a._display === true && a.is_finished && ((ref3 = a.finish_date) != null ? ref3.getTime() : void 0) <= completed_date;\n      } else {\n        return a._display === true;\n      }\n    });\n    return approves_sorted;\n  },\n  include: function(a, b) {\n    return InstanceformTemplate.helpers.include(a, b);\n  },\n  unempty: function(val) {\n    var ref;\n    return InstanceformTemplate.helpers.unempty(val) || ((ref = Meteor.settings[\"public\"].workflow) != null ? ref.showBlankApproveDescription : void 0);\n  },\n  formatDate: function(date, options) {\n    if (!options) {\n      options = {\n        \"format\": \"YYYY-MM-DD\"\n      };\n    }\n    return InstanceformTemplate.helpers.formatDate(date, options);\n  },\n  isMyApprove: function(approve, only_cc_opinion) {\n    var currentApprove, ins;\n    if (Meteor.isClient) {\n      if (Session.get(\"box\") !== 'inbox') {\n        return false;\n      }\n      ins = WorkflowManager.getInstance();\n      currentApprove = InstanceManager.getCurrentApprove();\n      if (!(approve != null ? approve._id : void 0)) {\n        approve = currentApprove;\n      }\n      if (approve._id === (currentApprove != null ? currentApprove._id : void 0) && (currentApprove != null ? currentApprove.type : void 0) === 'cc' && Template.instance().data.name) {\n        if (_.indexOf(currentApprove != null ? currentApprove.opinion_fields_code : void 0, Template.instance().data.name) > -1) {\n          return true;\n        } else {\n          return false;\n        }\n      }\n      if (!((currentApprove != null ? currentApprove.type : void 0) === 'cc') && only_cc_opinion) {\n        return false;\n      }\n      if (currentApprove && approve._id === currentApprove._id) {\n        return true;\n      }\n    }\n    return false;\n  },\n  myApproveDescription: function(approveId) {\n    var myApprove, ref, ref1, ref2, ref3;\n    if (Meteor.isClient) {\n      if (Session.get(\"box\") === 'inbox') {\n        myApprove = (ref = Template.instance()) != null ? (ref1 = ref.myApprove) != null ? ref1.get() : void 0 : void 0;\n        if (myApprove && myApprove.id === approveId) {\n          if (!myApprove.sign_field_code || myApprove.sign_field_code === ((ref2 = Template.instance()) != null ? (ref3 = ref2.data) != null ? ref3.name : void 0 : void 0)) {\n            if (!Session.get(\"instance_my_approve_description\")) {\n              return (myApprove != null ? myApprove.description : void 0) || \"\";\n            }\n            return Session.get(\"instance_my_approve_description\");\n          }\n        }\n      }\n    }\n  },\n  now: function() {\n    return new Date();\n  },\n  isReadOnly: function() {\n    if (Meteor.isClient) {\n      return ApproveManager.isReadOnly();\n    }\n    return false;\n  },\n  isOpinionOfField: function(approve) {\n    if (approve.type === \"cc\" && Template.instance().data.name) {\n      if (Template.instance().data.name === approve.sign_field_code) {\n        return true;\n      } else {\n        return false;\n      }\n    } else {\n      return true;\n    }\n  },\n  markDownToHtml: function(markDownString) {\n    if (markDownString) {\n      if (Meteor.isServer) {\n        marked = Npm.require('marked');\n      }\n      return Spacebars.SafeString(marked.parse(markDownString));\n    }\n  },\n  steps: function(field_formula, step, only_cc_opinion, image_sign) {\n    var ref, ref1, ref2, steps;\n    steps = [];\n    if (!step) {\n      if (!field_formula) {\n        field_formula = (ref = WorkflowManager.getInstanceFormVersion()) != null ? (ref1 = ref.fields) != null ? ref1.findPropertyByPK(\"code\", this.name).formula : void 0 : void 0;\n      }\n      steps = InstanceformTemplate.helpers.getOpinionFieldStepsName(field_formula, (ref2 = Template.instance()) != null ? ref2.data.top_keywords : void 0);\n    } else {\n      steps = [\n        {\n          stepName: step,\n          only_cc_opinion: only_cc_opinion,\n          image_sign: image_sign\n        }\n      ];\n    }\n    return steps;\n  },\n  imageSignData: function(handler) {\n    return {\n      user: handler\n    };\n  },\n  showSignImage: function(handler, image_sign, judge) {\n    var spaceUserSign;\n    if (['returned', 'terminated', 'retrieved'].includes(judge)) {\n      return false;\n    }\n    spaceUserSign = ImageSign.helpers.spaceUserSign(handler);\n    if ((spaceUserSign != null ? spaceUserSign.sign : void 0) && image_sign) {\n      return true;\n    } else {\n      return false;\n    }\n  },\n  getLastSignApprove: function() {\n    var ins;\n    ins = WorkflowManager.getInstance();\n    return _.last(TracesManager.getHandlerSignShowApproves(ins, Meteor.userId()));\n  },\n  lastMyApproveDescription: function() {\n    var approves, currentStep, ref, traces;\n    traces = InstanceformTemplate.helpers.traces();\n    currentStep = InstanceManager.getCurrentStep();\n    approves = _.clone(traces[currentStep.name]);\n    approves = approves.filterProperty(\"handler\", Meteor.userId());\n    if (approves.length > 1) {\n      return (ref = approves[approves.length - 2]) != null ? ref.description : void 0;\n    }\n    return \"\";\n  },\n  showApprove: function(approve) {\n    var ref, ref1;\n    if (!approve.sign_field_code || approve.sign_field_code === ((ref = Template.instance()) != null ? (ref1 = ref.data) != null ? ref1.name : void 0 : void 0)) {\n      if (approve != null ? approve.is_read : void 0) {\n        if (approve.is_finished) {\n          return [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(approve.judge);\n        }\n      }\n    }\n    return false;\n  },\n  judge_description: function(judge) {\n    return t(judge + \"_description\");\n  },\n  is_approved: function(judge) {\n    return \"approved\" === judge;\n  },\n  is_rejected: function(judge) {\n    return \"rejected\" === judge;\n  },\n  is_readed: function(judge) {\n    return [\"approved\", \"rejected\", \"submitted\", \"readed\"].includes(judge);\n  },\n  addClass: function() {\n    var name, ref, ref1;\n    name = (ref = Template.instance()) != null ? (ref1 = ref.data) != null ? ref1.name : void 0 : void 0;\n    setTimeout(function() {\n      var e, element;\n      try {\n        element = $(\".automatic.opinion-field-\" + name);\n        if (element.length > 0) {\n          if (element != null ? element.is(\"td\") : void 0) {\n            return element.addClass('field-editable');\n          } else {\n            return $(\".instance-sign\", element).addClass('field-editable');\n          }\n        }\n      } catch (error) {\n        e = error;\n        return console.log(e);\n      }\n    }, 1);\n    return '';\n  }\n};\n\nif (Meteor.isServer) {\n  InstanceSignText.helpers.defaultDescription = function() {\n    var locale;\n    locale = Template.instance().view.template.steedosData.locale;\n    return Template.instance().data.default_description || TAPi18n.__(\"instance_default_opinion\", {}, locale);\n  };\n}\n","marked = require(\"marked\")\nTracesTemplate.helpers =\n\ttraceShowSignImage: ()->\n\t\treturn Meteor.settings.public.workflow.traceShowSignImage != false && Meteor.settings.public.workflow.traceShowSignImage != 'false'\n\tequals: (a, b) ->\n\t\ta == b\n\tempty: (a) ->\n\t\tif a\n\t\t\ta.toString().trim().length < 1\n\t\telse\n\t\t\ttrue\n\tunempty: (a) ->\n\t\tif a\n\t\t\ta.toString().trim().length > 0\n\t\telse\n\t\t\tfalse\n\n\tappend: (a, b) ->\n\t\ta + b\n\n\tdateFormat: (date) ->\n\t\t\tif Steedos.isMobile() && date?.getFullYear() == (new Date).getFullYear()\n\t\t\t\treturn moment(date).format('MM-DD HH:mm');\n\t\t\telse\n\t\t\t\treturn moment(date).format('YYYY-MM-DD HH:mm');\n\n\tgetStepName: (stepId) ->\n\t\tstep = WorkflowManager.getInstanceStep(stepId)\n\t\tif step\n\t\t\treturn step.name\n\t\tnull\n\tshowDeleteButton: (approved) ->\n\t\tif approved and approved.type == 'cc' and approved.from_user == Meteor.userId() and approved.is_finished != true and !Session.get(\"instancePrint\")\n\t\t\treturn true\n\t\tfalse\n\tisShowModificationButton: (approved) ->\n\t\tapprove_admins = Meteor.settings?.public?.workflow?.approve_admins\n\t\tif approve_admins?.length\n\t\t\tisShow = approve_admins?.contains Meteor.userId()\n\t\tunless isShow\n\t\t\treturn false\n\t\treturn approved.handler == Meteor.userId()\n\tisEditing: () ->\n\t\t return Template.instance().is_editing?.get()\n\tisShowDescription: (approved)->\n\t\t# debugger\n\t\tif TracesTemplate.helpers.isShowModificationButton approved\n\t\t\treturn true\n\t\treturn approved.description?.toString().trim().length > 0\n\tisCC: (approved) ->\n\t\tif approved and approved.type == 'cc'\n\t\t\treturn true\n\t\tfalse\n\tgetApproveStatusIcon: (approveJudge, autoSubmitted) ->\n\t\tif autoSubmitted == true\n\t\t\treturn 'ion ion-android-alarm-clock'\n\t\t#已结束的显示为核准/驳回/取消申请，并显示处理状态图标\n\t\tapproveStatusIcon = undefined\n\t\tswitch approveJudge\n\t\t\twhen 'approved'\n\t\t\t\t# 已核准\n\t\t\t\tapproveStatusIcon = 'ion ion-checkmark-round'\n\t\t\twhen 'rejected'\n\t\t\t\t# 已驳回\n\t\t\t\tapproveStatusIcon = 'ion ion-close-round'\n\t\t\twhen 'terminated'\n\t\t\t\t# 已取消\n\t\t\t\tapproveStatusIcon = 'fa fa-ban'\n\t\t\twhen 'reassigned'\n\t\t\t\t# 转签核\n\t\t\t\tapproveStatusIcon = 'ion ion-android-contact'\n\t\t\twhen 'relocated'\n\t\t\t\t# 重定位\n\t\t\t\tapproveStatusIcon = 'ion ion-arrow-shrink'\n\t\t\twhen 'retrieved'\n\t\t\t\t# 已取回\n\t\t\t\tapproveStatusIcon = 'fa fa-undo'\n\t\t\telse\n\t\t\t\tapproveStatusIcon = ''\n\t\t\t\tbreak\n\t\tapproveStatusIcon\n\tgetApproveStatusText: (approveJudge, autoSubmitted) ->\n\t\tif Meteor.isServer\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\t\t#已结束的显示为核准/驳回/取消申请，并显示处理状态图标\n\t\tif autoSubmitted == true\n\t\t\treturn TAPi18n.__('instance_approve_timeout_auto_submitted', {}, locale)\n\t\tapproveStatusText = undefined\n\t\tswitch approveJudge\n\t\t\twhen 'approved'\n\t\t\t\t# 已核准\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State approved', {}, locale)\n\t\t\twhen 'rejected'\n\t\t\t\t# 已驳回\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State rejected', {}, locale)\n\t\t\twhen 'terminated'\n\t\t\t\t# 已取消\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State terminated', {}, locale)\n\t\t\twhen 'reassigned'\n\t\t\t\t# 转签核\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State reassigned', {}, locale)\n\t\t\twhen 'relocated'\n\t\t\t\t# 重定位\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State relocated', {}, locale)\n\t\t\twhen 'retrieved'\n\t\t\t\t# 已取回\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State retrieved', {}, locale)\n\t\t\twhen 'returned'\n\t\t\t\t# 已退回\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State returned', {}, locale)\n\t\t\twhen 'readed'\n\t\t\t\t# 已阅\n\t\t\t\tapproveStatusText = TAPi18n.__('Instance State readed', {}, locale)\n\t\t\telse\n\t\t\t\tapproveStatusText = ''\n\t\t\t\tbreak\n\t\tapproveStatusText\n\t\n\tgetApproveJudgeClass: (approveJudge, autoSubmitted) ->\n\t\tif autoSubmitted == true\n\t\t\treturn 'autoSubmitted'\n\t\treturn approveJudge\n\n\t_t: (key)->\n\t\treturn TAPi18n.__(key)\n\n\tmyApproveDescription: (approveId)->\n\t\tif Meteor.isClient\n\t\t\tif Session.get(\"box\") == 'inbox'\n\t\t\t\tmyApprove = Template.instance()?.myApprove?.get()\n\t\t\t\tif myApprove && myApprove.id == approveId\n\t\t\t\t\tif !Session.get(\"instance_my_approve_description\")\n\t\t\t\t\t\treturn myApprove?.description || \"\"\n\t\t\t\t\treturn Session.get(\"instance_my_approve_description\")\n\tisForward: (approved) ->\n\t\tif approved and approved.type == 'forward'\n\t\t\treturn true\n\t\tfalse\n\tshowForwardDeleteButton: (approve) ->\n\t\tif db.instances.find(approve.forward_instance).count() is 0\n\t\t\treturn false\n\t\tif approve and approve.type == 'forward' and approve.from_user == Meteor.userId() and !Session.get(\"instancePrint\") and approve.judge isnt 'terminated'\n\t\t\treturn true\n\t\tfalse\n\tmarkDownToHtml: (markDownString)->\n\t\tif markDownString\n\t\t\t# renderer = new Markdown.Renderer();\n\t\t\t# renderer.link = ( href, title, text ) ->\n\t\t\t# \treturn \"<a target='_blank' href='#{href}' title='#{title}'>#{text}</a>\"\n\t\t\tif Meteor.isServer\n\t\t\t\tmarked = Npm.require('marked')\n\t\t\treturn Spacebars.SafeString(marked.parse(markDownString))\n\tisDistribute: (approve) ->\n\t\tif approve and approve.type == 'distribute'\n\t\t\treturn true\n\t\tfalse\n\tshowDistributeDeleteButton: (approve) ->\n\t\tif db.instances.find(approve.forward_instance).count() is 0\n\t\t\treturn false\n\n\t\tif approve and approve.type == 'distribute' and !Session.get(\"instancePrint\") and approve.judge isnt 'terminated'\n\t\t\t# 流程管理员和系统管理员，可以执行任何情况下的文件取消分发\n\t\t\tins = db.instances.findOne({_id: approve.instance}, {fields: {flow: 1, space: 1}})\n\t\t\tif ins and ins.flow and ins.space\n\t\t\t\tif WorkflowManager.hasFlowAdminPermission(ins.flow, ins.space, Meteor.userId())\n\t\t\t\t\treturn true\n\n\t\t\tif approve.from_user == Meteor.userId()\n\t\t\t\treturn true\n\n\t\tfalse\n\n\tfinishDateSchema: () ->\n\t\tif Steedos.isAndroidOrIOS()\n\t\t\treturn new SimpleSchema({\n\t\t\t\tfinish_date: {\n\t\t\t\t\tautoform: {\n\t\t\t\t\t\ttype: \"datetime-local\"\n\t\t\t\t\t},\n\t\t\t\t\toptional: false,\n\t\t\t\t\ttype: Date\n\t\t\t\t}\n\t\t\t})\n\t\telse\n\t\t\treturn new SimpleSchema({\n\t\t\t\tfinish_date: {\n\t\t\t\t\tautoform: {\n\t\t\t\t\t\ttype: \"bootstrap-datetimepicker\"\n\t\t\t\t\t\treadonly: true\n\t\t\t\t\t\tdateTimePickerOptions:{\n\t\t\t\t\t\t\tformat: \"YYYY-MM-DD HH:mm\",\n\t\t\t\t\t\t\tignoreReadonly:true,\n\t\t\t\t\t\t\tlocale: Session.get(\"TAPi18n::loaded_lang\"),\n\t\t\t\t\t\t\twidgetPositioning:{\n\t\t\t\t\t\t\t\thorizontal: 'right'\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\toptional: false,\n\t\t\t\t\ttype: Date\n\t\t\t\t}\n\t\t\t})\n\n\tfinishDateValues: () ->\n\t\treturn {\n\t\t\tfinish_date:this.finish_date\n\t\t};\n\n\t###\n    \t此函数用于控制是否显示traces view\n    \ttrue: 显示traces view,签核历程按钮点击后是直接定位到traces view\n    \tfalse: 不显示traces view，签核历程按钮点击后,以Modal 方式显示traces view\n\t###\n\tshowTracesView: (form, form_version)->\n#\t\treturn !(InstanceManager.isTableStyle(form) && InstanceformTemplate.helpers.includesOpinionField(form, form_version))\n\n\t\tshow_modal_traces_list = db.space_settings.findOne({space: Session.get(\"spaceId\"), key: \"show_modal_traces_list\"})?.values || false\n\n\t\treturn !show_modal_traces_list\n\n\tgetInstanceStateText: (instance_id)->\n\t\tif Meteor.isServer\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\n\t\tins = db.instances.findOne({_id: instance_id}, {fields: {state: 1, is_read: 1}})\n\t\tif not ins\n\t\t\treturn TAPi18n.__('instance_deleted', {}, locale)\n\n\t\ttext = ''\n\t\tif ins.state is 'completed'\n\t\t\ttext = TAPi18n.__('completed', {}, locale)\n\t\telse if ins.state is 'pending'\n\t\t\ttext = TAPi18n.__('pending', {}, locale)\n\t\telse if ins.state is 'draft'\n\t\t\tif ins.is_read\n\t\t\t\ttext = TAPi18n.__('instance_approve_read', {}, locale)\n\t\t\telse\n\t\t\t\ttext = TAPi18n.__('instance_approve_not_yet_handled', {}, locale)\n\n\t\treturn text\n\n\tgetInstanceStateColor: (instance_id)->\n\t\tins = db.instances.findOne({_id: instance_id}, {fields: {state: 1, is_read: 1}})\n\t\tif not ins\n\t\t\treturn \"\"\n\n\t\tcla = ''\n\t\tif ins.state is 'draft'\n\t\t\tif ins.is_read\n\t\t\t\tcla = 'blue'\n\t\t\telse\n\t\t\t\tcla = 'red'\n\t\treturn cla\n\n\tfirstTrace: (index)->\n\t\treturn index is 0\n\n\tlast_distribute_from: (instance_id)->\n\t\tins = db.instances.findOne({_id: instance_id, distribute_from_instance: {$exists: true}},{fields:{created: 1, created_by: 1}})\n\t\tif ins\n\t\t\tdis_info = {}\n\t\t\tuser = {}\n\t\t\tif Meteor.isClient\n\t\t\t\tuser = UUflow_api.getNameForUser(ins.created_by)\n\t\t\telse if Meteor.isServer\n\t\t\t\tuser = db.users.findOne({_id: ins.created_by}, {fields: {name: 1}})\n\n\t\t\tif user.name\n\t\t\t\tdis_info.from_user = user._id\n\t\t\t\tdis_info.from_user_name = user.name\n\t\t\t\tdis_info.created = ins.created\n\n\t\t\tif not _.isEmpty(dis_info)\n\t\t\t\treturn dis_info\n\t\treturn\n\n\tisCCOrDistributeOrForwardTerminated: (approve)->\n\t\tif (approve.type is 'cc' or approve.type is 'distribute' or approve.type is 'forward') and approve.judge is 'terminated'\n\t\t\treturn true\n\t\treturn false\n\n\tjudgeTerminated: (judge)->\n\t\treturn judge is 'terminated'\n\n\tinstanceExists: (instance_id)->\n\t\treturn !!db.instances.find(instance_id).count()\n\n\tagentDescription: (userName)->\n\t\tif Meteor.isServer\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\tif locale.toLocaleLowerCase() == 'zh-cn'\n\t\t\t\tlocale = \"zh-CN\"\n\t\telse\n\t\t\tlocale = Session.get(\"TAPi18n::loaded_lang\")\n\n\t\treturn TAPi18n.__('process_delegation_rules_description', {userName: userName}, locale)\n\t\n\ttraceName: (instance_id, traceId)->\n\t\treturn _.find(db.instances.findOne(instance_id, {fields: {traces: 1}})?.traces, (trace)->\n\t\t\t\t\treturn trace._id ==  traceId\n\t\t)?.name\n\n\tobjectUrl: (object_name, record_id, app_id)->\n\t\treturn Creator.getObjectUrl(object_name, record_id, app_id)\n\n\thandlerDoc: (handlerId)->\n\t\tusers_can_read_cc_handler_detail_info = Meteor.settings.public?.workflow?.users_can_read_cc_handler_detail_info\n\t\tif !users_can_read_cc_handler_detail_info or !users_can_read_cc_handler_detail_info.includes(Meteor.userId())\n\t\t\treturn\n\t\tif Meteor.isClient\n\t\t\treturn UUflow_api.getContactInfoForUser(handlerId, Session.get('spaceId'))\n\t\telse if Meteor.isServer\n\t\t\treturn db.users.findOne(handlerId)\n\nif Meteor.isServer\n\tTracesTemplate.helpers.dateFormat = (date)->\n\t\tif date\n\t\t\tutcOffset = Template.instance().view.template.steedosData.utcOffset\n\t\t\treturn InstanceReadOnlyTemplate.formatDate(date, utcOffset);\n\n\tTracesTemplate.helpers._t = (key)->\n\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\treturn TAPi18n.__(key, {}, locale)\n\n\tTracesTemplate.helpers.showDeleteButton = (approved) ->\n\t\treturn false;\n\nTracesTemplate.events =\n\t'click .cc-approve-remove': (event, template) ->\n\t\tevent.stopPropagation()\n\t\tif event.currentTarget.dataset.calling * 1 != 1\n\t\t\tevent.currentTarget.dataset.calling = 1\n\t\t\t$(\"i\",event.currentTarget).addClass(\"fa-spin\")\n\t\t\tinstanceId = Session.get('instanceId')\n\t\t\tapproveId = event.target.dataset.approve\n\t\t\t# CALL 删除approve函数。\n\t\t\t$(\"body\").addClass(\"loading\")\n\t\t\tMeteor.call 'cc_remove', instanceId, approveId, (err, result) ->\n\t\t\t\t$(\"body\").removeClass(\"loading\")\n\t\t\t\tif err\n\t\t\t\t\ttoastr.error err\n\t\t\t\t\tevent.currentTarget.dataset.calling = 0\n\t\t\t\t\t$(\"i\",event.currentTarget).removeClass(\"fa-spin\")\n\t\t\t\tif result == true\n\t\t\t\t\ttoastr.success(TAPi18n.__(\"remove_cc_approve\"));\n\t\t\t\t\tif $(\".instance-trace-detail-modal\").length\n\t\t\t\t\t\tModal.hide \"instance_trace_detail_modal\"\n\t\t\t\treturn\n\t\t\treturn\n\n\t'click .instance-trace-detail-modal .btn-cc-approve-remove': (event, template) ->\n\t\tinstanceId = Session.get('instanceId')\n\t\tapproveId = event.target.dataset.approve\n\t\t# # CALL 删除approve函数。\n\t\t# $(\"body\").addClass(\"loading\")\n\t\t# Meteor.call 'cc_remove', instanceId, approveId, (err, result) ->\n\t\t# \t$(\"body\").removeClass(\"loading\")\n\t\t# \tif err\n\t\t# \t\ttoastr.error err\n\t\t# \tif result == true\n\t\t# \t\ttoastr.success(TAPi18n.__(\"remove_cc_approve\"));\n\t\t# \t\tModal.hide \"instance_trace_detail_modal\"\n\t\t# \treturn\n\t\t# return\n\t\tModal.allowMultiple = true\n\t\tModal.show 'cancel_cc_modal'\n\n\t'click .approve-item,.approve-description': (event, template) ->\n\t\t# PC上链接允许直接点开，不再打开签批历程详细\n\t\tunless $(event.target).closest(\"a.btn-link\").length\n\t\t\tModal.show \"instance_trace_detail_modal\", this\n\n\t'taphold .approve-item,.approve-description': (event, template) ->\n\t\t# 手机上长按打开签批历程详细，如果是链接长按打开后一放手窗口就又关掉了，所以不让链接打开签批历程详细\n\t\tunless $(event.target).closest(\"a.btn-link\").length\n\t\t\tModal.show \"instance_trace_detail_modal\", this\n\n\t'click .approve-item a.btn-link,.approve-description a.btn-link,.approve-item-distribute a.btn-link': (event, template) ->\n\t\t# 手机上点击链接，弹出新窗口，不支持，因为android上会弹出登录界面\n\t\tif Steedos.isMobile()\n\t\t\tuserId = event.target.dataset?.target_user_id\n\t\t\tCreator.openSafeObjectUrl('users', userId)\n\n\t'tapend .approve-item,.approve-description': (event, template) ->\n\t\t# 上述长按打开approve详细窗口的事件taphold会触发打开窗口后的touchend事件，造成长按打开窗口后一放手窗口就又关掉了\n\t\t# 这里只能通过阻止tapend事件(不可以用touchend事件，因为会影响taphold功能，造成没有长按效果时也会触发taphold事件)冒泡来避免问题。\n\t\t# 链接允许直接点开\n\t\tunless $(event.target).closest(\"a.btn-link\").length\n\t\t\tevent.stopPropagation()\n\t\t\tevent.preventDefault()\n\t\t\treturn false\n\n\t'click .instance-trace-detail-modal .btn-forward-approve-remove': (event, template) ->\n\t\tinstanceId = Session.get('instanceId')\n\t\tapproveId = event.target.dataset.approve\n\t\ttraceId = event.target.dataset.trace\n\t\t# CALL 删除approve函数。\n\t\t$(\"body\").addClass(\"loading\")\n\t\tMeteor.call 'forward_remove', instanceId, traceId, approveId, (err, result) ->\n\t\t\t$(\"body\").removeClass(\"loading\")\n\t\t\tif err\n\t\t\t\ttoastr.error TAPi18n.__(err.reason)\n\t\t\tif result == true\n\t\t\t\ttoastr.success(TAPi18n.__(\"instance_approve_forward_remove_success\"));\n\t\t\t\tModal.hide \"instance_trace_detail_modal\"\n\t\t\treturn\n\t\treturn\n\n\t'click .instance-trace-detail-modal .btn-forward-instance-look': (event, template) ->\n\t\tforward_space = event.target.dataset.forwardspace\n\t\tforward_instance = event.target.dataset.forwardinstance\n\t\tSteedos.openWindow(Steedos.absoluteUrl(\"workflow/space/\" + forward_space + \"/view/readonly/\" + forward_instance))\n\n\t'click .btn-modification'\t: (event, template) ->\n\t\ttemplate.is_editing.set(!template.is_editing.get());\n\t\tunless Steedos.isAndroidOrIOS()\n\t\t\tTracker.afterFlush ->\n\t\t\t\t# 显示日志的时候把滚动条往下移点，让日期控件显示出一部分，以避免用户看不到日期控件\n\t\t\t\t$(\"#instance_trace_detail_modal #finish_input\").on \"dp.show\", () ->\n\t\t\t\t\t$(\".modal-body\").scrollTop(100)\n\n\t'click .btn-cancelBut' : (event, template) ->\n\n\t\ttemplate.is_editing.set(!template.is_editing.get());\n\n\t'click .btn-saveBut' : (event, template) ->\n\t\t# template.is_editing.set(!template.is_editing.get())\n\n\t\tinstanceId = Session.get('instanceId')\n\t\tapproveId = event.target.dataset.approve\n\t\ttraceId = event.target.dataset.trace\n\t\topinion_input = $('#opinion_input').val()\n\t\tfinish_input = AutoForm.getFieldValue(\"finish_date\", \"finishDateAutoForm\")\n\n\t\t$(\"body\").addClass(\"loading\")\n\t\tMeteor.call 'change_approve_info', instanceId, traceId, approveId, opinion_input, finish_input, (err, result)->\n\t\t\t$(\"body\").removeClass(\"loading\")\n\t\t\tif err\n\t\t\t\ttoastr.error TAPi18n.__(err.reason)\n\t\t\tif result == true\n\t\t\t\ttoastr.success(t(\"instance_approve_modal_modificationsave\"))\n\t\t\t\tModal.hide \"instance_trace_detail_modal\"\n\t\t\treturn\n\n\t'click .instance-trace-detail-modal .btn-distribute-approve-remove': (event, template) ->\n\t\tModal.allowMultiple = true\n\t\tModal.show 'cancel_distribute_modal'\n","var marked;\n\nmarked = require(\"marked\");\n\nTracesTemplate.helpers = {\n  traceShowSignImage: function() {\n    return Meteor.settings[\"public\"].workflow.traceShowSignImage !== false && Meteor.settings[\"public\"].workflow.traceShowSignImage !== 'false';\n  },\n  equals: function(a, b) {\n    return a === b;\n  },\n  empty: function(a) {\n    if (a) {\n      return a.toString().trim().length < 1;\n    } else {\n      return true;\n    }\n  },\n  unempty: function(a) {\n    if (a) {\n      return a.toString().trim().length > 0;\n    } else {\n      return false;\n    }\n  },\n  append: function(a, b) {\n    return a + b;\n  },\n  dateFormat: function(date) {\n    if (Steedos.isMobile() && (date != null ? date.getFullYear() : void 0) === (new Date).getFullYear()) {\n      return moment(date).format('MM-DD HH:mm');\n    } else {\n      return moment(date).format('YYYY-MM-DD HH:mm');\n    }\n  },\n  getStepName: function(stepId) {\n    var step;\n    step = WorkflowManager.getInstanceStep(stepId);\n    if (step) {\n      return step.name;\n    }\n    return null;\n  },\n  showDeleteButton: function(approved) {\n    if (approved && approved.type === 'cc' && approved.from_user === Meteor.userId() && approved.is_finished !== true && !Session.get(\"instancePrint\")) {\n      return true;\n    }\n    return false;\n  },\n  isShowModificationButton: function(approved) {\n    var approve_admins, isShow, ref, ref1, ref2;\n    approve_admins = (ref = Meteor.settings) != null ? (ref1 = ref[\"public\"]) != null ? (ref2 = ref1.workflow) != null ? ref2.approve_admins : void 0 : void 0 : void 0;\n    if (approve_admins != null ? approve_admins.length : void 0) {\n      isShow = approve_admins != null ? approve_admins.contains(Meteor.userId()) : void 0;\n    }\n    if (!isShow) {\n      return false;\n    }\n    return approved.handler === Meteor.userId();\n  },\n  isEditing: function() {\n    var ref;\n    return (ref = Template.instance().is_editing) != null ? ref.get() : void 0;\n  },\n  isShowDescription: function(approved) {\n    var ref;\n    if (TracesTemplate.helpers.isShowModificationButton(approved)) {\n      return true;\n    }\n    return ((ref = approved.description) != null ? ref.toString().trim().length : void 0) > 0;\n  },\n  isCC: function(approved) {\n    if (approved && approved.type === 'cc') {\n      return true;\n    }\n    return false;\n  },\n  getApproveStatusIcon: function(approveJudge, autoSubmitted) {\n    var approveStatusIcon;\n    if (autoSubmitted === true) {\n      return 'ion ion-android-alarm-clock';\n    }\n    approveStatusIcon = void 0;\n    switch (approveJudge) {\n      case 'approved':\n        approveStatusIcon = 'ion ion-checkmark-round';\n        break;\n      case 'rejected':\n        approveStatusIcon = 'ion ion-close-round';\n        break;\n      case 'terminated':\n        approveStatusIcon = 'fa fa-ban';\n        break;\n      case 'reassigned':\n        approveStatusIcon = 'ion ion-android-contact';\n        break;\n      case 'relocated':\n        approveStatusIcon = 'ion ion-arrow-shrink';\n        break;\n      case 'retrieved':\n        approveStatusIcon = 'fa fa-undo';\n        break;\n      default:\n        approveStatusIcon = '';\n        break;\n    }\n    return approveStatusIcon;\n  },\n  getApproveStatusText: function(approveJudge, autoSubmitted) {\n    var approveStatusText, locale;\n    if (Meteor.isServer) {\n      locale = Template.instance().view.template.steedosData.locale;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    if (autoSubmitted === true) {\n      return TAPi18n.__('instance_approve_timeout_auto_submitted', {}, locale);\n    }\n    approveStatusText = void 0;\n    switch (approveJudge) {\n      case 'approved':\n        approveStatusText = TAPi18n.__('Instance State approved', {}, locale);\n        break;\n      case 'rejected':\n        approveStatusText = TAPi18n.__('Instance State rejected', {}, locale);\n        break;\n      case 'terminated':\n        approveStatusText = TAPi18n.__('Instance State terminated', {}, locale);\n        break;\n      case 'reassigned':\n        approveStatusText = TAPi18n.__('Instance State reassigned', {}, locale);\n        break;\n      case 'relocated':\n        approveStatusText = TAPi18n.__('Instance State relocated', {}, locale);\n        break;\n      case 'retrieved':\n        approveStatusText = TAPi18n.__('Instance State retrieved', {}, locale);\n        break;\n      case 'returned':\n        approveStatusText = TAPi18n.__('Instance State returned', {}, locale);\n        break;\n      case 'readed':\n        approveStatusText = TAPi18n.__('Instance State readed', {}, locale);\n        break;\n      default:\n        approveStatusText = '';\n        break;\n    }\n    return approveStatusText;\n  },\n  getApproveJudgeClass: function(approveJudge, autoSubmitted) {\n    if (autoSubmitted === true) {\n      return 'autoSubmitted';\n    }\n    return approveJudge;\n  },\n  _t: function(key) {\n    return TAPi18n.__(key);\n  },\n  myApproveDescription: function(approveId) {\n    var myApprove, ref, ref1;\n    if (Meteor.isClient) {\n      if (Session.get(\"box\") === 'inbox') {\n        myApprove = (ref = Template.instance()) != null ? (ref1 = ref.myApprove) != null ? ref1.get() : void 0 : void 0;\n        if (myApprove && myApprove.id === approveId) {\n          if (!Session.get(\"instance_my_approve_description\")) {\n            return (myApprove != null ? myApprove.description : void 0) || \"\";\n          }\n          return Session.get(\"instance_my_approve_description\");\n        }\n      }\n    }\n  },\n  isForward: function(approved) {\n    if (approved && approved.type === 'forward') {\n      return true;\n    }\n    return false;\n  },\n  showForwardDeleteButton: function(approve) {\n    if (db.instances.find(approve.forward_instance).count() === 0) {\n      return false;\n    }\n    if (approve && approve.type === 'forward' && approve.from_user === Meteor.userId() && !Session.get(\"instancePrint\") && approve.judge !== 'terminated') {\n      return true;\n    }\n    return false;\n  },\n  markDownToHtml: function(markDownString) {\n    if (markDownString) {\n      if (Meteor.isServer) {\n        marked = Npm.require('marked');\n      }\n      return Spacebars.SafeString(marked.parse(markDownString));\n    }\n  },\n  isDistribute: function(approve) {\n    if (approve && approve.type === 'distribute') {\n      return true;\n    }\n    return false;\n  },\n  showDistributeDeleteButton: function(approve) {\n    var ins;\n    if (db.instances.find(approve.forward_instance).count() === 0) {\n      return false;\n    }\n    if (approve && approve.type === 'distribute' && !Session.get(\"instancePrint\") && approve.judge !== 'terminated') {\n      ins = db.instances.findOne({\n        _id: approve.instance\n      }, {\n        fields: {\n          flow: 1,\n          space: 1\n        }\n      });\n      if (ins && ins.flow && ins.space) {\n        if (WorkflowManager.hasFlowAdminPermission(ins.flow, ins.space, Meteor.userId())) {\n          return true;\n        }\n      }\n      if (approve.from_user === Meteor.userId()) {\n        return true;\n      }\n    }\n    return false;\n  },\n  finishDateSchema: function() {\n    if (Steedos.isAndroidOrIOS()) {\n      return new SimpleSchema({\n        finish_date: {\n          autoform: {\n            type: \"datetime-local\"\n          },\n          optional: false,\n          type: Date\n        }\n      });\n    } else {\n      return new SimpleSchema({\n        finish_date: {\n          autoform: {\n            type: \"bootstrap-datetimepicker\",\n            readonly: true,\n            dateTimePickerOptions: {\n              format: \"YYYY-MM-DD HH:mm\",\n              ignoreReadonly: true,\n              locale: Session.get(\"TAPi18n::loaded_lang\"),\n              widgetPositioning: {\n                horizontal: 'right'\n              }\n            }\n          },\n          optional: false,\n          type: Date\n        }\n      });\n    }\n  },\n  finishDateValues: function() {\n    return {\n      finish_date: this.finish_date\n    };\n  },\n\n  /*\n     \t此函数用于控制是否显示traces view\n     \ttrue: 显示traces view,签核历程按钮点击后是直接定位到traces view\n     \tfalse: 不显示traces view，签核历程按钮点击后,以Modal 方式显示traces view\n   */\n  showTracesView: function(form, form_version) {\n    var ref, show_modal_traces_list;\n    show_modal_traces_list = ((ref = db.space_settings.findOne({\n      space: Session.get(\"spaceId\"),\n      key: \"show_modal_traces_list\"\n    })) != null ? ref.values : void 0) || false;\n    return !show_modal_traces_list;\n  },\n  getInstanceStateText: function(instance_id) {\n    var ins, locale, text;\n    if (Meteor.isServer) {\n      locale = Template.instance().view.template.steedosData.locale;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    ins = db.instances.findOne({\n      _id: instance_id\n    }, {\n      fields: {\n        state: 1,\n        is_read: 1\n      }\n    });\n    if (!ins) {\n      return TAPi18n.__('instance_deleted', {}, locale);\n    }\n    text = '';\n    if (ins.state === 'completed') {\n      text = TAPi18n.__('completed', {}, locale);\n    } else if (ins.state === 'pending') {\n      text = TAPi18n.__('pending', {}, locale);\n    } else if (ins.state === 'draft') {\n      if (ins.is_read) {\n        text = TAPi18n.__('instance_approve_read', {}, locale);\n      } else {\n        text = TAPi18n.__('instance_approve_not_yet_handled', {}, locale);\n      }\n    }\n    return text;\n  },\n  getInstanceStateColor: function(instance_id) {\n    var cla, ins;\n    ins = db.instances.findOne({\n      _id: instance_id\n    }, {\n      fields: {\n        state: 1,\n        is_read: 1\n      }\n    });\n    if (!ins) {\n      return \"\";\n    }\n    cla = '';\n    if (ins.state === 'draft') {\n      if (ins.is_read) {\n        cla = 'blue';\n      } else {\n        cla = 'red';\n      }\n    }\n    return cla;\n  },\n  firstTrace: function(index) {\n    return index === 0;\n  },\n  last_distribute_from: function(instance_id) {\n    var dis_info, ins, user;\n    ins = db.instances.findOne({\n      _id: instance_id,\n      distribute_from_instance: {\n        $exists: true\n      }\n    }, {\n      fields: {\n        created: 1,\n        created_by: 1\n      }\n    });\n    if (ins) {\n      dis_info = {};\n      user = {};\n      if (Meteor.isClient) {\n        user = UUflow_api.getNameForUser(ins.created_by);\n      } else if (Meteor.isServer) {\n        user = db.users.findOne({\n          _id: ins.created_by\n        }, {\n          fields: {\n            name: 1\n          }\n        });\n      }\n      if (user.name) {\n        dis_info.from_user = user._id;\n        dis_info.from_user_name = user.name;\n        dis_info.created = ins.created;\n      }\n      if (!_.isEmpty(dis_info)) {\n        return dis_info;\n      }\n    }\n  },\n  isCCOrDistributeOrForwardTerminated: function(approve) {\n    if ((approve.type === 'cc' || approve.type === 'distribute' || approve.type === 'forward') && approve.judge === 'terminated') {\n      return true;\n    }\n    return false;\n  },\n  judgeTerminated: function(judge) {\n    return judge === 'terminated';\n  },\n  instanceExists: function(instance_id) {\n    return !!db.instances.find(instance_id).count();\n  },\n  agentDescription: function(userName) {\n    var locale;\n    if (Meteor.isServer) {\n      locale = Template.instance().view.template.steedosData.locale;\n      if (locale.toLocaleLowerCase() === 'zh-cn') {\n        locale = \"zh-CN\";\n      }\n    } else {\n      locale = Session.get(\"TAPi18n::loaded_lang\");\n    }\n    return TAPi18n.__('process_delegation_rules_description', {\n      userName: userName\n    }, locale);\n  },\n  traceName: function(instance_id, traceId) {\n    var ref, ref1;\n    return (ref = _.find((ref1 = db.instances.findOne(instance_id, {\n      fields: {\n        traces: 1\n      }\n    })) != null ? ref1.traces : void 0, function(trace) {\n      return trace._id === traceId;\n    })) != null ? ref.name : void 0;\n  },\n  objectUrl: function(object_name, record_id, app_id) {\n    return Creator.getObjectUrl(object_name, record_id, app_id);\n  },\n  handlerDoc: function(handlerId) {\n    var ref, ref1, users_can_read_cc_handler_detail_info;\n    users_can_read_cc_handler_detail_info = (ref = Meteor.settings[\"public\"]) != null ? (ref1 = ref.workflow) != null ? ref1.users_can_read_cc_handler_detail_info : void 0 : void 0;\n    if (!users_can_read_cc_handler_detail_info || !users_can_read_cc_handler_detail_info.includes(Meteor.userId())) {\n      return;\n    }\n    if (Meteor.isClient) {\n      return UUflow_api.getContactInfoForUser(handlerId, Session.get('spaceId'));\n    } else if (Meteor.isServer) {\n      return db.users.findOne(handlerId);\n    }\n  }\n};\n\nif (Meteor.isServer) {\n  TracesTemplate.helpers.dateFormat = function(date) {\n    var utcOffset;\n    if (date) {\n      utcOffset = Template.instance().view.template.steedosData.utcOffset;\n      return InstanceReadOnlyTemplate.formatDate(date, utcOffset);\n    }\n  };\n  TracesTemplate.helpers._t = function(key) {\n    var locale;\n    locale = Template.instance().view.template.steedosData.locale;\n    return TAPi18n.__(key, {}, locale);\n  };\n  TracesTemplate.helpers.showDeleteButton = function(approved) {\n    return false;\n  };\n}\n\nTracesTemplate.events = {\n  'click .cc-approve-remove': function(event, template) {\n    var approveId, instanceId;\n    event.stopPropagation();\n    if (event.currentTarget.dataset.calling * 1 !== 1) {\n      event.currentTarget.dataset.calling = 1;\n      $(\"i\", event.currentTarget).addClass(\"fa-spin\");\n      instanceId = Session.get('instanceId');\n      approveId = event.target.dataset.approve;\n      $(\"body\").addClass(\"loading\");\n      Meteor.call('cc_remove', instanceId, approveId, function(err, result) {\n        $(\"body\").removeClass(\"loading\");\n        if (err) {\n          toastr.error(err);\n          event.currentTarget.dataset.calling = 0;\n          $(\"i\", event.currentTarget).removeClass(\"fa-spin\");\n        }\n        if (result === true) {\n          toastr.success(TAPi18n.__(\"remove_cc_approve\"));\n          if ($(\".instance-trace-detail-modal\").length) {\n            Modal.hide(\"instance_trace_detail_modal\");\n          }\n        }\n      });\n    }\n  },\n  'click .instance-trace-detail-modal .btn-cc-approve-remove': function(event, template) {\n    var approveId, instanceId;\n    instanceId = Session.get('instanceId');\n    approveId = event.target.dataset.approve;\n    Modal.allowMultiple = true;\n    return Modal.show('cancel_cc_modal');\n  },\n  'click .approve-item,.approve-description': function(event, template) {\n    if (!$(event.target).closest(\"a.btn-link\").length) {\n      return Modal.show(\"instance_trace_detail_modal\", this);\n    }\n  },\n  'taphold .approve-item,.approve-description': function(event, template) {\n    if (!$(event.target).closest(\"a.btn-link\").length) {\n      return Modal.show(\"instance_trace_detail_modal\", this);\n    }\n  },\n  'click .approve-item a.btn-link,.approve-description a.btn-link,.approve-item-distribute a.btn-link': function(event, template) {\n    var ref, userId;\n    if (Steedos.isMobile()) {\n      userId = (ref = event.target.dataset) != null ? ref.target_user_id : void 0;\n      return Creator.openSafeObjectUrl('users', userId);\n    }\n  },\n  'tapend .approve-item,.approve-description': function(event, template) {\n    if (!$(event.target).closest(\"a.btn-link\").length) {\n      event.stopPropagation();\n      event.preventDefault();\n      return false;\n    }\n  },\n  'click .instance-trace-detail-modal .btn-forward-approve-remove': function(event, template) {\n    var approveId, instanceId, traceId;\n    instanceId = Session.get('instanceId');\n    approveId = event.target.dataset.approve;\n    traceId = event.target.dataset.trace;\n    $(\"body\").addClass(\"loading\");\n    Meteor.call('forward_remove', instanceId, traceId, approveId, function(err, result) {\n      $(\"body\").removeClass(\"loading\");\n      if (err) {\n        toastr.error(TAPi18n.__(err.reason));\n      }\n      if (result === true) {\n        toastr.success(TAPi18n.__(\"instance_approve_forward_remove_success\"));\n        Modal.hide(\"instance_trace_detail_modal\");\n      }\n    });\n  },\n  'click .instance-trace-detail-modal .btn-forward-instance-look': function(event, template) {\n    var forward_instance, forward_space;\n    forward_space = event.target.dataset.forwardspace;\n    forward_instance = event.target.dataset.forwardinstance;\n    return Steedos.openWindow(Steedos.absoluteUrl(\"workflow/space/\" + forward_space + \"/view/readonly/\" + forward_instance));\n  },\n  'click .btn-modification': function(event, template) {\n    template.is_editing.set(!template.is_editing.get());\n    if (!Steedos.isAndroidOrIOS()) {\n      return Tracker.afterFlush(function() {\n        return $(\"#instance_trace_detail_modal #finish_input\").on(\"dp.show\", function() {\n          return $(\".modal-body\").scrollTop(100);\n        });\n      });\n    }\n  },\n  'click .btn-cancelBut': function(event, template) {\n    return template.is_editing.set(!template.is_editing.get());\n  },\n  'click .btn-saveBut': function(event, template) {\n    var approveId, finish_input, instanceId, opinion_input, traceId;\n    instanceId = Session.get('instanceId');\n    approveId = event.target.dataset.approve;\n    traceId = event.target.dataset.trace;\n    opinion_input = $('#opinion_input').val();\n    finish_input = AutoForm.getFieldValue(\"finish_date\", \"finishDateAutoForm\");\n    $(\"body\").addClass(\"loading\");\n    return Meteor.call('change_approve_info', instanceId, traceId, approveId, opinion_input, finish_input, function(err, result) {\n      $(\"body\").removeClass(\"loading\");\n      if (err) {\n        toastr.error(TAPi18n.__(err.reason));\n      }\n      if (result === true) {\n        toastr.success(t(\"instance_approve_modal_modificationsave\"));\n        Modal.hide(\"instance_trace_detail_modal\");\n      }\n    });\n  },\n  'click .instance-trace-detail-modal .btn-distribute-approve-remove': function(event, template) {\n    Modal.allowMultiple = true;\n    return Modal.show('cancel_distribute_modal');\n  }\n};\n","RelatedInstances.helpers =\n\tshowRelatedInstaces: ->\n\t\tif Meteor.isClient\n\t\t\tins = WorkflowManager.getInstance();\n\t\telse\n\t\t\tins = this.instance\n\t\tif ins?.related_instances && _.isArray(ins?.related_instances)\n\t\t\tif db.instances.find({_id: {$in: ins.related_instances}}, {fields: {space: 1, name: 1}}).count() > 0\n\t\t\t\treturn true\n\t\t\treturn false\n\t\telse\n\t\t\treturn false\n\n\trelated_instaces: ->\n\t\tif Meteor.isClient\n\t\t\tins = WorkflowManager.getInstance();\n\t\telse\n\t\t\tins = this.instance\n\t\tif ins?.related_instances && _.isArray(ins?.related_instances)\n\t\t\treturn db.instances.find({_id: {$in: ins.related_instances}}, {fields: {space: 1, name: 1}}).fetch()\n\n\trelated_instace_url: (ins) ->\n\n\t\tif Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())\n\t\t\treturn ''\n\n\t\tabsolute = false\n\n\t\tif Meteor.isServer\n\t\t\tabsolute = this.absolute\n\t\tif absolute\n\t\t\treturn Meteor.absoluteUrl(\"workflow/space/\"+ins.space+\"/view/readonly/\" + ins._id + '?hide_traces=0')\n\t\telse\n\t\t\treturn Steedos.absoluteUrl(\"workflow/space/\"+ins.space+\"/view/readonly/\" + ins._id + '?hide_traces=0')\n\n\t_t: (key)->\n\t\tif Meteor.isClient\n\t\t\treturn TAPi18n.__(key)\n\t\telse\n\t\t\tlocale = Template.instance().view.template.steedosData.locale\n\t\t\treturn TAPi18n.__(key, {}, locale)\n\n\tshow_delete: ()->\n\t\tif !Meteor.isClient\n\t\t\treturn false\n\t\telse\n\t\t\tif Session.get(\"box\") == \"draft\" || Session.get(\"box\") == 'inbox'\n\t\t\t\tcurrent_step = InstanceManager.getCurrentStep()\n\t\t\t\tif current_step\n\t\t\t\t\tif (current_step.can_edit_main_attach || current_step.can_edit_normal_attach == true || current_step.can_edit_normal_attach == undefined)\n\t\t\t\t\t\treturn true","RelatedInstances.helpers = {\n  showRelatedInstaces: function() {\n    var ins;\n    if (Meteor.isClient) {\n      ins = WorkflowManager.getInstance();\n    } else {\n      ins = this.instance;\n    }\n    if ((ins != null ? ins.related_instances : void 0) && _.isArray(ins != null ? ins.related_instances : void 0)) {\n      if (db.instances.find({\n        _id: {\n          $in: ins.related_instances\n        }\n      }, {\n        fields: {\n          space: 1,\n          name: 1\n        }\n      }).count() > 0) {\n        return true;\n      }\n      return false;\n    } else {\n      return false;\n    }\n  },\n  related_instaces: function() {\n    var ins;\n    if (Meteor.isClient) {\n      ins = WorkflowManager.getInstance();\n    } else {\n      ins = this.instance;\n    }\n    if ((ins != null ? ins.related_instances : void 0) && _.isArray(ins != null ? ins.related_instances : void 0)) {\n      return db.instances.find({\n        _id: {\n          $in: ins.related_instances\n        }\n      }, {\n        fields: {\n          space: 1,\n          name: 1\n        }\n      }).fetch();\n    }\n  },\n  related_instace_url: function(ins) {\n    var absolute;\n    if (Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())) {\n      return '';\n    }\n    absolute = false;\n    if (Meteor.isServer) {\n      absolute = this.absolute;\n    }\n    if (absolute) {\n      return Meteor.absoluteUrl(\"workflow/space/\" + ins.space + \"/view/readonly/\" + ins._id + '?hide_traces=0');\n    } else {\n      return Steedos.absoluteUrl(\"workflow/space/\" + ins.space + \"/view/readonly/\" + ins._id + '?hide_traces=0');\n    }\n  },\n  _t: function(key) {\n    var locale;\n    if (Meteor.isClient) {\n      return TAPi18n.__(key);\n    } else {\n      locale = Template.instance().view.template.steedosData.locale;\n      return TAPi18n.__(key, {}, locale);\n    }\n  },\n  show_delete: function() {\n    var current_step;\n    if (!Meteor.isClient) {\n      return false;\n    } else {\n      if (Session.get(\"box\") === \"draft\" || Session.get(\"box\") === 'inbox') {\n        current_step = InstanceManager.getCurrentStep();\n        if (current_step) {\n          if (current_step.can_edit_main_attach || current_step.can_edit_normal_attach === true || current_step.can_edit_normal_attach === void 0) {\n            return true;\n          }\n        }\n      }\n    }\n  }\n};\n","RelatedRecords.helpers =\n\tshowRelatedRecords: ()->\n\t\tif Meteor.isClient\n\t\t\tins = WorkflowManager.getInstance();\n\t\telse\n\t\t\tins = this.instance\n\t\tif !ins\n\t\t\treturn false\n\t\treturn !_.isEmpty(ins.record_ids)\n\trelatedRecordUrl: ()->\n\t\tif Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())\n\t\t\treturn ''\n\n\t\tabsolute = false\n\t\t\n\t\tif Meteor.isServer\n\t\t\tins = this.instance\n\t\t\tabsolute = this.absolute\n\t\telse\n\t\t\tins = WorkflowManager.getInstance();\n\t\n\t\tobjcetName = ins.record_ids[0].o\n\t\tid = ins.record_ids[0].ids[0]\n\n\t\tif absolute\n\t\t\treturn Meteor.absoluteUrl(\"app/-/#{objcetName}/view/#{id}\")\n\t\telse\n\t\t\treturn Steedos.absoluteUrl(\"app/-/#{objcetName}/view/#{id}\")","RelatedRecords.helpers = {\n  showRelatedRecords: function() {\n    var ins;\n    if (Meteor.isClient) {\n      ins = WorkflowManager.getInstance();\n    } else {\n      ins = this.instance;\n    }\n    if (!ins) {\n      return false;\n    }\n    return !_.isEmpty(ins.record_ids);\n  },\n  relatedRecordUrl: function() {\n    var absolute, id, ins, objcetName;\n    if (Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())) {\n      return '';\n    }\n    absolute = false;\n    if (Meteor.isServer) {\n      ins = this.instance;\n      absolute = this.absolute;\n    } else {\n      ins = WorkflowManager.getInstance();\n    }\n    objcetName = ins.record_ids[0].o;\n    id = ins.record_ids[0].ids[0];\n    if (absolute) {\n      return Meteor.absoluteUrl(\"app/-/\" + objcetName + \"/view/\" + id);\n    } else {\n      return Steedos.absoluteUrl(\"app/-/\" + objcetName + \"/view/\" + id);\n    }\n  }\n};\n","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-24 15:29:22\n * @Description: \n */\n// JsonRoutes.add(\"post\", \"/api/workflow/getSpaceUsers\", function (req, res, next) {\n//   var\n//     userIds = req.body.userIds,\n//     spaceId = req.query.spaceId,\n//     spaceUsers = []\n//   ;\n\n//   if (!userIds || !spaceId) {\n//     JsonRoutes.sendResult(res, {\n//       code: 200,\n//       data: {\n//         'errors': '缺少参数'\n//       }\n//     });\n//   }\n\n//   spaceUsers = WorkflowManager.getUsers(spaceId, userIds);\n\n//   JsonRoutes.sendResult(res, {\n//     code: 200,\n//     data: {\n//       'spaceUsers': spaceUsers\n//     }\n//   });\n// })\n\n\n  \n  ","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-24 15:23:14\n * @Description: \n */\n// JsonRoutes.add(\"post\", \"/api/workflow/getFormulaUserObjects\", function (req, res, next) {\n//   var\n//     userIds = req.body.userIds,\n//     spaceId = req.query.spaceId,\n//     spaceUsers = []\n//   ;\n\n//   if (!userIds || !spaceId) {\n//     JsonRoutes.sendResult(res, {\n//       code: 200,\n//       data: {\n//         'errors': '缺少参数'\n//       }\n//     });\n//   }\n\n//   var users = WorkflowManager.getFormulaUserObject(spaceId, userIds);\n\n//   JsonRoutes.sendResult(res, {\n//     code: 200,\n//     data: {\n//       'spaceUsers': users\n//     }\n//   });\n// })\n\n\n  \n  ","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-24 15:38:54\n * @Description: \n */\n// JsonRoutes.add(\"post\", \"/api/workflow/init_formula_values\", function(req, res, next) {\n// \tvar\n// \t\tfields = req.body.fields,\n// \t\tautoFormDoc = req.body.autoFormDoc,\n// \t\tapprover = req.body.approver,\n// \t\tapplicant = req.body.applicant,\n\n// \t\tspaceId = req.query.spaceId,\n\n// \t\tspaceUsers = [];\n\n// \tif (!fields || !spaceId || !autoFormDoc || !approver || !applicant) {\n// \t\tJsonRoutes.sendResult(res, {\n// \t\t\tcode: 200,\n// \t\t\tdata: {\n// \t\t\t\t'errors': '缺少参数'\n// \t\t\t}\n// \t\t});\n// \t\treturn;\n// \t}\n\n// \tformula_values = Form_formula.init_formula_values(fields, autoFormDoc, approver, applicant, spaceId);\n\n// \tJsonRoutes.sendResult(res, {\n// \t\tcode: 200,\n// \t\tdata: {\n// \t\t\t'formula_values': formula_values\n// \t\t}\n// \t});\n// })\n","// JsonRoutes.add('post', '/api/workflow/forward', function (req, res, next) {\n// \ttry {\n// \t\tvar current_user_info = uuflowManager.check_authorization(req);\n// \t\tvar current_user_id = current_user_info._id;\n\n// \t\tvar hashData = req.body;\n// \t\tvar instance_id = hashData.instance_id;\n// \t\tvar space_id = hashData.space_id;\n// \t\tvar flow_id = hashData.flow_id;\n// \t\tvar hasSaveInstanceToAttachment = hashData.hasSaveInstanceToAttachment;\n// \t\tvar description = hashData.description;\n// \t\tvar isForwardAttachments = hashData.isForwardAttachments;\n// \t\tvar selectedUsers = hashData.selectedUsers;\n// \t\tvar action_type = hashData.action_type;\n// \t\tvar related = hashData.related;\n// \t\tvar from_approve_id = hashData.from_approve_id;\n\n// \t\tcheck(instance_id, String);\n// \t\tcheck(space_id, String);\n// \t\tcheck(flow_id, String);\n// \t\tcheck(hasSaveInstanceToAttachment, Boolean);\n// \t\tcheck(description, String);\n// \t\tcheck(isForwardAttachments, Boolean);\n// \t\tcheck(selectedUsers, Array);\n// \t\tcheck(action_type, Match.OneOf('forward', 'distribute'));\n\n// \t\tif (action_type == \"distribute\")\n// \t\t\tcheck(from_approve_id, String);\n\n// \t\tvar ins = db.instances.findOne(instance_id);\n// \t\tvar old_space_id = ins.space;\n\n// \t\tvar flow = db.flows.findOne(flow_id);\n\n// \t\tvar space = db.spaces.findOne(space_id);\n\n// \t\tif (!ins || !flow || !space) {\n// \t\t\tthrow new Meteor.Error('params error!', 'record not exists!');\n// \t\t}\n\n// \t\tvar forward_users = new Array;\n// \t\tif (_.isEmpty(selectedUsers)) {\n// \t\t\tforward_users = [current_user_id];\n// \t\t} else {\n// \t\t\tforward_users = selectedUsers;\n// \t\t}\n\n// \t\t// 校验分发对象是否有分发流程的提交权限\n// \t\tvar no_permission_user_ids = new Array();\n// \t\t_.each(forward_users, function (uid) {\n// \t\t\tvar permissions = permissionManager.getFlowPermissions(flow_id, uid);\n// \t\t\tif (!permissions.includes(\"add\")) {\n// \t\t\t\t// throw new Meteor.Error('error!', \"该申请人没有提交此申请单的权限。\")\n// \t\t\t\tno_permission_user_ids.push(uid);\n// \t\t\t}\n// \t\t})\n// \t\tif (!_.isEmpty(no_permission_user_ids)) {\n// \t\t\tvar no_permission_users_name = new Array();\n// \t\t\tdb.users.find({\n// \t\t\t\t_id: {\n// \t\t\t\t\t$in: no_permission_user_ids\n// \t\t\t\t}\n// \t\t\t}, {\n// \t\t\t\tfields: {\n// \t\t\t\t\tname: 1\n// \t\t\t\t}\n// \t\t\t}).forEach(function (u) {\n// \t\t\t\tno_permission_users_name.push(u.name);\n// \t\t\t});\n// \t\t\tthrow new Meteor.Error('no_permission', \"该提交人没有提交此申请单的权限。\", no_permission_users_name.join(','))\n// \t\t}\n\n// \t\tvar new_ins_ids = new Array;\n\n// \t\tvar current_trace = null;\n// \t\tif (action_type == \"distribute\") {\n// \t\t\t_.each(ins.traces, function (t) {\n// \t\t\t\tif (!current_trace) {\n// \t\t\t\t\t_.each(t.approves, function (a) {\n// \t\t\t\t\t\tif (!current_trace) {\n// \t\t\t\t\t\t\tif (a._id == from_approve_id)\n// \t\t\t\t\t\t\t\tcurrent_trace = t;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t}\n// \t\t\t})\n// \t\t} else {\n// \t\t\tcurrent_trace = _.last(ins.traces);\n// \t\t}\n// \t\tvar current_trace_id = current_trace._id;\n// \t\tvar forward_approves = [];\n// \t\tvar from_user_name = db.users.findOne(current_user_id, {\n// \t\t\tfields: {\n// \t\t\t\tname: 1\n// \t\t\t}\n// \t\t}).name\n// \t\tvar set_obj = new Object;\n\n// \t\t// 计算values\n// \t\tvar old_values = ins.values,\n// \t\t\tnew_values = {};\n// \t\tvar form = db.forms.findOne(flow.form);\n// \t\tvar fields = form.current.fields || [];\n\n// \t\tvar old_form = db.forms.findOne(ins.form);\n// \t\tvar old_form_version = ins.form_version,\n// \t\t\told_fields = [],\n// \t\t\tcommon_fields = [];\n\n// \t\tvar select_to_input_fields = [];\n\n// \t\tif (old_form.current._id == old_form_version) {\n// \t\t\told_fields = old_form.current.fields;\n// \t\t} else {\n// \t\t\tif (old_form.historys) {\n// \t\t\t\told_form.historys.forEach(function (h) {\n// \t\t\t\t\tif (h._id == old_form_version)\n// \t\t\t\t\t\told_fields = h.fields;\n// \t\t\t\t})\n// \t\t\t}\n// \t\t}\n\n// \t\tfields.forEach(function (field) {\n// \t\t\tvar exists_field = _.find(old_fields, function (f) {\n// \t\t\t\treturn f.type == field.type && f.code == field.code;\n// \t\t\t})\n// \t\t\tif (exists_field)\n// \t\t\t\tcommon_fields.push(field);\n// \t\t\tvar select_input_field = _.find(old_fields, function (f) {\n// \t\t\t\treturn f.type == 'select' && field.type == 'input' && f.code == field.code;\n// \t\t\t})\n// \t\t\tif (select_input_field)\n// \t\t\t\tselect_to_input_fields.push(select_input_field);\n// \t\t})\n\n// \t\tselect_to_input_fields.forEach(function (field) {\n// \t\t\tif (old_values[field.code]) {\n// \t\t\t\tnew_values[field.code] = old_values[field.code];\n// \t\t\t}\n// \t\t})\n\n// \t\tcommon_fields.forEach(function (field) {\n// \t\t\tif (field.type == 'section') {\n// \t\t\t\tif (field.fields) {\n// \t\t\t\t\tfield.fields.forEach(function (f) {\n// \t\t\t\t\t\t// 跨工作区转发不复制选人选组\n// \t\t\t\t\t\tif (['group', 'user'].includes(f.type) && old_space_id != space_id) {\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t\tvar key = f.code;\n// \t\t\t\t\t\tvar old_v = old_values[key];\n// \t\t\t\t\t\tif (old_v) {\n// \t\t\t\t\t\t\tvar fieldOptions = f.options && f.options.split && f.options.split(\"\\n\").map(function(n){\n// \t\t\t\t\t\t\t\tvar itemSplits = n.split(\":\");\n// \t\t\t\t\t\t\t\treturn {\n// \t\t\t\t\t\t\t\t\tlabel: itemSplits[0],\n// \t\t\t\t\t\t\t\t\tvalue: itemSplits[1] || n\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t// 校验 单选，多选，下拉框 字段值是否在新表单对应字段的可选值范围内\n// \t\t\t\t\t\t\tif (f.type == 'select' || f.type == 'radio') {\n// \t\t\t\t\t\t\t\tvar selectedOption = fieldOptions.find(function(item) {\n// \t\t\t\t\t\t\t\t\treturn item.value === old_v;\n// \t\t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t\tif(!selectedOption){\n// \t\t\t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\tif (f.type == 'multiSelect') {\n// \t\t\t\t\t\t\t\tvar old_multiSelected = old_v.split(',');\n// \t\t\t\t\t\t\t\tvar new_multiSelected = _.intersection(fieldOptions.map(function(n){ return n.value; }), old_multiSelected);\n// \t\t\t\t\t\t\t\told_v = new_multiSelected.join(',');\n// \t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\tnew_values[key] = old_v;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t}\n// \t\t\t} else if (field.type == 'table') {\n// \t\t\t\tif (!_.isEmpty(old_values[field.code])) {\n// \t\t\t\t\tnew_values[field.code] = new Array;\n// \t\t\t\t\told_values[field.code].forEach(function (old_table_row_values) {\n// \t\t\t\t\t\tvar new_table_row_values = {};\n\n// \t\t\t\t\t\tif (!_.isEmpty(field.fields)) {\n// \t\t\t\t\t\t\tfield.fields.forEach(function (f) {\n// \t\t\t\t\t\t\t\t// 跨工作区转发不复制选人选组\n// \t\t\t\t\t\t\t\tif (['group', 'user'].includes(f.type) && old_space_id != space_id) {\n// \t\t\t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t\tvar key = f.code;\n// \t\t\t\t\t\t\t\tvar old_v = old_table_row_values[key];\n// \t\t\t\t\t\t\t\tif (old_v) {\n// \t\t\t\t\t\t\t\t\tvar fieldOptions = f.options && f.options.split && f.options.split(\"\\n\").map(function(n){\n// \t\t\t\t\t\t\t\t\t\tvar itemSplits = n.split(\":\");\n// \t\t\t\t\t\t\t\t\t\treturn {\n// \t\t\t\t\t\t\t\t\t\t\tlabel: itemSplits[0],\n// \t\t\t\t\t\t\t\t\t\t\tvalue: itemSplits[1] || n\n// \t\t\t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t\t\t// 校验 单选，多选，下拉框 字段值是否在新表单对应字段的可选值范围内\n// \t\t\t\t\t\t\t\t\tif (f.type == 'select' || f.type == 'radio') {\n// \t\t\t\t\t\t\t\t\t\tvar selectedOption = fieldOptions.find(function(item) {\n// \t\t\t\t\t\t\t\t\t\t\treturn item.value === old_v;\n// \t\t\t\t\t\t\t\t\t\t});\n// \t\t\t\t\t\t\t\t\t\tif(!selectedOption){\n// \t\t\t\t\t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\t\t\tif (f.type == 'multiSelect') {\n// \t\t\t\t\t\t\t\t\t\tvar old_multiSelected = old_v.split(',');\n// \t\t\t\t\t\t\t\t\t\tvar new_multiSelected = _.intersection(fieldOptions.map(function(n){ return n.value; }), old_multiSelected);\n// \t\t\t\t\t\t\t\t\t\told_v = new_multiSelected.join(',');\n// \t\t\t\t\t\t\t\t\t}\n\n// \t\t\t\t\t\t\t\t\tnew_table_row_values[key] = old_v;\n// \t\t\t\t\t\t\t\t}\n// \t\t\t\t\t\t\t})\n// \t\t\t\t\t\t}\n\n// \t\t\t\t\t\tif (old_table_row_values._id) {\n// \t\t\t\t\t\t\tnew_table_row_values._id = new Mongo.ObjectID()._str;\n// \t\t\t\t\t\t}\n\n// \t\t\t\t\t\tif (!_.isEmpty(new_table_row_values)) {\n// \t\t\t\t\t\t\tnew_values[field.code].push(new_table_row_values);\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t}\n// \t\t\t} else {\n// \t\t\t\t// 跨工作区转发不复制选人选组\n// \t\t\t\tif (['group', 'user'].includes(field.type) && old_space_id != space_id) {\n// \t\t\t\t\treturn;\n// \t\t\t\t}\n// \t\t\t\tvar key = field.code;\n// \t\t\t\tvar old_v = old_values[key];\n// \t\t\t\tif (old_v) {\n// \t\t\t\t\t// 校验 单选，多选，下拉框 字段值是否在新表单对应字段的可选值范围内\n// \t\t\t\t\tvar fieldOptions = field.options && field.options.split && field.options.split(\"\\n\").map(function(n){\n// \t\t\t\t\t\tvar itemSplits = n.split(\":\");\n// \t\t\t\t\t\treturn {\n// \t\t\t\t\t\t\tlabel: itemSplits[0],\n// \t\t\t\t\t\t\tvalue: itemSplits[1] || n\n// \t\t\t\t\t\t}\n// \t\t\t\t\t});\n// \t\t\t\t\tif (field.type == 'select' || field.type == 'radio') {\n// \t\t\t\t\t\tvar selectedOption = fieldOptions.find(function(item) {\n// \t\t\t\t\t\t\treturn item.value === old_v;\n// \t\t\t\t\t\t});\n// \t\t\t\t\t\tif(!selectedOption){\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t}\n\n// \t\t\t\t\tif (field.type == 'multiSelect') {\n// \t\t\t\t\t\tvar old_multiSelected = old_v.split(',');\n// \t\t\t\t\t\tvar new_multiSelected = _.intersection(fieldOptions.map(function(n){ return n.value; }), old_multiSelected);\n// \t\t\t\t\t\told_v = new_multiSelected.join(',');\n// \t\t\t\t\t}\n\n// \t\t\t\t\tnew_values[key] = old_v;\n// \t\t\t\t}\n// \t\t\t}\n\n// \t\t})\n\n// \t\t//如果是分发，则value中的record_need、FONDSID不需要分发到新申请单中\n// \t\tif (action_type === 'distribute') {\n// \t\t\tdelete new_values.record_need;\n// \t\t\tdelete new_values.FONDSID;\n// \t\t}\n\n// \t\t// 计算申请单标题\n// \t\tvar instance_name = \"\";\n// \t\tvar name_forumla = form.current.name_forumla;\n// \t\tif (name_forumla) {\n// \t\t\ttry {\n// \t\t\t\tvar iscript = name_forumla.replace(/\\{/g, \"(new_values['\").replace(/\\}/g, \"'] || '')\");\n// \t\t\t\tvar rev = eval(iscript);\n// \t\t\t\tinstance_name = rev || flow.name;\n// \t\t\t} catch (error) {\n// \t\t\t\tthrow new Meteor.Error('caculate_instance_name', \"计算申请单标题出错请检查表单标题脚本。\");\n// \t\t\t}\n// \t\t} else {\n// \t\t\tinstance_name = flow.name;\n// \t\t}\n\n// \t\t// instance中记录当前步骤名称 #1314\n// \t\tvar start_step = _.find(flow.current.steps, function (step) {\n// \t\t\treturn step.step_type == 'start';\n// \t\t})\n\n// \t\t// 流程转发功能修改为，开始节点有编辑权限的字段的值进行复制，无编辑权限的字段值不进行复制 #3748\n// \t\tif (action_type === 'forward') {\n// \t\t\tnew_values = uuflowManager.getApproveValues(new_values, start_step.permissions, flow.form, flow.current.form_version);\n// \t\t}\n\n// \t\t// 新建申请单时，instances记录流程名称、流程分类名称 #1313\n// \t\tvar category_name = \"\";\n// \t\tif (form.category) {\n// \t\t\tvar category = uuflowManager.getCategory(form.category);\n// \t\t\tif (category)\n// \t\t\t\tcategory_name = category.name;\n// \t\t}\n\n// \t\t_.each(forward_users, function (user_id) {\n\n// \t\t\tvar user_info = db.users.findOne(user_id);\n\n// \t\t\tvar space_user = db.space_users.findOne({\n// \t\t\t\tspace: space_id,\n// \t\t\t\tuser: user_id\n// \t\t\t}, {\n// \t\t\t\tfields: {\n// \t\t\t\t\torganization: 1\n// \t\t\t\t}\n// \t\t\t});\n// \t\t\tvar space_user_org_info = db.organizations.findOne({\n// \t\t\t\t_id: space_user.organization\n// \t\t\t}, {\n// \t\t\t\tfields: {\n// \t\t\t\t\tname: 1,\n// \t\t\t\t\tfullname: 1\n// \t\t\t\t}\n// \t\t\t});\n\n// \t\t\tvar now = new Date();\n// \t\t\tvar ins_obj = {};\n\n// \t\t\tvar agent = uuflowManager.getAgent(space_id, user_id);\n// \t\t\tvar handler_id = user_id;\n// \t\t\tvar handler_info = user_info;\n// \t\t\tvar handler_space_user = space_user;\n// \t\t\tvar handler_org_info = space_user_org_info;\n// \t\t\tif (agent) {\n// \t\t\t\thandler_id = agent;\n// \t\t\t\thandler_info = db.users.findOne(agent);\n// \t\t\t\thandler_space_user = uuflowManager.getSpaceUser(space_id, agent);\n// \t\t\t\thandler_org_info = uuflowManager.getSpaceUserOrgInfo(handler_space_user);\n// \t\t\t}\n// \t\t\tins_obj._id = db.instances._makeNewID();\n// \t\t\tins_obj.space = space_id;\n// \t\t\tins_obj.flow = flow_id;\n// \t\t\tins_obj.flow_version = flow.current._id;\n// \t\t\tins_obj.form = flow.form;\n// \t\t\tins_obj.form_version = flow.current.form_version;\n// \t\t\tins_obj.name = instance_name;\n// \t\t\tins_obj.submitter = handler_id;\n// \t\t\tins_obj.submitter_name = handler_info.name;\n// \t\t\tins_obj.applicant = user_id;\n// \t\t\tins_obj.applicant_name = user_info.name;\n// \t\t\tins_obj.applicant_organization = space_user.organization;\n// \t\t\tins_obj.applicant_organization_name = space_user_org_info.name;\n// \t\t\tins_obj.applicant_organization_fullname = space_user_org_info.fullname;\n// \t\t\tins_obj.state = \"draft\";\n// \t\t\tins_obj.code = \"\";\n// \t\t\tins_obj.is_archived = false;\n// \t\t\tins_obj.is_deleted = false;\n// \t\t\tins_obj.created = now;\n// \t\t\tins_obj.created_by = current_user_id;\n// \t\t\tins_obj.modified = now;\n// \t\t\tins_obj.modified_by = current_user_id;\n// \t\t\tins_obj.inbox_users = [handler_id];\n// \t\t\tins_obj.values = new_values;\n// \t\t\tif (action_type == 'distribute') {\n// \t\t\t\t// 解决多次分发看不到正文、附件问题\n// \t\t\t\tif (ins.distribute_from_instance) {\n// \t\t\t\t\tins_obj.distribute_from_instance = ins.distribute_from_instance;\n// \t\t\t\t} else {\n// \t\t\t\t\tins_obj.distribute_from_instance = instance_id;\n// \t\t\t\t}\n// \t\t\t\tins_obj.distribute_from_instances = _.clone(ins.distribute_from_instances) || [];\n// \t\t\t\tins_obj.distribute_from_instances.push(instance_id);\n\n// \t\t\t\tif (related) {\n// \t\t\t\t\tins_obj.related_instances = [instance_id]\n// \t\t\t\t}\n\n// \t\t\t} else if (action_type == 'forward') {\n// \t\t\t\tins_obj.forward_from_instance = instance_id\n// \t\t\t}\n\n// \t\t\t// 新建Trace\n// \t\t\tvar trace_obj = {};\n// \t\t\ttrace_obj._id = new Mongo.ObjectID()._str;\n// \t\t\ttrace_obj.instance = ins_obj._id;\n// \t\t\ttrace_obj.is_finished = false;\n\n// \t\t\t// 当前最新版flow中开始节点的step_id\n// \t\t\tvar step_id, step_name, can_edit_main_attach, can_edit_normal_attach;\n// \t\t\tflow.current.steps.forEach(function (step) {\n// \t\t\t\tif (step.step_type == \"start\") {\n// \t\t\t\t\tstep_id = step._id;\n// \t\t\t\t\tstep_name = step.name;\n// \t\t\t\t\tcan_edit_main_attach = step.can_edit_main_attach;\n// \t\t\t\t\tcan_edit_normal_attach = step.can_edit_normal_attach;\n// \t\t\t\t}\n// \t\t\t})\n// \t\t\ttrace_obj.step = step_id;\n// \t\t\ttrace_obj.start_date = now;\n// \t\t\ttrace_obj.name = step_name;\n\n// \t\t\t// 新建Approve\n// \t\t\tvar appr_obj = {};\n// \t\t\tappr_obj._id = new Mongo.ObjectID()._str;\n// \t\t\tappr_obj.instance = ins_obj._id;\n// \t\t\tappr_obj.trace = trace_obj._id;\n// \t\t\tappr_obj.is_finished = false;\n// \t\t\tappr_obj.user = user_id;\n// \t\t\tappr_obj.user_name = user_info.name;\n// \t\t\tappr_obj.handler = handler_id;\n// \t\t\tappr_obj.handler_name = handler_info.name;\n// \t\t\tappr_obj.handler_organization = handler_space_user.organization;\n// \t\t\tappr_obj.handler_organization_name = handler_org_info.name;\n// \t\t\tappr_obj.handler_organization_fullname = handler_org_info.fullname;\n// \t\t\tappr_obj.type = \"draft\";\n// \t\t\tappr_obj.start_date = now;\n// \t\t\tappr_obj.read_date = now;\n// \t\t\tappr_obj.is_read = false;\n// \t\t\tappr_obj.is_error = false;\n\n// \t\t\tappr_obj.values = new_values;\n\n// \t\t\tif (agent) {\n// \t\t\t\tappr_obj.agent = agent;\n// \t\t\t}\n\n// \t\t\ttrace_obj.approves = [appr_obj];\n// \t\t\tins_obj.traces = [trace_obj];\n\n// \t\t\tif (flow.auto_remind == true)\n// \t\t\t\tins_obj.auto_remind = true;\n\n// \t\t\tins_obj.current_step_name = start_step.name;\n\n// \t\t\tins_obj.flow_name = flow.name;\n// \t\t\tif (category_name) {\n// \t\t\t\tins_obj.category_name = category.name;\n// \t\t\t\tins_obj.category = category._id;\n// \t\t\t}\n\n// \t\t\tnew_ins_id = db.instances.insert(ins_obj);\n\n// \t\t\t// 复制附件\n// \t\t\tvar collection = cfs.instances;\n\n// \t\t\t//将原表单内容存储为第一个附件\n// \t\t\tif (hasSaveInstanceToAttachment) {\n// \t\t\t\t// try {\n\n// \t\t\t\tinstanceHtml = InstanceReadOnlyTemplate.getInstanceHtml(user_info, space_id, ins, {\n// \t\t\t\t\tabsolute: true,\n// \t\t\t\t\tshowTrace: true\n// \t\t\t\t})\n// \t\t\t\tvar instanceFile = new FS.File();\n// \t\t\t\tinstanceFile.attachData(Buffer.from(instanceHtml, \"utf-8\"), {\n// \t\t\t\t\ttype: \"text/html\"\n// \t\t\t\t}, function (error) {\n// \t\t\t\t\tif (error) {\n// \t\t\t\t\t\tthrow new Meteor.Error(error.error, error.reason);\n// \t\t\t\t\t}\n\n// \t\t\t\t\tinstanceFile.name(ins.name + \".html\");\n// \t\t\t\t\tinstanceFile.size(instanceHtml.length);\n\n// \t\t\t\t\tvar metadata = {\n// \t\t\t\t\t\towner: user_id,\n// \t\t\t\t\t\towner_name: user_info.name,\n// \t\t\t\t\t\tspace: space_id,\n// \t\t\t\t\t\tinstance: new_ins_id,\n// \t\t\t\t\t\tapprove: appr_obj._id,\n// \t\t\t\t\t\tcurrent: true\n// \t\t\t\t\t};\n// \t\t\t\t\tinstanceFile.metadata = metadata;\n// \t\t\t\t\tvar fileObj = collection.insert(instanceFile);\n// \t\t\t\t\tfileObj.update({\n// \t\t\t\t\t\t$set: {\n// \t\t\t\t\t\t\t'metadata.parent': fileObj._id\n// \t\t\t\t\t\t}\n// \t\t\t\t\t})\n// \t\t\t\t})\n\n// \t\t\t\t// } catch (e) {\n// \t\t\t\t//     console.error(e);\n// \t\t\t\t// }\n// \t\t\t}\n\n// \t\t\tif (isForwardAttachments && action_type == 'forward') {\n// \t\t\t\tvar files = collection.find({\n// \t\t\t\t\t'metadata.instance': instance_id,\n// \t\t\t\t\t'metadata.current': true\n// \t\t\t\t});\n// \t\t\t\tfiles.forEach(function (f) {\n// \t\t\t\t\t// 判断新的流程开始节点是否有编辑正文和编辑附件权限\n// \t\t\t\t\tif (f.metadata.main == true) {\n// \t\t\t\t\t\tif (can_edit_main_attach != true && can_edit_normal_attach != true)\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t} else {\n// \t\t\t\t\t\tif (can_edit_normal_attach != true)\n// \t\t\t\t\t\t\treturn;\n// \t\t\t\t\t}\n\n// \t\t\t\t\tvar newFile = new FS.File();\n// \t\t\t\t\tnewFile.attachData(f.createReadStream('instances'), {\n// \t\t\t\t\t\ttype: f.original.type\n// \t\t\t\t\t}, function (err) {\n// \t\t\t\t\t\tif (err) {\n// \t\t\t\t\t\t\tthrow new Meteor.Error(err.error, err.reason);\n// \t\t\t\t\t\t}\n// \t\t\t\t\t\tnewFile.name(f.name());\n// \t\t\t\t\t\tnewFile.size(f.size());\n// \t\t\t\t\t\tvar metadata = {\n// \t\t\t\t\t\t\towner: user_id,\n// \t\t\t\t\t\t\towner_name: user_info.name,\n// \t\t\t\t\t\t\tspace: space_id,\n// \t\t\t\t\t\t\tinstance: new_ins_id,\n// \t\t\t\t\t\t\tapprove: appr_obj._id,\n// \t\t\t\t\t\t\tcurrent: true\n// \t\t\t\t\t\t};\n// \t\t\t\t\t\tif (f.metadata.main == true && can_edit_main_attach == true) {\n// \t\t\t\t\t\t\tmetadata.main = true;\n// \t\t\t\t\t\t}\n// \t\t\t\t\t\tnewFile.metadata = metadata;\n// \t\t\t\t\t\tvar fileObj = collection.insert(newFile);\n// \t\t\t\t\t\tfileObj.update({\n// \t\t\t\t\t\t\t$set: {\n// \t\t\t\t\t\t\t\t'metadata.parent': fileObj._id\n// \t\t\t\t\t\t\t}\n// \t\t\t\t\t\t})\n// \t\t\t\t\t})\n\n// \t\t\t\t})\n// \t\t\t}\n\n// \t\t\tif (action_type === 'distribute') {\n// \t\t\t\t// 给当前的申请单增加分发记录\n// \t\t\t\tvar appr = {\n// \t\t\t\t\t'_id': new Mongo.ObjectID()._str,\n// \t\t\t\t\t'instance': instance_id,\n// \t\t\t\t\t'trace': current_trace_id,\n// \t\t\t\t\t'is_finished': true,\n// \t\t\t\t\t'user': user_id,\n// \t\t\t\t\t'user_name': user_info.name,\n// \t\t\t\t\t'handler': user_id,\n// \t\t\t\t\t'handler_name': user_info.name,\n// \t\t\t\t\t'handler_organization': space_user.organization,\n// \t\t\t\t\t'handler_organization_name': space_user_org_info.name,\n// \t\t\t\t\t'handler_organization_fullname': space_user_org_info.fullname,\n// \t\t\t\t\t'type': action_type,\n// \t\t\t\t\t'start_date': new Date(),\n// \t\t\t\t\t'finish_date': new Date(),\n// \t\t\t\t\t'is_read': false,\n// \t\t\t\t\t'judge': 'submitted',\n// \t\t\t\t\t'from_user': current_user_id,\n// \t\t\t\t\t'from_user_name': from_user_name,\n// \t\t\t\t\t'forward_space': space_id,\n// \t\t\t\t\t'forward_instance': new_ins_id,\n// \t\t\t\t\t'description': description,\n// \t\t\t\t\t'from_approve_id': from_approve_id\n// \t\t\t\t};\n\n// \t\t\t\tforward_approves.push(appr);\n// \t\t\t}\n\n// \t\t\tnew_ins_ids.push(new_ins_id);\n// \t\t\tpushManager.send_message_to_specifyUser(\"current_user\", user_id);\n// \t\t})\n\n// \t\tif (!_.isEmpty(forward_approves)) {\n// \t\t\tset_obj.modified = new Date();\n// \t\t\tset_obj.modified_by = current_user_id;\n// \t\t\tvar r = db.instances.update({\n// \t\t\t\t_id: instance_id,\n// \t\t\t\t\"traces._id\": current_trace_id\n// \t\t\t}, {\n// \t\t\t\t$set: set_obj,\n// \t\t\t\t$addToSet: {\n// \t\t\t\t\t'traces.$.approves': {\n// \t\t\t\t\t\t$each: forward_approves\n// \t\t\t\t\t}\n// \t\t\t\t}\n// \t\t\t});\n// \t\t}\n\n\n// \t\tif (r) {\n// \t\t\t_.each(current_trace.approves, function (a, idx) {\n// \t\t\t\tif (a._id == from_approve_id) {\n// \t\t\t\t\tvar update_read = {};\n// \t\t\t\t\tupdate_read[\"traces.$.approves.\" + idx + \".read_date\"] = new Date();\n// \t\t\t\t\tdb.instances.update({\n// \t\t\t\t\t\t_id: instance_id,\n// \t\t\t\t\t\t\"traces._id\": current_trace_id\n// \t\t\t\t\t}, {\n// \t\t\t\t\t\t$set: update_read\n// \t\t\t\t\t});\n// \t\t\t\t}\n// \t\t\t})\n\n// \t\t}\n\n// \t\tJsonRoutes.sendResult(res, {\n// \t\t\tcode: 200,\n// \t\t\tdata: { new_ins_ids: new_ins_ids }\n// \t\t})\n// \t} catch (e) {\n// \t\tconsole.error(e.stack)\n// \t\tJsonRoutes.sendResult(res, {\n// \t\t\tcode: 200,\n// \t\t\tdata: {\n// \t\t\t\terrors: [e]\n// \t\t\t}\n// \t\t})\n// \t}\n\n// })","if process.env.CREATOR_NODE_ENV == 'development'\n    JsonRoutes.add 'post', '/test/webhook', (req, res, next) ->\n        try\n\n            hashData = req.body\n            console.log 'action: ', hashData.action\n            console.log 'from_user: ', hashData.from_user\n            console.log 'to_users: ', hashData.to_users\n\n\n            JsonRoutes.sendResult res,\n                    code: 200\n                    data: {}\n        catch e\n            console.error e.stack\n            JsonRoutes.sendResult res,\n                code: 200\n                data: { errors: [{errorMessage: e.message}] }","if (process.env.CREATOR_NODE_ENV === 'development') {\n  JsonRoutes.add('post', '/test/webhook', function(req, res, next) {\n    var e, hashData;\n    try {\n      hashData = req.body;\n      console.log('action: ', hashData.action);\n      console.log('from_user: ', hashData.from_user);\n      console.log('to_users: ', hashData.to_users);\n      return JsonRoutes.sendResult(res, {\n        code: 200,\n        data: {}\n      });\n    } catch (error) {\n      e = error;\n      console.error(e.stack);\n      return JsonRoutes.sendResult(res, {\n        code: 200,\n        data: {\n          errors: [\n            {\n              errorMessage: e.message\n            }\n          ]\n        }\n      });\n    }\n  });\n}\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tset_instance_step_approve: (ins_id, step_approve, stepsApprovesOptions)->\n\t\treturn workflowMethods.set_instance_step_approve.apply(this, arguments)\n\tset_instance_skip_steps: (ins_id, stepId, action)->\n\t\treturn workflowMethods.set_instance_skip_steps.apply(this, arguments)","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-22 15:18:59\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\n\tget_instance_data: function (instance_id, formCached, flowCached) {\n\t\treturn workflowMethods.get_instance_data.apply(this, arguments)\n\t}\n\n});\n","const { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\n\tdraft_save_instance: function (ins) {\n\t\treturn workflowMethods.draft_save_instance.apply(this, arguments)\n\t},\n\n\tinbox_save_instance: function (approve) {\n\t\treturn workflowMethods.inbox_save_instance.apply(this, arguments)\n\t}\n\n})","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2023-01-13 17:35:13\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2023-03-11 10:51:29\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\tcc_do: function (approve, cc_user_ids, description) {\n\t\treturn workflowMethods.cc_do.apply(this, arguments)\n\t},\n\n\tcc_read: function (approve) {\n\t\treturn workflowMethods.cc_read.apply(this, arguments)\n\t},\n\n\tcc_submit: function (ins_id, description, myApprove, ccHasEditPermission) {\n\t\treturn workflowMethods.cc_submit.apply(this, arguments)\n\t},\n\n\tcc_remove: function (instanceId, approveId) {\n\t\treturn workflowMethods.cc_remove.apply(this, arguments)\n\t},\n\n\tbatch_cancel_cc: function (instance_id, approve_ids) {\n\t\treturn workflowMethods.batch_cancel_cc.apply(this, arguments)\n\t},\n\n\tcc_save: function (ins_id, description, myApprove, ccHasEditPermission) {\n\t\treturn workflowMethods.cc_save.apply(this, arguments)\n\t}\n})","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-22 15:18:38\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n\t// 改为通过api调用\n\tforward_instance: function (instance_id, space_id, flow_id, hasSaveInstanceToAttachment, description, isForwardAttachments, selectedUsers, action_type, related, from_approve_id) {\n\t\tif (!this.userId)\n\t\t\tthrow new Meteor.Error('not-authorized');\n\n\t\treturn;\n\t},\n\n\n\tforward_remove: function (instance_id, trace_id, approve_id) {\n\t\treturn workflowMethods.forward_remove.apply(this, arguments)\n\t},\n\n\tcancelDistribute: function (instance_id, approve_ids) {\n\t\treturn workflowMethods.cancelDistribute.apply(this, arguments)\n\t}\n\n\n})","/*\n * @Author: sunhaolin@hotoa.com\n * @Date: 2021-05-24 12:32:56\n * @LastEditors: sunhaolin@hotoa.com\n * @LastEditTime: 2022-12-22 15:17:54\n * @Description: \n */\nconst { workflowMethods } = require('@steedos/workflow')\nMeteor.methods({\n    cfs_instances_remove: function (file_id) {\n        return workflowMethods.cfs_instances_remove.apply(this, arguments)\n    },\n\n    cfs_instances_set_current: function (file_id) {\n        return workflowMethods.cfs_instances_set_current.apply(this, arguments)\n    },\n\n    cfs_instances_lock: function (file_id, user_id, user_name) {\n        return workflowMethods.cfs_instances_lock.apply(this, arguments)\n    },\n\n    cfs_instances_unlock: function (file_id) {\n        return workflowMethods.cfs_instances_unlock.apply(this, arguments)\n    },\n\n    download_space_instance_attachments_to_disk: function (spaceId, cfsRecordIds) {\n        return workflowMethods.download_space_instance_attachments_to_disk.apply(this, arguments)\n    }\n})","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tset_approve_have_read: (instanceId, traceId, approveId) ->\n\t\treturn workflowMethods.set_approve_have_read.apply(this, arguments)\n\n\tchange_approve_info: (instanceId, traceId, approveId, description, finish_date) ->\n\t\treturn workflowMethods.change_approve_info.apply(this, arguments)\n\n\tupdate_approve_sign: (instanceId, traceId, approveId, sign_field_code, description, sign_type, lastSignApprove)->\n\t\treturn workflowMethods.update_approve_sign.apply(this, arguments)\n\n\n\tupdate_sign_show: (objs, myApprove_id) ->\n\t\treturn workflowMethods.update_sign_show.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tinstance_return: (approve, reason)->\n\t\treturn workflowMethods.instance_return.apply(this, arguments)","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tinstance_remind: (remind_users, remind_count, remind_deadline, instance_id, action_types, trace_id)->\n\t\treturn workflowMethods.instance_remind.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tnext_step_users_not_found: (deal_type, step_name, params) ->\n\t\treturn workflowMethods.next_step_users_not_found.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\n_eval = require('eval')\n\nMeteor.methods\n\tinstanceNumberBuilder: (spaceId, name)->\n\t\treturn workflowMethods.instanceNumberBuilder.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tcheck_main_attach: (ins_id, name)->\n\t\treturn workflowMethods.check_main_attach.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tremove_related: (ins_id, re_ins_id)->\n\t\treturn workflowMethods.remove_related.apply(this, arguments)\n\n\tupdate_instance_related: (ins_id, related_instances)->\n\t\treturn workflowMethods.update_instance_related.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tupdateFlowPosition: (data) ->\n\t\treturn workflowMethods.updateFlowPosition.apply(this, arguments)\n\n\tupdateFlowRole: (data) ->\n\t\treturn workflowMethods.updateFlowRole.apply(this, arguments)","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tstart_flow: (space, flowId, start) ->\n\n\t\treturn workflowMethods.start_flow.apply(this, arguments)\n\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tget_instance_traces: (ins_id)->\n\t\treturn workflowMethods.get_instance_traces.apply(this, arguments)","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\t'get_batch_instances': (space, categoryId, flowIds)->\n\t\treturn workflowMethods.get_batch_instances.apply(this, arguments)\n\n\t'get_batch_instances_count': (space, categoryId, flowIds)->\n\t\treturn workflowMethods.get_batch_instances_count.apply(this, arguments)\n\n\t'get_my_approves': (instanceIds)->\n\t\treturn workflowMethods.get_my_approves.apply(this, arguments)\n\n\n\n\n\n\n\n\n\n\n\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tchange_flow_state: (flows) ->\n\t\treturn workflowMethods.change_flow_state.apply(this, arguments)\n\n\n\n\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\n\thide_instance: (insId, is_hidden) ->\n\t\treturn workflowMethods.hide_instance.apply(this, arguments)\n","{ workflowMethods } = require('@steedos/workflow')\nMeteor.methods\n\tgetInstanceValues: (insId)->\n\t\treturn workflowMethods.getInstanceValues.apply(this, arguments)","Cookies = require(\"cookies\")\n\ngetInstanceReadOnly = (req, res, next, options) ->\n\n\tuser = Steedos.getAPILoginUser(req, res)\n\n\tif req?.query?.access_token\n\t\tuserId = Steedos.getUserIdFromAccessToken(req.query.access_token)\n\t\tif userId\n\t\t\tuser = Meteor.users.findOne({_id: userId})\n\n\tspaceId = req.params.space\n\n\tinstanceId = req.params.instance_id\n\n\tinstance = db.instances.findOne({_id: instanceId});\n\n\tspace = db.spaces.findOne({_id: spaceId});\n\n\thide_traces = req.query?.hide_traces\n\n\tif !options\n\t\toptions = {showTrace: true}\n\telse\n\t\toptions.showTrace = true\n\n\tif hide_traces is \"1\"\n\t\tif options\n\t\t\toptions.showTrace = false\n\t\telse\n\t\t\toptions = {showTrace: false}\n\n\tif !options.showAttachments\n\t\toptions.showAttachments = true\n\n\tif !space\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing space\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tif  !instance\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing instance\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tif !user\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing X-Auth-Token,X-User-Id\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tif instance.space != spaceId\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing space or instance\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\n\n\tspaceUserCount = db.space_users.find({ user: user._id, space: spaceId }).count()\n\n\tif spaceUserCount is 0\n\t\tif !space\n\t\t\tJsonRoutes.sendResult res,\n\t\t\t\tcode: 401,\n\t\t\t\tdata:\n\t\t\t\t\t\"error\": \"Validate Request -- Missing sapceUser\",\n\t\t\t\t\t\"success\": false\n\t\t\treturn;\n\n\t#校验user是否对instance有查看权限\n\t_hasPermission = WorkflowManager.hasInstancePermissions(user, instance)\n\n\tif !_hasPermission  && instance.distribute_from_instance\n\t\t_parent_instances = _.union([instance.distribute_from_instance], instance.distribute_from_instances || [])\n\n\t\t_hasPermission = _.find _parent_instances, (_parent_id)->\n\t\t\t_parent_ins = db.instances.findOne({_id:_parent_id}, {fields: {traces: 0}})\n\n\t\t\treturn WorkflowManager.hasInstancePermissions(user, _parent_ins)\n\n\tif !_hasPermission\n\t\t_locale = Steedos.locale(user._id, true)\n\t\terror = TAPi18n.__(\"instance_permissions_error\", {}, _locale)\n\t\tres.charset = \"utf-8\"\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": error,\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\thtml = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options)\n\tdataBuf = new Buffer(html);\n\tres.setHeader('Content-type', 'text/html; charset=utf-8');\n\tres.setHeader('content-length', dataBuf.length)\n\tres.setHeader('content-range', \"bytes 0-#{dataBuf.length - 1}/#{dataBuf.length}\")\n\tres.statusCode = 200\n\tres.end(html)\n\nJsonRoutes.add \"get\", \"/workflow/space/:space/view/readonly/:instance_id\", getInstanceReadOnly\n\nJsonRoutes.add \"get\", \"/workflow/space/:space/view/readonly/:instance_id/:instance_name\", (req, res, next)->\n\tres.setHeader('Content-type', 'application/x-msdownload');\n\tres.setHeader('Content-Disposition', 'attachment;filename='+encodeURI(req.params.instance_name));\n\tres.setHeader('Transfer-Encoding', '')\n\n\toptions = {absolute: true}\n\n\treturn getInstanceReadOnly(req, res, next, options)\n###\n\t获取申请单列表：\n    final_decision：审批结果\n    state: 申请单状态\n###\nJsonRoutes.add \"get\", \"/api/workflow/instances\", (req, res, next) ->\n\n\tif !Steedos.APIAuthenticationCheck(req, res)\n\t\treturn ;\n\n\tuser_id = req.userId\n\n\tspaceId = req.headers[\"x-space-id\"]\n\n\tif not spaceId\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 401,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing X-Space-Id\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tflowId = req.query?.flowId\n\n\tif !flowId\n\t\tJsonRoutes.sendResult res,\n\t\t\tcode: 400,\n\t\t\tdata:\n\t\t\t\t\"error\": \"Validate Request -- Missing flowId\",\n\t\t\t\t\"success\": false\n\t\treturn;\n\n\tquery = {}\n\n\tret_sync_token = new Date().getTime()\n\n\tflowIds = flowId.split(\",\")\n\n\n\tflows = db.flows.find({_id: {$in: flowIds}}).fetch()\n\n\ti = 0\n\twhile i < flows.length\n\t\tf = flows[i]\n\t\tspaceUser = db.space_users.findOne({space: f.space, user: user_id})\n\t\tif !spaceUser\n\t\t\tJsonRoutes.sendResult res,\n\t\t\t\tcode: 401,\n\t\t\t\tdata:\n\t\t\t\t\t\"error\": \"Validate Request -- No permission, flow is #{f._id}\",\n\t\t\t\t\t\"success\": false\n\t\t\treturn;\n\t\telse\n\n\t#\t是否工作区管理员\n\t\tif !Steedos.isSpaceAdmin(spaceId, user_id)\n\t\t\tspaceUserOrganizations = db.organizations.find({\n\t\t\t\t_id: {\n\t\t\t\t\t$in: spaceUser.organizations\n\t\t\t\t}\n\t\t\t}).fetch();\n\n\t\t\tif !WorkflowManager.canMonitor(f, spaceUser, spaceUserOrganizations) && !WorkflowManager.canAdmin(f, spaceUser, spaceUserOrganizations)\n\t\t\t\tJsonRoutes.sendResult res,\n\t\t\t\t\tcode: 401,\n\t\t\t\t\tdata:\n\t\t\t\t\t\t\"error\": \"Validate Request -- No permission, flow is #{f._id}\",\n\t\t\t\t\t\t\"success\": false\n\t\t\t\treturn;\n\t\ti++\n\n\n\tquery.flow = {$in: flowIds}\n\n\tquery.space = spaceId\n\n\tif req.query?.sync_token\n\t\tsync_token = new Date(Number(req.query.sync_token))\n\t\tquery.modified = {$gt: sync_token}\n\n\tif req.query?.final_decision\n\t\tquery.final_decision = {$in : req.query.final_decision.split(\",\")}\n\telse\n\t\tquery.final_decision = {$nin: [\"terminated\", \"rejected\"]}\n\n\tif req.query?.state\n\t\tquery.state = {$in: req.query.state.split(\",\")}\n\telse\n\t\tquery.state = \"completed\"\n\n#\t最多返回500条数据\n\tinstances = db.instances.find(query, {fields: {inbox_uers: 0, cc_users: 0, outbox_users: 0, traces: 0, attachments: 0}, skip: 0, limit: 500}).fetch()\n\tinstances.forEach (instance)->\n\n\t\tattachments = cfs.instances.find({'metadata.instance': instance._id,'metadata.current': true, \"metadata.is_private\": {$ne: true}}, {fields: {copies: 0}}).fetch()\n\n\t\tinstance.attachments = attachments\n\n\n\tJsonRoutes.sendResult res,\n\t\t\tcode: 200,\n\t\t\tdata:\n\t\t\t\t\"status\": \"success\",\n\t\t\t\t\"sync_token\": ret_sync_token\n\t\t\t\t\"data\": instances\n\treturn;\n","var Cookies, getInstanceReadOnly;\n\nCookies = require(\"cookies\");\n\ngetInstanceReadOnly = function(req, res, next, options) {\n  var _hasPermission, _locale, _parent_instances, dataBuf, error, hide_traces, html, instance, instanceId, ref, ref1, space, spaceId, spaceUserCount, user, userId;\n  user = Steedos.getAPILoginUser(req, res);\n  if (req != null ? (ref = req.query) != null ? ref.access_token : void 0 : void 0) {\n    userId = Steedos.getUserIdFromAccessToken(req.query.access_token);\n    if (userId) {\n      user = Meteor.users.findOne({\n        _id: userId\n      });\n    }\n  }\n  spaceId = req.params.space;\n  instanceId = req.params.instance_id;\n  instance = db.instances.findOne({\n    _id: instanceId\n  });\n  space = db.spaces.findOne({\n    _id: spaceId\n  });\n  hide_traces = (ref1 = req.query) != null ? ref1.hide_traces : void 0;\n  if (!options) {\n    options = {\n      showTrace: true\n    };\n  } else {\n    options.showTrace = true;\n  }\n  if (hide_traces === \"1\") {\n    if (options) {\n      options.showTrace = false;\n    } else {\n      options = {\n        showTrace: false\n      };\n    }\n  }\n  if (!options.showAttachments) {\n    options.showAttachments = true;\n  }\n  if (!space) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing space\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  if (!instance) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing instance\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  if (!user) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing X-Auth-Token,X-User-Id\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  if (instance.space !== spaceId) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing space or instance\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  spaceUserCount = db.space_users.find({\n    user: user._id,\n    space: spaceId\n  }).count();\n  if (spaceUserCount === 0) {\n    if (!space) {\n      JsonRoutes.sendResult(res, {\n        code: 401,\n        data: {\n          \"error\": \"Validate Request -- Missing sapceUser\",\n          \"success\": false\n        }\n      });\n      return;\n    }\n  }\n  _hasPermission = WorkflowManager.hasInstancePermissions(user, instance);\n  if (!_hasPermission && instance.distribute_from_instance) {\n    _parent_instances = _.union([instance.distribute_from_instance], instance.distribute_from_instances || []);\n    _hasPermission = _.find(_parent_instances, function(_parent_id) {\n      var _parent_ins;\n      _parent_ins = db.instances.findOne({\n        _id: _parent_id\n      }, {\n        fields: {\n          traces: 0\n        }\n      });\n      return WorkflowManager.hasInstancePermissions(user, _parent_ins);\n    });\n  }\n  if (!_hasPermission) {\n    _locale = Steedos.locale(user._id, true);\n    error = TAPi18n.__(\"instance_permissions_error\", {}, _locale);\n    res.charset = \"utf-8\";\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": error,\n        \"success\": false\n      }\n    });\n    return;\n  }\n  html = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options);\n  dataBuf = new Buffer(html);\n  res.setHeader('Content-type', 'text/html; charset=utf-8');\n  res.setHeader('content-length', dataBuf.length);\n  res.setHeader('content-range', \"bytes 0-\" + (dataBuf.length - 1) + \"/\" + dataBuf.length);\n  res.statusCode = 200;\n  return res.end(html);\n};\n\nJsonRoutes.add(\"get\", \"/workflow/space/:space/view/readonly/:instance_id\", getInstanceReadOnly);\n\nJsonRoutes.add(\"get\", \"/workflow/space/:space/view/readonly/:instance_id/:instance_name\", function(req, res, next) {\n  var options;\n  res.setHeader('Content-type', 'application/x-msdownload');\n  res.setHeader('Content-Disposition', 'attachment;filename=' + encodeURI(req.params.instance_name));\n  res.setHeader('Transfer-Encoding', '');\n  options = {\n    absolute: true\n  };\n  return getInstanceReadOnly(req, res, next, options);\n});\n\n\n/*\n\t获取申请单列表：\n    final_decision：审批结果\n    state: 申请单状态\n */\n\nJsonRoutes.add(\"get\", \"/api/workflow/instances\", function(req, res, next) {\n  var f, flowId, flowIds, flows, i, instances, query, ref, ref1, ref2, ref3, ret_sync_token, spaceId, spaceUser, spaceUserOrganizations, sync_token, user_id;\n  if (!Steedos.APIAuthenticationCheck(req, res)) {\n    return;\n  }\n  user_id = req.userId;\n  spaceId = req.headers[\"x-space-id\"];\n  if (!spaceId) {\n    JsonRoutes.sendResult(res, {\n      code: 401,\n      data: {\n        \"error\": \"Validate Request -- Missing X-Space-Id\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  flowId = (ref = req.query) != null ? ref.flowId : void 0;\n  if (!flowId) {\n    JsonRoutes.sendResult(res, {\n      code: 400,\n      data: {\n        \"error\": \"Validate Request -- Missing flowId\",\n        \"success\": false\n      }\n    });\n    return;\n  }\n  query = {};\n  ret_sync_token = new Date().getTime();\n  flowIds = flowId.split(\",\");\n  flows = db.flows.find({\n    _id: {\n      $in: flowIds\n    }\n  }).fetch();\n  i = 0;\n  while (i < flows.length) {\n    f = flows[i];\n    spaceUser = db.space_users.findOne({\n      space: f.space,\n      user: user_id\n    });\n    if (!spaceUser) {\n      JsonRoutes.sendResult(res, {\n        code: 401,\n        data: {\n          \"error\": \"Validate Request -- No permission, flow is \" + f._id,\n          \"success\": false\n        }\n      });\n      return;\n    } else {\n\n    }\n    if (!Steedos.isSpaceAdmin(spaceId, user_id)) {\n      spaceUserOrganizations = db.organizations.find({\n        _id: {\n          $in: spaceUser.organizations\n        }\n      }).fetch();\n      if (!WorkflowManager.canMonitor(f, spaceUser, spaceUserOrganizations) && !WorkflowManager.canAdmin(f, spaceUser, spaceUserOrganizations)) {\n        JsonRoutes.sendResult(res, {\n          code: 401,\n          data: {\n            \"error\": \"Validate Request -- No permission, flow is \" + f._id,\n            \"success\": false\n          }\n        });\n        return;\n      }\n    }\n    i++;\n  }\n  query.flow = {\n    $in: flowIds\n  };\n  query.space = spaceId;\n  if ((ref1 = req.query) != null ? ref1.sync_token : void 0) {\n    sync_token = new Date(Number(req.query.sync_token));\n    query.modified = {\n      $gt: sync_token\n    };\n  }\n  if ((ref2 = req.query) != null ? ref2.final_decision : void 0) {\n    query.final_decision = {\n      $in: req.query.final_decision.split(\",\")\n    };\n  } else {\n    query.final_decision = {\n      $nin: [\"terminated\", \"rejected\"]\n    };\n  }\n  if ((ref3 = req.query) != null ? ref3.state : void 0) {\n    query.state = {\n      $in: req.query.state.split(\",\")\n    };\n  } else {\n    query.state = \"completed\";\n  }\n  instances = db.instances.find(query, {\n    fields: {\n      inbox_uers: 0,\n      cc_users: 0,\n      outbox_users: 0,\n      traces: 0,\n      attachments: 0\n    },\n    skip: 0,\n    limit: 500\n  }).fetch();\n  instances.forEach(function(instance) {\n    var attachments;\n    attachments = cfs.instances.find({\n      'metadata.instance': instance._id,\n      'metadata.current': true,\n      \"metadata.is_private\": {\n        $ne: true\n      }\n    }, {\n      fields: {\n        copies: 0\n      }\n    }).fetch();\n    return instance.attachments = attachments;\n  });\n  JsonRoutes.sendResult(res, {\n    code: 200,\n    data: {\n      \"status\": \"success\",\n      \"sync_token\": ret_sync_token,\n      \"data\": instances\n    }\n  });\n});\n","\nJsonRoutes.add \"get\", \"/steedos-css\", (req, res, next)->\n\tres.setHeader('Content-type', 'text/css');\n\tallCss = WebApp.getRefreshableAssets()\n\n\tallCssLink = \"\"\n\n\tallCss.forEach (css) ->\n\t\tif __meteor_runtime_config__.ROOT_URL_PATH_PREFIX\n\t\t\trootUrl = __meteor_runtime_config__.ROOT_URL\n\t\t\tif rootUrl.endsWith(\"/\")\n\t\t\t\tcssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX + \"/\", \"\") + css.url\n\t\t\telse\n\t\t\t\tcssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX, \"\") + css.url\n\t\telse\n\t\t\tcssHref = Meteor.absoluteUrl(css.url)\n\t\tallCssLink += \"@import url(#{cssHref});\"\n\n\tres.statusCode = 200\n\tres.end(allCssLink)","JsonRoutes.add(\"get\", \"/steedos-css\", function(req, res, next) {\n  var allCss, allCssLink;\n  res.setHeader('Content-type', 'text/css');\n  allCss = WebApp.getRefreshableAssets();\n  allCssLink = \"\";\n  allCss.forEach(function(css) {\n    var cssHref, rootUrl;\n    if (__meteor_runtime_config__.ROOT_URL_PATH_PREFIX) {\n      rootUrl = __meteor_runtime_config__.ROOT_URL;\n      if (rootUrl.endsWith(\"/\")) {\n        cssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX + \"/\", \"\") + css.url;\n      } else {\n        cssHref = rootUrl.replace(__meteor_runtime_config__.ROOT_URL_PATH_PREFIX, \"\") + css.url;\n      }\n    } else {\n      cssHref = Meteor.absoluteUrl(css.url);\n    }\n    return allCssLink += \"@import url(\" + cssHref + \");\";\n  });\n  res.statusCode = 200;\n  return res.end(allCssLink);\n});\n","JsonRoutes.add \"get\", \"/api/workflow/space/:space/view/draft/:flow\", (req, res, next) ->\n\tif !Steedos.APIAuthenticationCheck(req, res)\n\t\treturn\n\n\tuser_id = req.userId\n\n\tuser = db.users.findOne({ _id: user_id })\n\n\tspaceId = req.params.space\n\n\tflowId = req.params.flow\n\n\tspace = db.spaces.findOne({ _id: spaceId })\n\n\tflow = db.flows.findOne({ _id: flowId }, { fields: { name: 1, 'current._id': 1, form: 1 } })\n\n\tform = db.forms.findOne({ _id: flow.form }, { fields: { 'current._id': 1 } })\n\n\toptions = {\n\t\tshowTrace: false,\n\t\tshowAttachments: false,\n\t\ttemplateName: \"default\",\n\t\teditable: true,\n\t\twidth: \"100%\",\n\t\tinstance_style: \"instance-default\",\n\t\tplugins: \"\"\"\n\n\t\t\t<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge,chrome=1\" />\n\t\t\t<meta name=\"format-detection\" content=\"telephone=no\">\n\t\t\t<meta http-equiv=\"x-rim-auto-match\" content=\"none\">\n\t\t\t<title>#{flow.name}</title>\n\t\t\t<meta content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0' name='viewport' />\n\t\t\t<meta name=\"viewport\" content=\"width=device-width\" />\n\n\t\t\t<link rel=\"stylesheet\" type=\"text/css\" href=\"/plugins/bootstrap-datetimepicker/css/bootstrap-datetimepicker.min.css\">\n\n\t\t\t<script src=\"/plugins/bootstrap-datetimepicker/js/bootstrap-datetimepicker.min.js\" type=\"text/javascript\"></script>\n\n\t\t\t<script src=\"/plugins/bootstrap-datetimepicker/js/locales/bootstrap-datetimepicker.zh-CN.js\" type=\"text/javascript\" charset=\"UTF-8\"></script>\n\n\t\t\t<link rel=\"stylesheet\" type=\"text/css\" href=\"/plugins/toastr/toastr.min.css\">\n\t\t\t<script src=\"/plugins/toastr/toastr.min.js\" type=\"text/javascript\"></script>\n\t\t\t<link rel=\"stylesheet\" type=\"text/css\" href=\"/js/workflow_client.css\">\n\t\t\t<script src=\"/js/workflow_client.js\" type=\"text/javascript\"></script>\n\t\t\"\"\"\n\t}\n\n\tinstance = {\n\t\tflow: flow._id,\n\t\tflow_version: flow.current._id,\n\t\tform: form._id,\n\t\tform_version: form.current._id,\n\t\tvalues: {},\n\t\tname: flow.name,\n\t\tspace: spaceId\n\t}\n\n\thtml = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options)\n\n\tdataBuf = new Buffer(html)\n\n\tres.setHeader('content-length', dataBuf.length)\n\n\tres.setHeader('content-range', \"bytes 0-#{dataBuf.length - 1}/#{dataBuf.length}\")\n\n\tres.statusCode = 200\n\n\tres.end(html)\n","JsonRoutes.add(\"get\", \"/api/workflow/space/:space/view/draft/:flow\", function(req, res, next) {\n  var dataBuf, flow, flowId, form, html, instance, options, space, spaceId, user, user_id;\n  if (!Steedos.APIAuthenticationCheck(req, res)) {\n    return;\n  }\n  user_id = req.userId;\n  user = db.users.findOne({\n    _id: user_id\n  });\n  spaceId = req.params.space;\n  flowId = req.params.flow;\n  space = db.spaces.findOne({\n    _id: spaceId\n  });\n  flow = db.flows.findOne({\n    _id: flowId\n  }, {\n    fields: {\n      name: 1,\n      'current._id': 1,\n      form: 1\n    }\n  });\n  form = db.forms.findOne({\n    _id: flow.form\n  }, {\n    fields: {\n      'current._id': 1\n    }\n  });\n  options = {\n    showTrace: false,\n    showAttachments: false,\n    templateName: \"default\",\n    editable: true,\n    width: \"100%\",\n    instance_style: \"instance-default\",\n    plugins: \"\\n<meta http-equiv=\\\"X-UA-Compatible\\\" content=\\\"IE=edge,chrome=1\\\" />\\n<meta name=\\\"format-detection\\\" content=\\\"telephone=no\\\">\\n<meta http-equiv=\\\"x-rim-auto-match\\\" content=\\\"none\\\">\\n<title>\" + flow.name + \"</title>\\n<meta content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=0' name='viewport' />\\n<meta name=\\\"viewport\\\" content=\\\"width=device-width\\\" />\\n\\n<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"/plugins/bootstrap-datetimepicker/css/bootstrap-datetimepicker.min.css\\\">\\n\\n<script src=\\\"/plugins/bootstrap-datetimepicker/js/bootstrap-datetimepicker.min.js\\\" type=\\\"text/javascript\\\"></script>\\n\\n<script src=\\\"/plugins/bootstrap-datetimepicker/js/locales/bootstrap-datetimepicker.zh-CN.js\\\" type=\\\"text/javascript\\\" charset=\\\"UTF-8\\\"></script>\\n\\n<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"/plugins/toastr/toastr.min.css\\\">\\n<script src=\\\"/plugins/toastr/toastr.min.js\\\" type=\\\"text/javascript\\\"></script>\\n<link rel=\\\"stylesheet\\\" type=\\\"text/css\\\" href=\\\"/js/workflow_client.css\\\">\\n<script src=\\\"/js/workflow_client.js\\\" type=\\\"text/javascript\\\"></script>\"\n  };\n  instance = {\n    flow: flow._id,\n    flow_version: flow.current._id,\n    form: form._id,\n    form_version: form.current._id,\n    values: {},\n    name: flow.name,\n    space: spaceId\n  };\n  html = InstanceReadOnlyTemplate.getInstanceHtml(user, space, instance, options);\n  dataBuf = new Buffer(html);\n  res.setHeader('content-length', dataBuf.length);\n  res.setHeader('content-range', \"bytes 0-\" + (dataBuf.length - 1) + \"/\" + dataBuf.length);\n  res.statusCode = 200;\n  return res.end(html);\n});\n","Array.prototype.filterProperty = function(h, l){\n    var g = [];\n    this.forEach(function(t){\n        var m = t? t[h]:null;\n        var d = false;\n        if(m instanceof Array){\n            d = m.includes(l);\n        }else{\n            d = (l === undefined)? false:m==l;\n        }\n        if(d){\n            g.push(t);\n        }\n    });\n    return g;\n};\n\nArray.prototype.getProperty = function(k){\n    var v = new Array();\n    this.forEach(function(t){\n        var m = t? t[k]:null;\n        v.push(m);\n    });\n    return v;\n}\n\nArray.prototype.getEach = function(code){\n    var rev = [];\n    for(var i = 0 ; i < this.length ; i++){\n        rev.push(this[i][code]);\n    }\n    return rev;\n};\n\nArray.prototype.uniq = function(){\n    var a = [];\n    this.forEach(function(b){ \n        if(a.indexOf(b) < 0)\n            {a[a.length] = b}\n    });\n    return a;\n};\n\nForm_formula = {};\n\n\nForm_formula.mixin = function(dest, src){\n    for(var key in src){\n        dest[key] = src[key];\n    }\n    return dest;\n};\n\n\nForm_formula.handerUserObject = function(u){\n\n    if(u instanceof Array){\n        var user = {};\n\n        user.name = u.getProperty(\"name\")\n        user.organization = {};\n        user.organization.name = u.getProperty(\"organization\").getProperty(\"name\");\n        user.organization.fullname = u.getProperty(\"organization\").getProperty(\"fullname\");\n\n        user.hr = u.getProperty(\"hr\")\n\n        user.sort_no = u.getProperty(\"sort_no\")\n\n\t\tuser.mobile = u.getProperty(\"mobile\")\n\n\t\tuser.work_phone = u.getProperty(\"work_phone\")\n\n\t\tuser.position = u.getProperty(\"position\")\n\n        var userRoles = u.getProperty(\"roles\");\n        var roles = new Array();\n        userRoles.forEach(function(i){\n            roles = roles.concat(i);\n        }); \n        roles.uniq();\n        user.roles = roles;\n        return user;\n    }else{\n        return u;\n    }\n}\n\nForm_formula.handerOrgObject = function(o){\n\n    if(o instanceof Array){\n        var org = {};\n\t\torg.id = o.getProperty(\"_id\");\n        org.name = o.getProperty(\"name\");\n        org.fullname = o.getProperty(\"fullname\");\n\n        return org;\n    }else{\n        return o;\n    }\n}\n\n\n\n/**\n    * 获得公式需要用到的初始值\n    * 输入：fields, values, applicant\n    * 输出：__values\n**/\nForm_formula.init_formula_values = function(fields, autoFormDoc, approver, applicant, spaceId){\n    var __values = {};\n    //申请单中填的值处理\n    if(fields && fields.length && autoFormDoc) {\n        //debugger;\n        fields.forEach(function(field){\n            var type = field.type;\n            if(type) {\n                if(type === 'table') {\n                    /*\n                    * 将表格字段的值进行转换后传入__values中\n                    * values中表格的值格式为\n                    * [{\"a\":1,\"b\":4},{\"a\":2,\"b\":5},{\"a\":3,\"b\":6}]\n                    * __values需要转化为下面格式且和主表的值一样放到第一层\n                    * {\"a\":[1,2,3],\"b\":[4,5,6]}\n                    **/\n                    var tableFields = field.sfields,\n                        tableValues = autoFormDoc[field.code],\n                        formulaTableValues = [],\n                        __tableValues = {};\n                    //按公式的格式转换值为__tableValues\n                    if(tableFields && tableFields.length && tableValues && tableValues instanceof Array) {\n                        tableValues.forEach(function(tableValue){\n                            formulaTableValues.push(Form_formula.init_formula_values(tableFields, tableValue));\n                        }, this);\n                        //按主表的格式转换__tableValues加到\n                        tableFields.forEach(function(tablefield){\n                            __tableValues[tablefield.code] = formulaTableValues.getEach(tablefield.code);\n                        });\n                        __values = Form_formula.mixin(__values, __tableValues);\n                    }\n                } else if (type == 'user'){\n                    __values[field.code] = Form_formula.handerUserObject(WorkflowManager.getFormulaUserObjects(spaceId, autoFormDoc[field.code]));\n\n                } else if (type == 'group'){\n                    __values[field.code] = Form_formula.handerOrgObject(WorkflowManager.getFormulaOrgObjects(autoFormDoc[field.code]));\n\n                } else if (type == 'odata'){\n\t\t\t\t\t__values[field.code] = autoFormDoc[field.code] || {}\n\n\t\t\t\t} else {\n                    //此处传spaceId给选人控件的旧数据计算roles和organization\n                    __values[field.code] = autoFormDoc[field.code];\n                }\n            }\n        }, this);\n    }\n    //当前处理人\n    __values[\"approver\"] = WorkflowManager.getFormulaUserObject(spaceId, approver);\n    //申请人\n    __values[\"applicant\"] = WorkflowManager.getFormulaUserObject(spaceId, applicant);\n\n    return __values;\n};\n\n","Meteor.publish 'categories', (spaceId) ->\n\tcheck spaceId, String\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\n\treturn db.categories.find({ space: spaceId }, { fields: { name: 1, space: 1, sort_no: 1, app: 1 } })","Meteor.publish('categories', function(spaceId) {\n  check(spaceId, String);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.categories.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      space: 1,\n      sort_no: 1,\n      app: 1\n    }\n  });\n});\n","\nMeteor.publish 'cfs_instances', (instanceIds)->\n\tcheck(instanceIds, Array)\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless instanceIds\n\t\t\treturn this.ready()\n\n\treturn cfs.instances.find({'metadata.instance': {$in: instanceIds} , $or: [{'metadata.is_private': {$ne: true}},{'metadata.is_private': true, \"metadata.owner\": this.userId}]})\n","Meteor.publish('cfs_instances', function(instanceIds) {\n  check(instanceIds, Array);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instanceIds) {\n    return this.ready();\n  }\n  return cfs.instances.find({\n    'metadata.instance': {\n      $in: instanceIds\n    },\n    $or: [\n      {\n        'metadata.is_private': {\n          $ne: true\n        }\n      }, {\n        'metadata.is_private': true,\n        \"metadata.owner\": this.userId\n      }\n    ]\n  });\n});\n","\n\nMeteor.publish 'flow_positions', (spaceId)->\n\t\n\tunless this.userId\n\t\treturn this.ready()\n\t\n\tunless spaceId\n\t\treturn this.ready()\n\n\treturn db.flow_positions.find({space: spaceId}, {fields: {role:1, users: 1, org: 1}});\n","Meteor.publish('flow_positions', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.flow_positions.find({\n    space: spaceId\n  }, {\n    fields: {\n      role: 1,\n      users: 1,\n      org: 1\n    }\n  });\n});\n","Meteor.publishComposite 'flow_positions_tabular', (tableName, ids, fields)->\n\tcheck(tableName, String);\n\tcheck(ids, Array);\n\tcheck(fields, Match.Optional(Object));\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tthis.unblock()\n\n\tfind: ->\n\t\tthis.unblock()\n\t\tdb.flow_positions.find {_id: {$in: ids}}, fields: fields\n\n\tchildren: [\n\t\t{\n\t\t\tfind: (position) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related flow_roles\n\t\t\t\tdb.flow_roles.find { _id: position.role }, fields: name: 1\n\t\t}\n\t\t{\n\t\t\tfind: (position) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related organizations\n\t\t\t\tdb.organizations.find { _id: position.org }, fields: fullname: 1\n\t\t}\n\t\t{\n\t\t\tfind: (position) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.space_users.find {\n\t\t\t\t\tspace: position.space\n\t\t\t\t\tuser: $in: position.users\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\tuser: 1\n\t\t\t\t\tname: 1\n\t\t}\n\t]","Meteor.publishComposite('flow_positions_tabular', function(tableName, ids, fields) {\n  check(tableName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  if (!this.userId) {\n    return this.ready();\n  }\n  this.unblock();\n  return {\n    find: function() {\n      this.unblock();\n      return db.flow_positions.find({\n        _id: {\n          $in: ids\n        }\n      }, {\n        fields: fields\n      });\n    },\n    children: [\n      {\n        find: function(position) {\n          this.unblock();\n          return db.flow_roles.find({\n            _id: position.role\n          }, {\n            fields: {\n              name: 1\n            }\n          });\n        }\n      }, {\n        find: function(position) {\n          this.unblock();\n          return db.organizations.find({\n            _id: position.org\n          }, {\n            fields: {\n              fullname: 1\n            }\n          });\n        }\n      }, {\n        find: function(position) {\n          this.unblock();\n          return db.space_users.find({\n            space: position.space,\n            user: {\n              $in: position.users\n            }\n          }, {\n            fields: {\n              space: 1,\n              user: 1,\n              name: 1\n            }\n          });\n        }\n      }\n    ]\n  };\n});\n","\n\n\tMeteor.publish 'flow_roles', (spaceId)->\n\t\t\n\t\tunless this.userId\n\t\t\treturn this.ready()\n\t\t\n\t\tunless spaceId\n\t\t\treturn this.ready()\n\n\n\t\treturn db.flow_roles.find({space: spaceId}, {fields: {name:1}});\n","Meteor.publish('flow_roles', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.flow_roles.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1\n    }\n  });\n});\n","Meteor.publish 'flows', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\t# 第一次订阅时初始化工作区\n\tif db.flows.find({space: spaceId}).count() == 0\n\t\tdb.spaces.createTemplateFormAndFlow(spaceId)\n\n\treturn db.flows.find({space: spaceId}, {\n\t\tfields: {\n\t\t\tname: 1,\n\t\t\tform: 1,\n\t\t\tstate: 1,\n\t\t\tperms: 1,\n\t\t\tspace: 1,\n\t\t\tcompany_id: 1,\n\t\t\tsort_no: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\n\nMeteor.publish 'instance_flow', (spaceId, flowId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\treturn db.flows.find({_id: flowId, space: spaceId}, {\n\t\tfields: {\n\t\t\tname: 1,\n\t\t\tform: 1,\n\t\t\tstate: 1,\n\t\t\tperms: 1,\n\t\t\tspace: 1,\n\t\t\tcompany_id: 1,\n\t\t\tsort_no: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\n\n\nMeteor.publish 'flow_version', (spaceId, flowId, versionId) ->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\tunless versionId\n\t\treturn this.ready()\n\n\n\tself = this;\n\n\tgetFlowVersion = (id , versionId)->\n\t\tflow = db.flows.findOne({_id : id});\n\t\tif flow\n\t\t\tflow_version = flow.current\n\t\t\tflow_version.latest = true\n\n\t\t\tif flow_version._id != versionId\n\t\t\t\tflow_version = flow.historys.findPropertyByPK(\"_id\", versionId)\n\t\t\t\tflow_version.latest = false\n\n\t\t\treturn flow_version\n\thandle = db.flows.find({_id: flowId}, {fields: {_id: 1, \"current.modified\": 1}}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tself.changed(\"flow_versions\", versionId, getFlowVersion(id, versionId));\n\t}\n\n\n\tself.added(\"flow_versions\", versionId, getFlowVersion(flowId, versionId));\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n\nMeteor.publish 'distribute_optional_flows', (flow_ids)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless flow_ids\n\t\treturn this.ready()\n\n\treturn db.flows.find({_id: {$in: flow_ids}}, {\n\t\tfields: {\n\t\t\tname: 1,\n\t\t\tform: 1,\n\t\t\tstate: 1,\n\t\t\tperms: 1,\n\t\t\tspace: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tdistribute_end_notification: 1,\n\t\t\tcompany_id: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\n\nMeteor.publish 'flow', (spaceId, flowId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\n\treturn db.flows.find({_id: flowId, space: spaceId}, {\n\t\tfields: {\n\t\t\tprint_template: 1,\n\t\t\tinstance_template: 1,\n\t\t\tevents: 1,\n\t\t\tdistribute_optional_users: 1,\n\t\t\tdistribute_to_self: 1,\n\t\t\tupload_after_being_distributed: 1,\n\t\t\tdistribute_end_notification: 1,\n\t\t\tcompany_id: 1,\n\t\t\tallow_select_step: 1,\n\t\t\tenable_amisform: 1\n\t\t}\n\t})\nMeteor.publish 'flow_files', (spaceId, flowId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless flowId\n\t\treturn this.ready()\n\n\treturn cfs.files.find({ 'metadata.space': spaceId, 'metadata.object_name': 'flows', 'metadata.record_id': flowId })\n\nMeteor.publishComposite 'flows_tabular', (tableName, ids, fields)->\n\tcheck(tableName, String);\n\tcheck(ids, Array);\n\tcheck(fields, Match.Optional(Object));\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tthis.unblock()\n\n\tfind: ->\n\t\tthis.unblock()\n\t\tdb.flows.find {_id: {$in: ids}}, fields: fields\n\n\tchildren: [\n\t\t{\n\t\t\tfind: (flow) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.space_users.find {\n\t\t\t\t\tspace: flow.space,\n\t\t\t\t\tuser: flow.current.modified_by\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\tuser: 1\n\t\t\t\t\tname: 1\n\t\t},\n\t\t{\n\t\t\tfind: (flow) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.forms.find {\n\t\t\t\t\tspace: flow.space,\n\t\t\t\t\t_id: flow.form\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\t_id: 1\n\t\t\t\t\tname: 1,\n\t\t\t\t\tcategory: 1\n\t\t},\n\t\t{\n\t\t\tfind: (flow) ->\n\t\t\t\t@unblock()\n\t\t\t\t# Publish the related user\n\t\t\t\tdb.categories.find {\n\t\t\t\t\tspace: flow.space\n\t\t\t\t}, fields:\n\t\t\t\t\tspace: 1\n\t\t\t\t\t_id: 1\n\t\t\t\t\tname: 1\n\t\t}\n\t]","Meteor.publish('flows', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (db.flows.find({\n    space: spaceId\n  }).count() === 0) {\n    db.spaces.createTemplateFormAndFlow(spaceId);\n  }\n  return db.flows.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      form: 1,\n      state: 1,\n      perms: 1,\n      space: 1,\n      company_id: 1,\n      sort_no: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('instance_flow', function(spaceId, flowId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  return db.flows.find({\n    _id: flowId,\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      form: 1,\n      state: 1,\n      perms: 1,\n      space: 1,\n      company_id: 1,\n      sort_no: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('flow_version', function(spaceId, flowId, versionId) {\n  var getFlowVersion, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  if (!versionId) {\n    return this.ready();\n  }\n  self = this;\n  getFlowVersion = function(id, versionId) {\n    var flow, flow_version;\n    flow = db.flows.findOne({\n      _id: id\n    });\n    if (flow) {\n      flow_version = flow.current;\n      flow_version.latest = true;\n      if (flow_version._id !== versionId) {\n        flow_version = flow.historys.findPropertyByPK(\"_id\", versionId);\n        flow_version.latest = false;\n      }\n      return flow_version;\n    }\n  };\n  handle = db.flows.find({\n    _id: flowId\n  }, {\n    fields: {\n      _id: 1,\n      \"current.modified\": 1\n    }\n  }).observeChanges({\n    changed: function(id) {\n      return self.changed(\"flow_versions\", versionId, getFlowVersion(id, versionId));\n    }\n  });\n  self.added(\"flow_versions\", versionId, getFlowVersion(flowId, versionId));\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n\nMeteor.publish('distribute_optional_flows', function(flow_ids) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!flow_ids) {\n    return this.ready();\n  }\n  return db.flows.find({\n    _id: {\n      $in: flow_ids\n    }\n  }, {\n    fields: {\n      name: 1,\n      form: 1,\n      state: 1,\n      perms: 1,\n      space: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      distribute_end_notification: 1,\n      company_id: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('flow', function(spaceId, flowId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  return db.flows.find({\n    _id: flowId,\n    space: spaceId\n  }, {\n    fields: {\n      print_template: 1,\n      instance_template: 1,\n      events: 1,\n      distribute_optional_users: 1,\n      distribute_to_self: 1,\n      upload_after_being_distributed: 1,\n      distribute_end_notification: 1,\n      company_id: 1,\n      allow_select_step: 1,\n      enable_amisform: 1\n    }\n  });\n});\n\nMeteor.publish('flow_files', function(spaceId, flowId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!flowId) {\n    return this.ready();\n  }\n  return cfs.files.find({\n    'metadata.space': spaceId,\n    'metadata.object_name': 'flows',\n    'metadata.record_id': flowId\n  });\n});\n\nMeteor.publishComposite('flows_tabular', function(tableName, ids, fields) {\n  check(tableName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  if (!this.userId) {\n    return this.ready();\n  }\n  this.unblock();\n  return {\n    find: function() {\n      this.unblock();\n      return db.flows.find({\n        _id: {\n          $in: ids\n        }\n      }, {\n        fields: fields\n      });\n    },\n    children: [\n      {\n        find: function(flow) {\n          this.unblock();\n          return db.space_users.find({\n            space: flow.space,\n            user: flow.current.modified_by\n          }, {\n            fields: {\n              space: 1,\n              user: 1,\n              name: 1\n            }\n          });\n        }\n      }, {\n        find: function(flow) {\n          this.unblock();\n          return db.forms.find({\n            space: flow.space,\n            _id: flow.form\n          }, {\n            fields: {\n              space: 1,\n              _id: 1,\n              name: 1,\n              category: 1\n            }\n          });\n        }\n      }, {\n        find: function(flow) {\n          this.unblock();\n          return db.categories.find({\n            space: flow.space\n          }, {\n            fields: {\n              space: 1,\n              _id: 1,\n              name: 1\n            }\n          });\n        }\n      }\n    ]\n  };\n});\n","Meteor.publish 'forms', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\n\treturn db.forms.find({space: spaceId}, {fields: {name: 1, category: 1, state: 1, description: 1, instance_style: 1, amis_schema: 1}})\n\nMeteor.publish 'instance_form', (spaceId, formId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\n\treturn db.forms.find({_id: formId, space: spaceId}, {fields: {name: 1, category: 1, state: 1, description: 1, instance_style: 1, amis_schema: 1}})\n\n\nMeteor.publish 'form_version', (spaceId, formId, versionId) ->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId\n\t\treturn this.ready()\n\n\tunless formId\n\t\treturn this.ready()\n\n\tunless versionId\n\t\treturn this.ready()\n\n\n\tself = this;\n\n\tgetFormVersion = (id , versionId)->\n\t\tform = db.forms.findOne({_id : id});\n\t\tif !form\n\t\t\treturn {}\n\t\tform_version = form.current\n\t\tform_version.latest = true\n\t\tif form_version._id != versionId\n\t\t\tform_version = form.historys.findPropertyByPK(\"_id\", versionId)\n\t\t\tform_version.latest = false\n\t\treturn form_version\n\n\thandle = db.forms.find({_id: formId}, {fields: {_id: 1, \"current.modified\": 1}}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tself.changed(\"form_versions\", versionId, getFormVersion(id, versionId));\n\t}\n\n\tself.added(\"form_versions\", versionId, getFormVersion(formId, versionId));\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()","Meteor.publish('forms', function(spaceId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.forms.find({\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      category: 1,\n      state: 1,\n      description: 1,\n      instance_style: 1,\n      amis_schema: 1\n    }\n  });\n});\n\nMeteor.publish('instance_form', function(spaceId, formId) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  return db.forms.find({\n    _id: formId,\n    space: spaceId\n  }, {\n    fields: {\n      name: 1,\n      category: 1,\n      state: 1,\n      description: 1,\n      instance_style: 1,\n      amis_schema: 1\n    }\n  });\n});\n\nMeteor.publish('form_version', function(spaceId, formId, versionId) {\n  var getFormVersion, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  if (!formId) {\n    return this.ready();\n  }\n  if (!versionId) {\n    return this.ready();\n  }\n  self = this;\n  getFormVersion = function(id, versionId) {\n    var form, form_version;\n    form = db.forms.findOne({\n      _id: id\n    });\n    if (!form) {\n      return {};\n    }\n    form_version = form.current;\n    form_version.latest = true;\n    if (form_version._id !== versionId) {\n      form_version = form.historys.findPropertyByPK(\"_id\", versionId);\n      form_version.latest = false;\n    }\n    return form_version;\n  };\n  handle = db.forms.find({\n    _id: formId\n  }, {\n    fields: {\n      _id: 1,\n      \"current.modified\": 1\n    }\n  }).observeChanges({\n    changed: function(id) {\n      return self.changed(\"form_versions\", versionId, getFormVersion(id, versionId));\n    }\n  });\n  self.added(\"form_versions\", versionId, getFormVersion(formId, versionId));\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n","Meteor.publish 'instance_data', (instanceId, box)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless (instanceId && db.instances.find({_id: instanceId}).count())\n\t\treturn this.ready()\n\n\tself = this;\n\n\tminiApproveFields = ['_id', 'is_finished', 'user', 'handler', 'handler_name', 'type', 'start_date', 'description',\n\t\t'is_read', 'judge', 'finish_date', 'from_user_name', 'from_user', 'cc_description', 'auto_submitted']\n\n\ttriggerChangeFields = ['form_version', 'flow_version', 'related_instances', '_my_approve_read_dates', 'values', 'change_time']\n\n\ttriggerChangeFieldsValues = {}\n\n\tinstance_fields_0 = {\n\t\t\"record_synced\": 0,\n\n#\t\t\"traces.approves.handler_organization_fullname\": 0,\n\t\t\"traces.approves.handler_organization_name\": 0,\n\t\t\"traces.approves.handler_organization\": 0,\n\t\t\"traces.approves.cost_time\": 0,\n#\t\t\"traces.approves.read_date\": 0,\n\t\t\"traces.approves.is_error\": 0,\n\t\t# \"traces.approves.user_name\": 0,\n\t\t\"traces.approves.deadline\": 0,\n\t\t\"traces.approves.remind_date\": 0,\n\t\t\"traces.approves.reminded_count\": 0,\n\t\t\"traces.approves.modified_by\": 0,\n\t\t\"traces.approves.modified\": 0,\n\t\t\"traces.approves.geolocation\": 0,\n\t\t\"traces.approves.cc_users\": 0,\n\t\t\"traces.approves.from_approve_id\": 0,\n\t\t\"traces.approves.values_history\": 0\n\t}\n\n\tgetMyapproveModified = (traces)->\n\t\tmyApproveModifieds = new Array()\n\n\t\ttraces?.forEach (trace)->\n\t\t\ttrace?.approves?.forEach (approve)->\n\t\t\t\tif (approve.user == self.userId || approve.handler == self.userId)\n\t\t\t\t# && !approve.is_finished\n#\t\t\t\t\tconsole.log(\"approve\", approve._id, approve.read_date)\n\n\t\t\t\t\tmyApproveModifieds.push(approve.read_date)\n\n\t\treturn myApproveModifieds\n\n\n\tgetMiniInstance = (_instanceId)->\n\t\tinstance = db.instances.findOne({_id: _instanceId}, {fields: instance_fields_0})\n\n\t\tif instance\n\n\t\t\ttriggerChangeFields.forEach (key)->\n\t\t\t\tif key == '_my_approve_read_dates'\n\t\t\t\t\ttriggerChangeFieldsValues[key] = getMyapproveModified(instance.traces)\n\t\t\t\telse\n\t\t\t\t\ttriggerChangeFieldsValues[key] = instance[key]\n\n#\t\t\thasOpinionField = InstanceSignText.includesOpinionField(instance.form, instance.form_version)\n\n\t\t\tshow_modal_traces_list = db.space_settings.findOne({ space: instance.space, key: \"show_modal_traces_list\" }, { fields: { values: 1 } })?.values || false\n\n\t\t\tif show_modal_traces_list\n\n\t\t\t\ttraces = new Array();\n\n\t\t\t\tinstance?.traces?.forEach (trace)->\n\t\t\t\t\t_trace = _.clone(trace)\n\n\t\t\t\t\tapproves = new Array()\n\n\t\t\t\t\ttrace?.approves?.forEach (approve)->\n\t\t\t\t\t\tif approve.type != 'cc' || approve.user == self.userId || approve.handler == self.userId || (!_.isEmpty(approve.sign_field_code))\n\t\t\t\t\t\t\tapproves.push(approve)\n\n\t\t\t\t\t_trace.approves = approves\n\n\t\t\t\t\ttraces.push(_trace)\n\n\t\t\t\tinstance.traces = traces;\n\n\t\treturn instance\n\n\n\tneedChange = (changeFields)->\n\t\tif changeFields\n\n\t\t\t_change = false\n\n\t\t\t_rev = _.find triggerChangeFields, (key)->\n\t\t\t\t_key = key\n\n\t\t\t\tif key == '_my_approve_read_dates'\n\t\t\t\t\t_key = 'traces'\n\n\t\t\t\tif _.has(changeFields, _key)\n\n\t\t\t\t\tif key == '_my_approve_read_dates'\n\n\t\t\t\t\t\t_my_approve_modifieds = getMyapproveModified(changeFields.traces)\n\n#\t\t\t\t\t\tconsole.log(triggerChangeFieldsValues[key], _my_approve_modifieds)\n\n\t\t\t\t\t\treturn !_.isEqual(triggerChangeFieldsValues[key], _my_approve_modifieds)\n\t\t\t\t\telse\n\t\t\t\t\t\treturn !_.isEqual(triggerChangeFieldsValues[key], changeFields[key])\n\n\t\t\tif _rev\n\t\t\t\t_change = true\n\n#\t\t\tconsole.log(_rev, _change)\n\n\t\t\treturn _change\n\n\t\treturn true\n\t#此处不能添加fields限制，否则会导致数据不实时\n\thandle = db.instances.find({_id: instanceId}).observeChanges {\n\t\tchanged: (id, fields)->\n\t\t\tif(box != 'inbox' || needChange(fields))\n\t\t\t\tself.changed(\"instances\", id, getMiniInstance(id));\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tinstance = getMiniInstance(instanceId)\n\n\tself.added(\"instances\", instance?._id, instance);\n\n\tself.ready();\n\n\tself.onStop ()->\n\t\thandle.stop()\n\n\nMeteor.publish 'instance_traces', (instanceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless instanceId\n\t\treturn this.ready()\n\n\tself = this\n\n\tgetInstanceTraces = (_insId)->\n\t\treturn db.instances.findOne({_id: _insId}, {fields: {_id: 1, traces: 1}})\n\n\n\thandle =  db.instances.find({_id: instanceId}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tself.changed(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n\t}\n\n\tself.added(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()","Meteor.publish('instance_data', function(instanceId, box) {\n  var getMiniInstance, getMyapproveModified, handle, instance, instance_fields_0, miniApproveFields, needChange, self, triggerChangeFields, triggerChangeFieldsValues;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!(instanceId && db.instances.find({\n    _id: instanceId\n  }).count())) {\n    return this.ready();\n  }\n  self = this;\n  miniApproveFields = ['_id', 'is_finished', 'user', 'handler', 'handler_name', 'type', 'start_date', 'description', 'is_read', 'judge', 'finish_date', 'from_user_name', 'from_user', 'cc_description', 'auto_submitted'];\n  triggerChangeFields = ['form_version', 'flow_version', 'related_instances', '_my_approve_read_dates', 'values', 'change_time'];\n  triggerChangeFieldsValues = {};\n  instance_fields_0 = {\n    \"record_synced\": 0,\n    \"traces.approves.handler_organization_name\": 0,\n    \"traces.approves.handler_organization\": 0,\n    \"traces.approves.cost_time\": 0,\n    \"traces.approves.is_error\": 0,\n    \"traces.approves.deadline\": 0,\n    \"traces.approves.remind_date\": 0,\n    \"traces.approves.reminded_count\": 0,\n    \"traces.approves.modified_by\": 0,\n    \"traces.approves.modified\": 0,\n    \"traces.approves.geolocation\": 0,\n    \"traces.approves.cc_users\": 0,\n    \"traces.approves.from_approve_id\": 0,\n    \"traces.approves.values_history\": 0\n  };\n  getMyapproveModified = function(traces) {\n    var myApproveModifieds;\n    myApproveModifieds = new Array();\n    if (traces != null) {\n      traces.forEach(function(trace) {\n        var ref;\n        return trace != null ? (ref = trace.approves) != null ? ref.forEach(function(approve) {\n          if (approve.user === self.userId || approve.handler === self.userId) {\n            return myApproveModifieds.push(approve.read_date);\n          }\n        }) : void 0 : void 0;\n      });\n    }\n    return myApproveModifieds;\n  };\n  getMiniInstance = function(_instanceId) {\n    var instance, ref, ref1, show_modal_traces_list, traces;\n    instance = db.instances.findOne({\n      _id: _instanceId\n    }, {\n      fields: instance_fields_0\n    });\n    if (instance) {\n      triggerChangeFields.forEach(function(key) {\n        if (key === '_my_approve_read_dates') {\n          return triggerChangeFieldsValues[key] = getMyapproveModified(instance.traces);\n        } else {\n          return triggerChangeFieldsValues[key] = instance[key];\n        }\n      });\n      show_modal_traces_list = ((ref = db.space_settings.findOne({\n        space: instance.space,\n        key: \"show_modal_traces_list\"\n      }, {\n        fields: {\n          values: 1\n        }\n      })) != null ? ref.values : void 0) || false;\n      if (show_modal_traces_list) {\n        traces = new Array();\n        if (instance != null) {\n          if ((ref1 = instance.traces) != null) {\n            ref1.forEach(function(trace) {\n              var _trace, approves, ref2;\n              _trace = _.clone(trace);\n              approves = new Array();\n              if (trace != null) {\n                if ((ref2 = trace.approves) != null) {\n                  ref2.forEach(function(approve) {\n                    if (approve.type !== 'cc' || approve.user === self.userId || approve.handler === self.userId || (!_.isEmpty(approve.sign_field_code))) {\n                      return approves.push(approve);\n                    }\n                  });\n                }\n              }\n              _trace.approves = approves;\n              return traces.push(_trace);\n            });\n          }\n        }\n        instance.traces = traces;\n      }\n    }\n    return instance;\n  };\n  needChange = function(changeFields) {\n    var _change, _rev;\n    if (changeFields) {\n      _change = false;\n      _rev = _.find(triggerChangeFields, function(key) {\n        var _key, _my_approve_modifieds;\n        _key = key;\n        if (key === '_my_approve_read_dates') {\n          _key = 'traces';\n        }\n        if (_.has(changeFields, _key)) {\n          if (key === '_my_approve_read_dates') {\n            _my_approve_modifieds = getMyapproveModified(changeFields.traces);\n            return !_.isEqual(triggerChangeFieldsValues[key], _my_approve_modifieds);\n          } else {\n            return !_.isEqual(triggerChangeFieldsValues[key], changeFields[key]);\n          }\n        }\n      });\n      if (_rev) {\n        _change = true;\n      }\n      return _change;\n    }\n    return true;\n  };\n  handle = db.instances.find({\n    _id: instanceId\n  }).observeChanges({\n    changed: function(id, fields) {\n      if (box !== 'inbox' || needChange(fields)) {\n        return self.changed(\"instances\", id, getMiniInstance(id));\n      }\n    },\n    removed: function(id) {\n      return self.removed(\"instances\", id);\n    }\n  });\n  instance = getMiniInstance(instanceId);\n  self.added(\"instances\", instance != null ? instance._id : void 0, instance);\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n\nMeteor.publish('instance_traces', function(instanceId) {\n  var getInstanceTraces, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instanceId) {\n    return this.ready();\n  }\n  self = this;\n  getInstanceTraces = function(_insId) {\n    return db.instances.findOne({\n      _id: _insId\n    }, {\n      fields: {\n        _id: 1,\n        traces: 1\n      }\n    });\n  };\n  handle = db.instances.find({\n    _id: instanceId\n  }).observeChanges({\n    changed: function(id) {\n      return self.changed(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n    }\n  });\n  self.added(\"instance_traces\", instanceId, getInstanceTraces(instanceId));\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n","\n\tMeteor.publish 'instances_list', (spaceId, box, flowId)->\n\n\t\tunless this.userId\n\t\t\treturn this.ready()\n\t\t\n\t\tunless spaceId\n\t\t\treturn this.ready()\n\n\t\tquery = {space: spaceId}\n\t\tif box == \"inbox\"\n\t\t\tquery.inbox_users = this.userId;\n\t\telse if box == \"outbox\"\n\t\t\tquery.outbox_users = this.userId;\n\t\telse if box == \"draft\"\n\t\t\tquery.submitter = this.userId;\n\t\t\tquery.state = \"draft\"\n\t\telse if box == \"pending\"\n\t\t\tquery.submitter = this.userId;\n\t\t\tquery.state = \"pending\"\n\t\telse if box == \"completed\"\n\t\t\tquery.submitter = this.userId;\n\t\t\tquery.state = \"completed\"\n\t\telse if box == \"monitor\"\n\t\t\tquery.flow = flowId;\n\t\t\tquery.state = {$in: [\"pending\",\"completed\"]};\n\t\telse\n\t\t\tquery.state = \"none\"\n\n\t\treturn db.instances.find(query, {fields: {name:1, created:1, form:1, flow: 1, space:1, modified:1, applicant: 1, is_archived:1, form_version: 1, flow_version: 1}})\n\n","Meteor.publish('instances_list', function(spaceId, box, flowId) {\n  var query;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!spaceId) {\n    return this.ready();\n  }\n  query = {\n    space: spaceId\n  };\n  if (box === \"inbox\") {\n    query.inbox_users = this.userId;\n  } else if (box === \"outbox\") {\n    query.outbox_users = this.userId;\n  } else if (box === \"draft\") {\n    query.submitter = this.userId;\n    query.state = \"draft\";\n  } else if (box === \"pending\") {\n    query.submitter = this.userId;\n    query.state = \"pending\";\n  } else if (box === \"completed\") {\n    query.submitter = this.userId;\n    query.state = \"completed\";\n  } else if (box === \"monitor\") {\n    query.flow = flowId;\n    query.state = {\n      $in: [\"pending\", \"completed\"]\n    };\n  } else {\n    query.state = \"none\";\n  }\n  return db.instances.find(query, {\n    fields: {\n      name: 1,\n      created: 1,\n      form: 1,\n      flow: 1,\n      space: 1,\n      modified: 1,\n      applicant: 1,\n      is_archived: 1,\n      form_version: 1,\n      flow_version: 1\n    }\n  });\n});\n","lastFinishedApproveAggregate = (instanceid, userId, dataMap, callback)->\n\toperation = [{\n\t\t\"$match\": {\n\t\t\t\"_id\": instanceid\n\t\t}\n\t}, {\"$project\": {\"name\": 1, \"_approve\": \"$traces.approves\"}}, {\"$unwind\": \"$_approve\"}, {\"$unwind\": \"$_approve\"},\n\t\t{\"$match\": {\"_approve.is_finished\": true, $or:[{\"_approve.handler\": userId},{\"_approve.user\": userId}]}},\n\t\t{\"$group\": {\"_id\": \"$_id\", \"finish_date\": {\"$last\": \"$_approve.finish_date\"}}}\n\t]\n\n\tdb.instances.rawCollection().aggregate(operation).toArray (err, data)->\n\t\tif err\n\t\t\tthrow new Error(err)\n\n\t\tdata.forEach (doc) ->\n\t\t\tdataMap.push doc\n\n\t\tif callback && _.isFunction(callback)\n\t\t\tcallback()\n\t\treturn\n\nasyncLastFinishedApprove = Meteor.wrapAsync(lastFinishedApproveAggregate)\n\nMeteor.publish \"instance_tabular\", (tableName, ids, fields)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tcheck(tableName, String);\n\n\tcheck(ids, Array);\n\n\tcheck(fields, Match.Optional(Object))\n\n\tfields.cc_users = 1\n\n\tself = this;\n\n\tgetMyLastFinishedApprove = (userId, instanceId)->\n\t\tdata = []\n\t\tasyncLastFinishedApprove(instanceId, userId, data)\n\t\tif data.length > 0\n\t\t\treturn data[0]\n\n\n\tgetMyApprove = (userId, instanceId)->\n\t\tinstance = db.instances.findOne({_id: instanceId}, {fields: {traces: 1}})\n\t\tmyApprove = null\n\n\t\tif !instance\n\t\t\treturn\n\n\t\tif !instance.traces || instance.traces.length < 1\n\t\t\treturn\n\n\t\tnotFinishedTraces = instance.traces.filterProperty(\"is_finished\", false)\n\n\t\tif notFinishedTraces.length > 0\n\t\t\tapproves = notFinishedTraces[0].approves.filterProperty(\"is_finished\", false).filterProperty(\"handler\", userId);\n\n\t\t\tif approves.length > 0\n\t\t\t\tapprove = approves[0]\n\t\t\t\tmyApprove = {\n\t\t\t\t\tid: approve._id,\n\t\t\t\t\tinstance: approve.instance,\n\t\t\t\t\ttrace: approve.trace,\n\t\t\t\t\tis_read: approve.is_read,\n\t\t\t\t\tstart_date: approve.start_date\n\t\t\t\t\tagent: approve.agent\n\t\t\t\t\tuser_name: approve.user_name\n\t\t\t\t}\n\n\t\tif !myApprove\n\t\t\tis_read = false\n\t\t\tinstance.traces.forEach (trace) ->\n\t\t\t\ttrace?.approves?.forEach (approve) ->\n\t\t\t\t\tif approve.type == 'cc' and approve.user == userId and approve.is_finished == false\n\t\t\t\t\t\tif approve.is_read\n\t\t\t\t\t\t\tis_read = true\n\t\t\t\t\t\tmyApprove = {id: approve._id, is_read: is_read, start_date: approve.start_date, agent: approve.agent, user_name: approve.user_name}\n\n\t\treturn myApprove\n\n\tgetStepCurrentName = (instanceId) ->\n\t\tinstance = db.instances.findOne({_id: instanceId}, {fields: {\"traces.name\": 1, \"traces\": {$slice: -1}}})\n\t\tif instance\n\t\t\tstepCurrentName = instance.traces?[0]?.name\n\n\t\treturn stepCurrentName\n\n\thandle = db.instances.find({_id: {$in: ids}}, {fields: {traces: 0}}).observeChanges {\n\t\tchanged: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tmyApprove = getMyApprove(self.userId, id)\n\t\t\tmyLastFinishedApprove = getMyLastFinishedApprove(self.userId, id)\n\t\t\tif myApprove\n\t\t\t\tinstance.is_read = myApprove.is_read\n\t\t\t\tinstance.start_date = myApprove.start_date\n\t\t\t\tif myApprove.agent\n\t\t\t\t\tinstance.agent_user_name = myApprove.user_name\n\t\t\telse\n\t\t\t\tinstance.is_read = true\n\n\t\t\tif myLastFinishedApprove\n\t\t\t\tinstance.my_finish_date = myLastFinishedApprove.finish_date\n\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tinstance.cc_count = instance.cc_users?.length || 0\n\t\t\tdelete instance.cc_users\n\t\t\ttry\n\t\t\t\tself.changed(\"instances\", id, instance);\n\t\t\tcatch error\n\t\t\t\tconsole.log('instance observeChanges error: ', error.message);\n\t\t\t\tconsole.log('self.userId: ', self.userId);\n\t\t\t\tconsole.log('tableName: ', tableName);\n\t\t\t\tconsole.log('ids: ', JSON.stringify(ids));\n\t\t\t\tconsole.log('myApprove: ', JSON.stringify(myApprove));\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tids.forEach (id)->\n\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\treturn if not instance\n\t\tmyApprove = getMyApprove(self.userId, id)\n\t\tmyLastFinishedApprove = getMyLastFinishedApprove(self.userId, id)\n\t\tif myApprove\n\t\t\tinstance.is_read = myApprove.is_read\n\t\t\tinstance.start_date = myApprove.start_date\n\t\t\tif myApprove.agent\n\t\t\t\t\tinstance.agent_user_name = myApprove.user_name\n\t\telse\n\t\t\tinstance.is_read = true\n\n\t\tif myLastFinishedApprove\n\t\t\tinstance.my_finish_date = myLastFinishedApprove.finish_date\n\n\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\tinstance.cc_count = instance.cc_users?.length || 0\n\t\tdelete instance.cc_users\n\t\tself.added(\"instances\", id, instance);\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n\nMeteor.publish \"instance_tasks_tabular\", (tabularName, ids, fields)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tcheck(tabularName, String);\n\n\tcheck(ids, Array);\n\n\tcheck(fields, Match.Optional(Object))\n\n\t# console.log('tabularName: ', tabularName);\n\t# console.log('ids: ', JSON.stringify(ids));\n\t# console.log('fields: ', JSON.stringify(fields));\n\n\tdb.instance_tasks.find({\n\t\t_id: {\n\t\t\t$in: ids\n\t\t}\n\t}, {\n\t\tfields: fields\n\t})\n\nMeteor.publish \"instances_tabular\", (tabularName, ids, fields)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tcheck(tabularName, String);\n\n\tcheck(ids, Array);\n\n\tcheck(fields, Match.Optional(Object))\n\n\t# console.log('tabularName: ', tabularName);\n\t# console.log('ids: ', JSON.stringify(ids));\n\t# console.log('fields: ', JSON.stringify(fields));\n\n\tdb.instances.find({\n\t\t_id: {\n\t\t\t$in: ids\n\t\t}\n\t}, {\n\t\tfields: fields\n\t})","var asyncLastFinishedApprove, lastFinishedApproveAggregate;\n\nlastFinishedApproveAggregate = function(instanceid, userId, dataMap, callback) {\n  var operation;\n  operation = [\n    {\n      \"$match\": {\n        \"_id\": instanceid\n      }\n    }, {\n      \"$project\": {\n        \"name\": 1,\n        \"_approve\": \"$traces.approves\"\n      }\n    }, {\n      \"$unwind\": \"$_approve\"\n    }, {\n      \"$unwind\": \"$_approve\"\n    }, {\n      \"$match\": {\n        \"_approve.is_finished\": true,\n        $or: [\n          {\n            \"_approve.handler\": userId\n          }, {\n            \"_approve.user\": userId\n          }\n        ]\n      }\n    }, {\n      \"$group\": {\n        \"_id\": \"$_id\",\n        \"finish_date\": {\n          \"$last\": \"$_approve.finish_date\"\n        }\n      }\n    }\n  ];\n  return db.instances.rawCollection().aggregate(operation).toArray(function(err, data) {\n    if (err) {\n      throw new Error(err);\n    }\n    data.forEach(function(doc) {\n      return dataMap.push(doc);\n    });\n    if (callback && _.isFunction(callback)) {\n      callback();\n    }\n  });\n};\n\nasyncLastFinishedApprove = Meteor.wrapAsync(lastFinishedApproveAggregate);\n\nMeteor.publish(\"instance_tabular\", function(tableName, ids, fields) {\n  var getMyApprove, getMyLastFinishedApprove, getStepCurrentName, handle, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  check(tableName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  fields.cc_users = 1;\n  self = this;\n  getMyLastFinishedApprove = function(userId, instanceId) {\n    var data;\n    data = [];\n    asyncLastFinishedApprove(instanceId, userId, data);\n    if (data.length > 0) {\n      return data[0];\n    }\n  };\n  getMyApprove = function(userId, instanceId) {\n    var approve, approves, instance, is_read, myApprove, notFinishedTraces;\n    instance = db.instances.findOne({\n      _id: instanceId\n    }, {\n      fields: {\n        traces: 1\n      }\n    });\n    myApprove = null;\n    if (!instance) {\n      return;\n    }\n    if (!instance.traces || instance.traces.length < 1) {\n      return;\n    }\n    notFinishedTraces = instance.traces.filterProperty(\"is_finished\", false);\n    if (notFinishedTraces.length > 0) {\n      approves = notFinishedTraces[0].approves.filterProperty(\"is_finished\", false).filterProperty(\"handler\", userId);\n      if (approves.length > 0) {\n        approve = approves[0];\n        myApprove = {\n          id: approve._id,\n          instance: approve.instance,\n          trace: approve.trace,\n          is_read: approve.is_read,\n          start_date: approve.start_date,\n          agent: approve.agent,\n          user_name: approve.user_name\n        };\n      }\n    }\n    if (!myApprove) {\n      is_read = false;\n      instance.traces.forEach(function(trace) {\n        var ref;\n        return trace != null ? (ref = trace.approves) != null ? ref.forEach(function(approve) {\n          if (approve.type === 'cc' && approve.user === userId && approve.is_finished === false) {\n            if (approve.is_read) {\n              is_read = true;\n            }\n            return myApprove = {\n              id: approve._id,\n              is_read: is_read,\n              start_date: approve.start_date,\n              agent: approve.agent,\n              user_name: approve.user_name\n            };\n          }\n        }) : void 0 : void 0;\n      });\n    }\n    return myApprove;\n  };\n  getStepCurrentName = function(instanceId) {\n    var instance, ref, ref1, stepCurrentName;\n    instance = db.instances.findOne({\n      _id: instanceId\n    }, {\n      fields: {\n        \"traces.name\": 1,\n        \"traces\": {\n          $slice: -1\n        }\n      }\n    });\n    if (instance) {\n      stepCurrentName = (ref = instance.traces) != null ? (ref1 = ref[0]) != null ? ref1.name : void 0 : void 0;\n    }\n    return stepCurrentName;\n  };\n  handle = db.instances.find({\n    _id: {\n      $in: ids\n    }\n  }, {\n    fields: {\n      traces: 0\n    }\n  }).observeChanges({\n    changed: function(id) {\n      var error, instance, myApprove, myLastFinishedApprove, ref, ref1;\n      instance = db.instances.findOne({\n        _id: id\n      }, {\n        fields: fields\n      });\n      if (!instance) {\n        return;\n      }\n      myApprove = getMyApprove(self.userId, id);\n      myLastFinishedApprove = getMyLastFinishedApprove(self.userId, id);\n      if (myApprove) {\n        instance.is_read = myApprove.is_read;\n        instance.start_date = myApprove.start_date;\n        if (myApprove.agent) {\n          instance.agent_user_name = myApprove.user_name;\n        }\n      } else {\n        instance.is_read = true;\n      }\n      if (myLastFinishedApprove) {\n        instance.my_finish_date = myLastFinishedApprove.finish_date;\n      }\n      instance.is_cc = ((ref = instance.cc_users) != null ? ref.includes(self.userId) : void 0) || false;\n      instance.cc_count = ((ref1 = instance.cc_users) != null ? ref1.length : void 0) || 0;\n      delete instance.cc_users;\n      try {\n        return self.changed(\"instances\", id, instance);\n      } catch (error1) {\n        error = error1;\n        console.log('instance observeChanges error: ', error.message);\n        console.log('self.userId: ', self.userId);\n        console.log('tableName: ', tableName);\n        console.log('ids: ', JSON.stringify(ids));\n        return console.log('myApprove: ', JSON.stringify(myApprove));\n      }\n    },\n    removed: function(id) {\n      return self.removed(\"instances\", id);\n    }\n  });\n  ids.forEach(function(id) {\n    var instance, myApprove, myLastFinishedApprove, ref, ref1;\n    instance = db.instances.findOne({\n      _id: id\n    }, {\n      fields: fields\n    });\n    if (!instance) {\n      return;\n    }\n    myApprove = getMyApprove(self.userId, id);\n    myLastFinishedApprove = getMyLastFinishedApprove(self.userId, id);\n    if (myApprove) {\n      instance.is_read = myApprove.is_read;\n      instance.start_date = myApprove.start_date;\n      if (myApprove.agent) {\n        instance.agent_user_name = myApprove.user_name;\n      }\n    } else {\n      instance.is_read = true;\n    }\n    if (myLastFinishedApprove) {\n      instance.my_finish_date = myLastFinishedApprove.finish_date;\n    }\n    instance.is_cc = ((ref = instance.cc_users) != null ? ref.includes(self.userId) : void 0) || false;\n    instance.cc_count = ((ref1 = instance.cc_users) != null ? ref1.length : void 0) || 0;\n    delete instance.cc_users;\n    return self.added(\"instances\", id, instance);\n  });\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n\nMeteor.publish(\"instance_tasks_tabular\", function(tabularName, ids, fields) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  check(tabularName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  return db.instance_tasks.find({\n    _id: {\n      $in: ids\n    }\n  }, {\n    fields: fields\n  });\n});\n\nMeteor.publish(\"instances_tabular\", function(tabularName, ids, fields) {\n  if (!this.userId) {\n    return this.ready();\n  }\n  check(tabularName, String);\n  check(ids, Array);\n  check(fields, Match.Optional(Object));\n  return db.instances.find({\n    _id: {\n      $in: ids\n    }\n  }, {\n    fields: fields\n  });\n});\n","Meteor.publish 'instances_draft', (spaceId) ->\n\tcheck spaceId, String\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tuserId = this.userId\n\treturn db.instances.find({state:\"draft\",space:spaceId,submitter:userId,$or:[{inbox_users: {$exists:false}}, {inbox_users: []}]}, {fields: {_id: 1, state: 1, space: 1, submitter: 1, inbox_users: 1, modified: 1, name: 1}, sort:{modified: -1}})","Meteor.publish('instances_draft', function(spaceId) {\n  var userId;\n  check(spaceId, String);\n  if (!this.userId) {\n    return this.ready();\n  }\n  userId = this.userId;\n  return db.instances.find({\n    state: \"draft\",\n    space: spaceId,\n    submitter: userId,\n    $or: [\n      {\n        inbox_users: {\n          $exists: false\n        }\n      }, {\n        inbox_users: []\n      }\n    ]\n  }, {\n    fields: {\n      _id: 1,\n      state: 1,\n      space: 1,\n      submitter: 1,\n      inbox_users: 1,\n      modified: 1,\n      name: 1\n    },\n    sort: {\n      modified: -1\n    }\n  });\n});\n","Meteor.publish 'distributed_instances_state_by_ids', (instance_ids)->\n\tcheck(instance_ids, Array)\n\n\tunless this.userId\n\t\treturn this.ready()\n\t\n\tunless instance_ids\n\t\treturn this.ready()\n\n\tif _.isEmpty(instance_ids)\n\t\treturn this.ready()\n\n\tself = this\n\n\thandle = db.instances.find({_id: {$in: instance_ids}}, {fields: {state: 1, traces:{$slice: 1} } }).observeChanges {\n\t\tadded: (id, fields)->\n\t\t\tself.added('instances', id, {state: fields.state, is_read: fields.traces[0].approves[0].is_read})\n\n\t\tchanged: (id, fields)->\n\t\t\tif fields.state\n\t\t\t\tself.changed('instances', id, {state: fields.state})\n\t\t\tif fields.traces\n\t\t\t\tself.changed('instances', id, {is_read: fields.traces[0].approves[0].is_read})\n\t}\n\n\tthis.ready()\n\tthis.onStop ()->\n\t\thandle.stop()\n","Meteor.publish('distributed_instances_state_by_ids', function(instance_ids) {\n  var handle, self;\n  check(instance_ids, Array);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instance_ids) {\n    return this.ready();\n  }\n  if (_.isEmpty(instance_ids)) {\n    return this.ready();\n  }\n  self = this;\n  handle = db.instances.find({\n    _id: {\n      $in: instance_ids\n    }\n  }, {\n    fields: {\n      state: 1,\n      traces: {\n        $slice: 1\n      }\n    }\n  }).observeChanges({\n    added: function(id, fields) {\n      return self.added('instances', id, {\n        state: fields.state,\n        is_read: fields.traces[0].approves[0].is_read\n      });\n    },\n    changed: function(id, fields) {\n      if (fields.state) {\n        self.changed('instances', id, {\n          state: fields.state\n        });\n      }\n      if (fields.traces) {\n        return self.changed('instances', id, {\n          is_read: fields.traces[0].approves[0].is_read\n        });\n      }\n    }\n  });\n  this.ready();\n  return this.onStop(function() {\n    return handle.stop();\n  });\n});\n","Meteor.publish 'related_instaces', (instanceId, related_instances)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless instanceId\n\t\treturn this.ready()\n\n\trelated_instance_ids = db.instances.findOne(instanceId,{fields: {related_instances: 1}})?.related_instances\n\n\tif related_instance_ids && _.isArray(related_instance_ids)\n\t\treturn db.instances.find({_id: {$in : related_instance_ids}}, {fields: {_id: 1, name: 1, space: 1}})\n\telse\n\t\treturn this.ready()","Meteor.publish('related_instaces', function(instanceId, related_instances) {\n  var ref, related_instance_ids;\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!instanceId) {\n    return this.ready();\n  }\n  related_instance_ids = (ref = db.instances.findOne(instanceId, {\n    fields: {\n      related_instances: 1\n    }\n  })) != null ? ref.related_instances : void 0;\n  if (related_instance_ids && _.isArray(related_instance_ids)) {\n    return db.instances.find({\n      _id: {\n        $in: related_instance_ids\n      }\n    }, {\n      fields: {\n        _id: 1,\n        name: 1,\n        space: 1\n      }\n    });\n  } else {\n    return this.ready();\n  }\n});\n","if Meteor.isServer\n    Meteor.publish 'space_user_signs', (spaceId) ->\n        check spaceId, String\n\n        unless this.userId\n            return this.ready()\n\n        return db.space_user_signs.find({ space: spaceId }, {fields: {created_by: 0, created: 0, modified_by: 0}})\n","if (Meteor.isServer) {\n  Meteor.publish('space_user_signs', function(spaceId) {\n    check(spaceId, String);\n    if (!this.userId) {\n      return this.ready();\n    }\n    return db.space_user_signs.find({\n      space: spaceId\n    }, {\n      fields: {\n        created_by: 0,\n        created: 0,\n        modified_by: 0\n      }\n    });\n  });\n}\n","###\nMeteor.publishComposite \"user_inbox_instance\", ()->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tuserSpaceIds = db.space_users.find({\n\t\tuser: this.userId,\n\t\tuser_accepted: true\n\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\tquery = {space: {$in: userSpaceIds}}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfind: ->\n\t\tdb.instances.find(query, {\n\t\t\tfields: {\n\t\t\t\tspace: 1,\n\t\t\t\tapplicant_name: 1,\n\t\t\t\tflow: 1,\n\t\t\t\tinbox_users: 1,\n\t\t\t\tcc_users: 1,\n\t\t\t\tstate: 1,\n\t\t\t\tname: 1,\n\t\t\t\tmodified: 1,\n\t\t\t\tform: 1\n\t\t\t}, sort: {modified: -1}, skip: 0, limit: 200\n\t\t});\n\tchildren: [\n\t\t{\n\t\t\tfind: (instance, post)->\n\t\t\t\tdb.flows.find({_id: instance.flow}, {fields: {name: 1, space: 1}});\n\t\t}\n\t]\n###\n\n###\nMeteor.publish 'my_inbox_instances', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tself = this;\n\n\t#\tuserSpaceIds = db.space_users.find({\n\t#\t\tuser: this.userId,\n\t#\t\tuser_accepted: true\n\t#\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\n\tquery = {space: spaceId}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfields = {\n\t\tspace: 1,\n#\t\tapplicant_name: 1,\n\t\tflow: 1,\n\t\tinbox_users: 1,\n\t\tcc_users: 1,\n\t\tstate: 1,\n#\t\tname: 1,\n#\t\tmodified: 1,\n\t\tform: 1\n\t}\n\n\thandle = db.instances.find(query, {sort: {modified: -1}, skip: 0, limit: 500}).observeChanges {\n\t\tadded: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.added(\"instances\", id, instance)\n\t\tchanged: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.changed(\"instances\", id, instance);\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n###\n\n_get_flow_instances_aggregate = (spaceId, userId, _items, callback)->\n\tdb.instances.rawCollection().aggregate([\n\t\t{\n\t\t\t$match: {\n\t\t\t\tspace: spaceId,\n\t\t\t\t$or: [{inbox_users: userId}, {cc_users: userId}]\n\t\t\t}\n\t\t},\n\t\t{\n\t\t\t$group: {\n\t\t\t\t_id: {flow: \"$flow\", category: \"$category\"}, count: {$sum: 1}\n\t\t\t}\n\t\t}\n\t]).toArray (err, data)->\n\t\tif err\n\t\t\tthrow new Error(err)\n\n\t\tdata.forEach (doc) ->\n\t\t\t_items.push doc\n\n\t\tif callback && _.isFunction(callback)\n\t\t\tcallback()\n\t\treturn\n\n_async_get_flow_instances_aggregate = Meteor.wrapAsync(_get_flow_instances_aggregate)\n\nMeteor.publish 'my_inbox_flow_instances_count', (spaceId)->\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tself = this;\n\n\tquery = {space: spaceId}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tdata = []  #数据格式：[{_id:flowId, count: 待办数量}, {_id:flowId2, count: 待办数量2}]\n\t_async_get_flow_instances_aggregate(spaceId, self.userId, data)\n\n\t_flowsData = []\n\n\t_.each data, (dataItem)->\n\t\t_flowsData.push({_id: dataItem._id.flow, category: dataItem._id.category, count: dataItem.count})\n\n\tself.added(\"flow_instances\", spaceId, {flows: _flowsData});\n\n\t_changeData = (doc, action)->\n\t\tflow_instance = _.find _flowsData, (f)->\n\t\t\treturn f._id == doc.flow\n\t\tif flow_instance\n\t\t\tif action == \"added\"\n\t\t\t\tflow_instance.count++\n\t\t\telse if action == \"removed\"\n\t\t\t\tflow_instance.count--\n\t\telse if action == \"added\"\n\t\t\t_flowsData.push {_id: doc.flow, category: doc.category, count: 1}\n\n\t\tself.changed(\"flow_instances\", spaceId, {flows: _flowsData});\n\n\t_init = true\n\thandle = db.instances.find(query, {fields: {_id: 1, inbox_users: 1, cc_users: 1, flow: 1, category: 1}}).observe {\n\t\tadded: (doc)->\n\t\t\tif !_init\n\t\t\t\t_changeData(doc, \"added\")\n\t\tremoved: (doc)->\n\t\t\tif !_init\n\t\t\t\t_changeData(doc, \"removed\")\n\t}\n\t_init = false\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()","\n/*\nMeteor.publishComposite \"user_inbox_instance\", ()->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tuserSpaceIds = db.space_users.find({\n\t\tuser: this.userId,\n\t\tuser_accepted: true\n\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\tquery = {space: {$in: userSpaceIds}}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfind: ->\n\t\tdb.instances.find(query, {\n\t\t\tfields: {\n\t\t\t\tspace: 1,\n\t\t\t\tapplicant_name: 1,\n\t\t\t\tflow: 1,\n\t\t\t\tinbox_users: 1,\n\t\t\t\tcc_users: 1,\n\t\t\t\tstate: 1,\n\t\t\t\tname: 1,\n\t\t\t\tmodified: 1,\n\t\t\t\tform: 1\n\t\t\t}, sort: {modified: -1}, skip: 0, limit: 200\n\t\t});\n\tchildren: [\n\t\t{\n\t\t\tfind: (instance, post)->\n\t\t\t\tdb.flows.find({_id: instance.flow}, {fields: {name: 1, space: 1}});\n\t\t}\n\t]\n */\n\n/*\nMeteor.publish 'my_inbox_instances', (spaceId)->\n\tunless this.userId\n\t\treturn this.ready()\n\n\tself = this;\n\n\t *\tuserSpaceIds = db.space_users.find({\n\t *\t\tuser: this.userId,\n\t *\t\tuser_accepted: true\n\t *\t}, {fields: {space: 1}}).fetch().getEach(\"space\");\n\n\tquery = {space: spaceId}\n\n\tquery.$or = [{inbox_users: this.userId}, {cc_users: this.userId}]\n\n\tfields = {\n\t\tspace: 1,\n *\t\tapplicant_name: 1,\n\t\tflow: 1,\n\t\tinbox_users: 1,\n\t\tcc_users: 1,\n\t\tstate: 1,\n *\t\tname: 1,\n *\t\tmodified: 1,\n\t\tform: 1\n\t}\n\n\thandle = db.instances.find(query, {sort: {modified: -1}, skip: 0, limit: 500}).observeChanges {\n\t\tadded: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.added(\"instances\", id, instance)\n\t\tchanged: (id)->\n\t\t\tinstance = db.instances.findOne({_id: id}, {fields: fields})\n\t\t\treturn if not instance\n\t\t\tinstance.is_cc = instance.cc_users?.includes(self.userId) || false\n\t\t\tdelete instance.cc_users\n\t\t\tself.changed(\"instances\", id, instance);\n\t\tremoved: (id)->\n\t\t\tself.removed(\"instances\", id);\n\t}\n\n\tself.ready();\n\tself.onStop ()->\n\t\thandle.stop()\n */\nvar _async_get_flow_instances_aggregate, _get_flow_instances_aggregate;\n\n_get_flow_instances_aggregate = function(spaceId, userId, _items, callback) {\n  return db.instances.rawCollection().aggregate([\n    {\n      $match: {\n        space: spaceId,\n        $or: [\n          {\n            inbox_users: userId\n          }, {\n            cc_users: userId\n          }\n        ]\n      }\n    }, {\n      $group: {\n        _id: {\n          flow: \"$flow\",\n          category: \"$category\"\n        },\n        count: {\n          $sum: 1\n        }\n      }\n    }\n  ]).toArray(function(err, data) {\n    if (err) {\n      throw new Error(err);\n    }\n    data.forEach(function(doc) {\n      return _items.push(doc);\n    });\n    if (callback && _.isFunction(callback)) {\n      callback();\n    }\n  });\n};\n\n_async_get_flow_instances_aggregate = Meteor.wrapAsync(_get_flow_instances_aggregate);\n\nMeteor.publish('my_inbox_flow_instances_count', function(spaceId) {\n  var _changeData, _flowsData, _init, data, handle, query, self;\n  if (!this.userId) {\n    return this.ready();\n  }\n  self = this;\n  query = {\n    space: spaceId\n  };\n  query.$or = [\n    {\n      inbox_users: this.userId\n    }, {\n      cc_users: this.userId\n    }\n  ];\n  data = [];\n  _async_get_flow_instances_aggregate(spaceId, self.userId, data);\n  _flowsData = [];\n  _.each(data, function(dataItem) {\n    return _flowsData.push({\n      _id: dataItem._id.flow,\n      category: dataItem._id.category,\n      count: dataItem.count\n    });\n  });\n  self.added(\"flow_instances\", spaceId, {\n    flows: _flowsData\n  });\n  _changeData = function(doc, action) {\n    var flow_instance;\n    flow_instance = _.find(_flowsData, function(f) {\n      return f._id === doc.flow;\n    });\n    if (flow_instance) {\n      if (action === \"added\") {\n        flow_instance.count++;\n      } else if (action === \"removed\") {\n        flow_instance.count--;\n      }\n    } else if (action === \"added\") {\n      _flowsData.push({\n        _id: doc.flow,\n        category: doc.category,\n        count: 1\n      });\n    }\n    return self.changed(\"flow_instances\", spaceId, {\n      flows: _flowsData\n    });\n  };\n  _init = true;\n  handle = db.instances.find(query, {\n    fields: {\n      _id: 1,\n      inbox_users: 1,\n      cc_users: 1,\n      flow: 1,\n      category: 1\n    }\n  }).observe({\n    added: function(doc) {\n      if (!_init) {\n        return _changeData(doc, \"added\");\n      }\n    },\n    removed: function(doc) {\n      if (!_init) {\n        return _changeData(doc, \"removed\");\n      }\n    }\n  });\n  _init = false;\n  self.ready();\n  return self.onStop(function() {\n    return handle.stop();\n  });\n});\n","\nMeteor.publish 'flow_main_attach_template', (spaceId, flowId)->\n\tcheck(spaceId, String)\n\tcheck(flowId, String)\n\n\tunless this.userId\n\t\treturn this.ready()\n\n\tunless spaceId && flowId\n\t\treturn this.ready()\n\n\treturn Creator.getCollection('cms_files').find({ space: spaceId, 'parent.o': 'flows', 'parent.ids': flowId,  name: '正文.docx' })\n","Meteor.publish('flow_main_attach_template', function(spaceId, flowId) {\n  check(spaceId, String);\n  check(flowId, String);\n  if (!this.userId) {\n    return this.ready();\n  }\n  if (!(spaceId && flowId)) {\n    return this.ready();\n  }\n  return Creator.getCollection('cms_files').find({\n    space: spaceId,\n    'parent.o': 'flows',\n    'parent.ids': flowId,\n    name: '正文.docx'\n  });\n});\n","workflowTemplate = {}\n\n#可用此脚本从模板工作区做批量导出：\n#使用管理员账户登录后，进入FlowModules，在控制台执行以下脚本即可\n#db.forms.find({state:\"enabled\"}).forEach(function(form){window.open(Meteor.absoluteUrl(\"api/workflow/export/form?form=\"+form._id))})\nworkflowTemplate[\"en\"] =[]\n\n#可用此脚本从模板工作区做批量导出：\n#使用管理员账户登录后，进入模板专区，在控制台执行以下脚本即可\n#db.forms.find({state:\"enabled\"}).forEach(function(form){window.open(Meteor.absoluteUrl(\"api/workflow/export/form?form=\"+form._id))})\nworkflowTemplate[\"zh-CN\"] =[]\n\nMeteor.startup ()->\n\tfs = require('fs')\n\tpath = require('path')\n\tmime = require('mime')\n\treadFileList = (pathDir, filesList)->\n\t\tfiles = fs.readdirSync(pathDir)\n\t\tfiles.forEach (name, index)->\n\t\t\tstat = fs.statSync(path.join(pathDir, name))\n\t\t\tif stat.isDirectory()\n\t\t\t\t# 递归读取文件\n\t\t\t\treadFileList(path.join(pathDir, name), filesList)\n\t\t\telse\n\t\t\t\tobj = {}\n\t\t\t\tobj.path = pathDir\n\t\t\t\tobj.name = name\n\t\t\t\tfilesList.push(obj)\n\n\t#获取zh-cn文件夹下的所有文件\n\tfilesList_cn = []\n\tpath_cn = Meteor.settings.workflowTemplates?.path_cn\n\tif path_cn\n\t\tabsolute_path_cn = path.resolve(path_cn)\n\t\tconsole.log \"absolute_path_cn\", absolute_path_cn\n\t\tif fs.existsSync(absolute_path_cn)\n\t\t\treadFileList(absolute_path_cn, filesList_cn)\n\t\t\tfilesList_cn.forEach (file)->\n\t\t\t\ttry\n\t\t\t\t\tif mime.getType(file.name) is \"application/json\"\n\t\t\t\t\t\tdata = fs.readFileSync(path.join(file.path, file.name), 'utf8')\n\t\t\t\t\t\tworkflowTemplate[\"zh-CN\"].push(JSON.parse(data))\n\t\t\t\tcatch e\n\t\t\t\t\tconsole.error \"获取zh-cn文件夹下的所有文件\", path.join(file.path, file.name)\n\t\t\t\t\tconsole.error e.stack\n\n\t#获取en-us文件夹下的所有文件\n\tfilesList_us = []\n\tpath_us = Meteor.settings.workflowTemplates?.path_us\n\tif path_us\n\t\tabsolute_path_us = path.resolve(path_us)\n\t\tconsole.log \"absolute_path_us\", absolute_path_us\n\t\tif fs.existsSync(absolute_path_us)\n\t\t\treadFileList(absolute_path_us, filesList_us)\n\t\t\tfilesList_us.forEach (file)->\n\t\t\t\ttry\n\t\t\t\t\tif mime.getType(file.name) is \"application/json\"\n\t\t\t\t\t\tdata = fs.readFileSync(path.join(file.path, file.name), 'utf8')\n\t\t\t\t\t\tworkflowTemplate[\"en\"].push(JSON.parse(data))\n\t\t\t\tcatch e\n\t\t\t\t\tconsole.error \"获取en-us文件夹下的所有文件\", path.join(file.path, file.name)\n\t\t\t\t\tconsole.error e.stack\n\t\t\t\t\n\t\t\t\t\t\n\n\n","                     \n\nworkflowTemplate = {};\n\nworkflowTemplate[\"en\"] = [];\n\nworkflowTemplate[\"zh-CN\"] = [];\n\nMeteor.startup(function() {\n  var absolute_path_cn, absolute_path_us, filesList_cn, filesList_us, fs, mime, path, path_cn, path_us, readFileList, ref, ref1;\n  fs = require('fs');\n  path = require('path');\n  mime = require('mime');\n  readFileList = function(pathDir, filesList) {\n    var files;\n    files = fs.readdirSync(pathDir);\n    return files.forEach(function(name, index) {\n      var obj, stat;\n      stat = fs.statSync(path.join(pathDir, name));\n      if (stat.isDirectory()) {\n        return readFileList(path.join(pathDir, name), filesList);\n      } else {\n        obj = {};\n        obj.path = pathDir;\n        obj.name = name;\n        return filesList.push(obj);\n      }\n    });\n  };\n  filesList_cn = [];\n  path_cn = (ref = Meteor.settings.workflowTemplates) != null ? ref.path_cn : void 0;\n  if (path_cn) {\n    absolute_path_cn = path.resolve(path_cn);\n    console.log(\"absolute_path_cn\", absolute_path_cn);\n    if (fs.existsSync(absolute_path_cn)) {\n      readFileList(absolute_path_cn, filesList_cn);\n      filesList_cn.forEach(function(file) {\n        var data, e;\n        try {\n          if (mime.getType(file.name) === \"application/json\") {\n            data = fs.readFileSync(path.join(file.path, file.name), 'utf8');\n            return workflowTemplate[\"zh-CN\"].push(JSON.parse(data));\n          }\n        } catch (error) {\n          e = error;\n          console.error(\"获取zh-cn文件夹下的所有文件\", path.join(file.path, file.name));\n          return console.error(e.stack);\n        }\n      });\n    }\n  }\n  filesList_us = [];\n  path_us = (ref1 = Meteor.settings.workflowTemplates) != null ? ref1.path_us : void 0;\n  if (path_us) {\n    absolute_path_us = path.resolve(path_us);\n    console.log(\"absolute_path_us\", absolute_path_us);\n    if (fs.existsSync(absolute_path_us)) {\n      readFileList(absolute_path_us, filesList_us);\n      return filesList_us.forEach(function(file) {\n        var data, e;\n        try {\n          if (mime.getType(file.name) === \"application/json\") {\n            data = fs.readFileSync(path.join(file.path, file.name), 'utf8');\n            return workflowTemplate[\"en\"].push(JSON.parse(data));\n          }\n        } catch (error) {\n          e = error;\n          console.error(\"获取en-us文件夹下的所有文件\", path.join(file.path, file.name));\n          return console.error(e.stack);\n        }\n      });\n    }\n  }\n});\n","###\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n###\nMeteor.startup ->\n\tif Meteor.settings.cron?.auto_finish_process_delegation\n\t\tschedule = require('node-schedule')\n\t\t# 定时执行同步\n\t\trule = Meteor.settings.cron.auto_finish_process_delegation\n\t\tgo_next = true\n\t\tschedule.scheduleJob rule, Meteor.bindEnvironment ()->\n\t\t\ttry\n\t\t\t\tif !go_next\n\t\t\t\t\treturn\n\t\t\t\tgo_next = false\n\t\t\t\tconsole.time 'auto_finish_process_delegation'\n\n\t\t\t\tnow = new Date\n\n\t\t\t\t# 将委托规则设置为不可用\n\t\t\t\tdb.process_delegation_rules.update({ enabled: true, end_time: { $lte: now } }, { $set: { enabled: false } }, { multi :true })\n\n\t\t\t\tconsole.timeEnd 'auto_finish_process_delegation'\n\t\t\t\tgo_next = true\n\n\t\t\tcatch e\n\t\t\t\tconsole.error \"AUTO AUTO_FINISH_PROCESS_DELEGATION ERROR: \"\n\t\t\t\tconsole.error e.stack\n\t\t\t\tgo_next = true\n\n\t\t, (e)->\n\t\t\tconsole.log 'Failed to bind environment: auto_finish_process_delegation.coffee'\n\t\t\tconsole.log e.stack\n","\n/*\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n */\nMeteor.startup(function() {\n  var go_next, ref, rule, schedule;\n  if ((ref = Meteor.settings.cron) != null ? ref.auto_finish_process_delegation : void 0) {\n    schedule = require('node-schedule');\n    rule = Meteor.settings.cron.auto_finish_process_delegation;\n    go_next = true;\n    return schedule.scheduleJob(rule, Meteor.bindEnvironment(function() {\n      var e, now;\n      try {\n        if (!go_next) {\n          return;\n        }\n        go_next = false;\n        console.time('auto_finish_process_delegation');\n        now = new Date;\n        db.process_delegation_rules.update({\n          enabled: true,\n          end_time: {\n            $lte: now\n          }\n        }, {\n          $set: {\n            enabled: false\n          }\n        }, {\n          multi: true\n        });\n        console.timeEnd('auto_finish_process_delegation');\n        return go_next = true;\n      } catch (error) {\n        e = error;\n        console.error(\"AUTO AUTO_FINISH_PROCESS_DELEGATION ERROR: \");\n        console.error(e.stack);\n        return go_next = true;\n      }\n    }, function(e) {\n      console.log('Failed to bind environment: auto_finish_process_delegation.coffee');\n      return console.log(e.stack);\n    }));\n  }\n});\n","###\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n###\nMeteor.startup ->\n\tif Meteor.settings.cron?.timeout_auto_submit\n\t\tschedule = require('node-schedule')\n\t\t# 定时执行同步\n\t\trule = Meteor.settings.cron.timeout_auto_submit\n\t\tgo_next = true\n\t\tschedule.scheduleJob rule, Meteor.bindEnvironment ()->\n\t\t\ttry\n\t\t\t\tif !go_next\n\t\t\t\t\treturn\n\t\t\t\tgo_next = false\n\t\t\t\tconsole.time 'timeout_auto_submit'\n\n\t\t\t\tuuflowManager.timeoutAutoSubmit()\n\n\t\t\t\tconsole.timeEnd 'timeout_auto_submit'\n\t\t\t\tgo_next = true\n\n\t\t\tcatch e\n\t\t\t\tconsole.error \"AUTO TIMEOUT_AUTO_SUBMIT ERROR: \"\n\t\t\t\tconsole.error e.stack\n\t\t\t\tgo_next = true\n\n\t\t, (e)->\n\t\t\tconsole.log 'Failed to bind environment: timeout_auto_submit.coffee'\n\t\t\tconsole.log e.stack\n\nMeteor.methods\n\ttimeout_auto_submit: (ins_id)->\n\t\tuuflowManager.timeoutAutoSubmit(ins_id)\n\t\treturn true\n\n\n","\n/*\n*    *    *    *    *    *\n┬    ┬    ┬    ┬    ┬    ┬\n│    │    │    │    │    |\n│    │    │    │    │    └ day of week (0 - 7) (0 or 7 is Sun)\n│    │    │    │    └───── month (1 - 12)\n│    │    │    └────────── day of month (1 - 31)\n│    │    └─────────────── hour (0 - 23)\n│    └──────────────────── minute (0 - 59)\n└───────────────────────── second (0 - 59, OPTIONAL)\n */\nMeteor.startup(function() {\n  var go_next, ref, rule, schedule;\n  if ((ref = Meteor.settings.cron) != null ? ref.timeout_auto_submit : void 0) {\n    schedule = require('node-schedule');\n    rule = Meteor.settings.cron.timeout_auto_submit;\n    go_next = true;\n    return schedule.scheduleJob(rule, Meteor.bindEnvironment(function() {\n      var e;\n      try {\n        if (!go_next) {\n          return;\n        }\n        go_next = false;\n        console.time('timeout_auto_submit');\n        uuflowManager.timeoutAutoSubmit();\n        console.timeEnd('timeout_auto_submit');\n        return go_next = true;\n      } catch (error) {\n        e = error;\n        console.error(\"AUTO TIMEOUT_AUTO_SUBMIT ERROR: \");\n        console.error(e.stack);\n        return go_next = true;\n      }\n    }, function(e) {\n      console.log('Failed to bind environment: timeout_auto_submit.coffee');\n      return console.log(e.stack);\n    }));\n  }\n});\n\nMeteor.methods({\n  timeout_auto_submit: function(ins_id) {\n    uuflowManager.timeoutAutoSubmit(ins_id);\n    return true;\n  }\n});\n","Meteor.startup ()->\n\tTabularTables.related_instances_tabular = new Tabular.Table\n\t\tname: \"related_instances_tabular\"\n\t\tcollection: db.instances\n\t\tcolumns: [\n\t\t\t{\n\t\t\t\tdata: \"_id\",\n\t\t\t\ttitle: '<input type=\"checkbox\" name=\"reverse\" id=\"reverse\">',\n\t\t\t\torderable: false,\n\t\t\t\twidth: '1px',\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tinput = '<input type=\"checkbox\" class=\"related-instances-list-checkbox\" name=\"related_instances_ids\" id=\"related_instances_ids\" value=\"' + doc._id + '\"'\n\n\t\t\t\t\tif TabularTables.related_instances_tabular.related_instances?.includes(doc._id)\n\t\t\t\t\t\tinput += \" checked \"\n\n\t\t\t\t\tinput += \">\"\n\t\t\t\t\treturn input\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"name\",\n\t\t\t\torderable: false,\n\t\t\t\twidth: '45%',\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\thref = '';\n\t\t\t\t\tif Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())\n\t\t\t\t\t\thref = ''\n\n\t\t\t\t\tabsolute = false\n\n\t\t\t\t\tif Meteor.isServer\n\t\t\t\t\t\tabsolute = this.absolute\n\t\t\t\t\tif absolute\n\t\t\t\t\t\thref = Meteor.absoluteUrl(\"workflow/space/\"+doc.space+\"/view/readonly/\" + doc._id + '?hide_traces=0')\n\t\t\t\t\telse\n\t\t\t\t\t\thref = Steedos.absoluteUrl(\"workflow/space/\"+doc.space+\"/view/readonly/\" + doc._id + '?hide_traces=0')\n\t\t\t\t\treturn \"<a data-id='#{doc._id}' target='_blank' href='\"+href+\"'>\" + doc.name + \"</a>\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_name\",\n\t\t\t\ttitle: t(\"instances_applicant_name\"),\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"flow_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"current_step_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.state == \"completed\"\n\t\t\t\t\t\tjudge = doc.final_decision || \"approved\"\n\n\t\t\t\t\tstep_current_name = doc.current_step_name || ''\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t<div class=\"step-current-state #{judge}\">#{step_current_name}</div>\n\t\t\t\t\t\t\"\"\"\n\t\t\t}\n\t\t]\n\n\t\tdom: \"tp\",\n\t\tlengthChange: false,\n\t\textraFields: [\"state\", \"final_decision\", \"space\", \"keywords\"],\n\t\tpageLength: 10,\n\t\tinfo: false,\n\t\tsearching: true,\n\t\tresponsive:\n\t\t\tdetails: false\n\t\tautoWidth: false,\n\t\tchangeSelector: (selector, userId) ->\n\t\t\tunless userId\n\t\t\t\treturn {_id: -1}\n\n\t\t\tspaceId = selector.space\n\t\t\tunless spaceId\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tspaceId = selector.$and.getProperty('space')[0]\n\t\t\tunless spaceId\n\t\t\t\treturn {_id: -1}\n\t\t\tspace = db.spaces.findOne(spaceId)\n\t\t\tif !space\n\t\t\t\tselector.state = \"none\"\n\t\t\tif !space.admins.includes(userId)\n\n\t\t\t\tflow_ids = []\n\t\t\t\tcurSpaceUser = db.space_users.findOne({\n\t\t\t\t\tspace: spaceId,\n\t\t\t\t\t'user': userId\n\t\t\t\t})\n\t\t\t\tif curSpaceUser\n\t\t\t\t\torganizations = db.organizations.find({\n\t\t\t\t\t\t_id: {\n\t\t\t\t\t\t\t$in: curSpaceUser.organizations\n\t\t\t\t\t\t}\n\t\t\t\t\t}).fetch()\n\t\t\t\t\tflows = db.flows.find({ space: spaceId })\n\t\t\t\t\tflows.forEach (fl)->\n\t\t\t\t\t\tif WorkflowManager.canMonitor(fl, curSpaceUser, organizations) || WorkflowManager.canAdmin(fl, curSpaceUser, organizations)\n\t\t\t\t\t\t\tflow_ids.push(fl._id)\n\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tselector.$and[0].$or = [{submitter: userId}, {applicant: userId}, {inbox_users: userId}, {outbox_users: userId},\n\t\t\t\t\t\t\t{cc_users: userId}, { flow: { $in: flow_ids } }]\n\t\t\t\telse\n\t\t\t\t\t_.extend selector, {\n\t\t\t\t\t\t$or: [{submitter: userId}, {applicant: userId}, {inbox_users: userId}, {outbox_users: userId},\n\t\t\t\t\t\t\t{cc_users: userId}, { flow: { $in: flow_ids } }]\n\t\t\t\t\t}\n\n\t\t\treturn selector","Meteor.startup(function() {\n  return TabularTables.related_instances_tabular = new Tabular.Table({\n    name: \"related_instances_tabular\",\n    collection: db.instances,\n    columns: [\n      {\n        data: \"_id\",\n        title: '<input type=\"checkbox\" name=\"reverse\" id=\"reverse\">',\n        orderable: false,\n        width: '1px',\n        render: function(val, type, doc) {\n          var input, ref;\n          input = '<input type=\"checkbox\" class=\"related-instances-list-checkbox\" name=\"related_instances_ids\" id=\"related_instances_ids\" value=\"' + doc._id + '\"';\n          if ((ref = TabularTables.related_instances_tabular.related_instances) != null ? ref.includes(doc._id) : void 0) {\n            input += \" checked \";\n          }\n          input += \">\";\n          return input;\n        }\n      }, {\n        data: \"name\",\n        orderable: false,\n        width: '45%',\n        render: function(val, type, doc) {\n          var absolute, href;\n          href = '';\n          if (Meteor.isClient && (Steedos.isMobile() || Steedos.isCordova())) {\n            href = '';\n          }\n          absolute = false;\n          if (Meteor.isServer) {\n            absolute = this.absolute;\n          }\n          if (absolute) {\n            href = Meteor.absoluteUrl(\"workflow/space/\" + doc.space + \"/view/readonly/\" + doc._id + '?hide_traces=0');\n          } else {\n            href = Steedos.absoluteUrl(\"workflow/space/\" + doc.space + \"/view/readonly/\" + doc._id + '?hide_traces=0');\n          }\n          return (\"<a data-id='\" + doc._id + \"' target='_blank' href='\") + href + \"'>\" + doc.name + \"</a>\";\n        }\n      }, {\n        data: \"applicant_name\",\n        title: t(\"instances_applicant_name\"),\n        orderable: false\n      }, {\n        data: \"flow_name\",\n        title: t(\"instances_flow\"),\n        orderable: false\n      }, {\n        data: \"current_step_name\",\n        title: t(\"instances_flow\"),\n        render: function(val, type, doc) {\n          var judge, step_current_name;\n          if (doc.state === \"completed\") {\n            judge = doc.final_decision || \"approved\";\n          }\n          step_current_name = doc.current_step_name || '';\n          return \"<div class=\\\"step-current-state \" + judge + \"\\\">\" + step_current_name + \"</div>\";\n        }\n      }\n    ],\n    dom: \"tp\",\n    lengthChange: false,\n    extraFields: [\"state\", \"final_decision\", \"space\", \"keywords\"],\n    pageLength: 10,\n    info: false,\n    searching: true,\n    responsive: {\n      details: false\n    },\n    autoWidth: false,\n    changeSelector: function(selector, userId) {\n      var curSpaceUser, flow_ids, flows, organizations, ref, ref1, space, spaceId;\n      if (!userId) {\n        return {\n          _id: -1\n        };\n      }\n      spaceId = selector.space;\n      if (!spaceId) {\n        if ((selector != null ? (ref = selector.$and) != null ? ref.length : void 0 : void 0) > 0) {\n          spaceId = selector.$and.getProperty('space')[0];\n        }\n      }\n      if (!spaceId) {\n        return {\n          _id: -1\n        };\n      }\n      space = db.spaces.findOne(spaceId);\n      if (!space) {\n        selector.state = \"none\";\n      }\n      if (!space.admins.includes(userId)) {\n        flow_ids = [];\n        curSpaceUser = db.space_users.findOne({\n          space: spaceId,\n          'user': userId\n        });\n        if (curSpaceUser) {\n          organizations = db.organizations.find({\n            _id: {\n              $in: curSpaceUser.organizations\n            }\n          }).fetch();\n          flows = db.flows.find({\n            space: spaceId\n          });\n          flows.forEach(function(fl) {\n            if (WorkflowManager.canMonitor(fl, curSpaceUser, organizations) || WorkflowManager.canAdmin(fl, curSpaceUser, organizations)) {\n              return flow_ids.push(fl._id);\n            }\n          });\n        }\n        if ((selector != null ? (ref1 = selector.$and) != null ? ref1.length : void 0 : void 0) > 0) {\n          selector.$and[0].$or = [\n            {\n              submitter: userId\n            }, {\n              applicant: userId\n            }, {\n              inbox_users: userId\n            }, {\n              outbox_users: userId\n            }, {\n              cc_users: userId\n            }, {\n              flow: {\n                $in: flow_ids\n              }\n            }\n          ];\n        } else {\n          _.extend(selector, {\n            $or: [\n              {\n                submitter: userId\n              }, {\n                applicant: userId\n              }, {\n                inbox_users: userId\n              }, {\n                outbox_users: userId\n              }, {\n                cc_users: userId\n              }, {\n                flow: {\n                  $in: flow_ids\n                }\n              }\n            ]\n          });\n        }\n      }\n      return selector;\n    }\n  });\n});\n","Steedos.subs[\"InstanceTabular\"] = new SubsManager()\n\n\n_handleListFields = (fields) ->\n\tins_fields = new Array();\n\n\tfields?.forEach (f)->\n\t\tif f.type == 'table'\n\t\t\tconsole.log 'ignore opinion field in table'\n\t\telse if f.type == 'section'\n\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\tins_fields.push f1\n\t\telse\n\t\t\tins_fields.push f\n\n\treturn ins_fields\n\n\nupdateTabularTitle = ()->\n\n# 如果columns有加减，请修改Template.instance_list._tableColumns 函数\ninstancesListTableTabular = (flowId, fields)->\n\toptions = {\n\t\tname: \"instances\",\n\t\tcollection: db.instances,\n\t\tpub: \"instance_tabular\",\n\t\tonUnload: ()->\n\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\n\t\tdrawCallback: (settings)->\n\t\t\temptyTd = $(\".dataTables_empty\")\n\t\t\tif emptyTd.length\n\t\t\t\temptyTd[0].colSpan = \"6\"\n\t\t\tif !Steedos.isMobile() && !Steedos.isPad()\n\t\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\t\t\t\t$(\".instance-list\").scrollTop(0).ready ->\n\t\t\t\t\t$(\".instance-list\").perfectScrollbar(\"update\")\n\t\t\telse\n\t\t\t\t$(\".instance-list\").scrollTop(0)\n\n\t\t\ttitle = t \"pager_input_hint\"\n\t\t\tellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a')\n\t\t\tellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click ->\n\t\t\t\tif !$(this).find('input').length\n\t\t\t\t\tinput = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>')\n\t\t\t\t\tif Steedos.isMobile()\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"20px\"\n\t\t\t\t\t\t})\n\t\t\t\t\telse\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"16px\"\n\t\t\t\t\t\t})\n\t\t\t\t\tinput.attr(\"title\", title).attr(\"placeholder\", title)\n\t\t\t\t\t$(this).empty().append input\n\t\t\t\t\tgoPage = (index)->\n\t\t\t\t\t\tif index > 0\n\t\t\t\t\t\t\tpages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength)\n\t\t\t\t\t\t\tif index > pages\n\t\t\t\t\t\t\t\t# 页码超出索引时跳转到最后一页\n\t\t\t\t\t\t\t\tindex = pages\n\t\t\t\t\t\t\tindex--\n\t\t\t\t\t\t\tsettings.oInstance.DataTable().page(index).draw('page')\n\t\t\t\t\tinput.blur (e)->\n\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\tgoPage currentPage\n\t\t\t\t\t\t$(this).parent().html '...'\n\t\t\t\t\tinput.keydown (e)->\n\t\t\t\t\t\tif(e.keyCode.toString() == \"13\")\n\t\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\t\tgoPage currentPage\n\n\t\tcreatedRow: (row, data, dataIndex) ->\n\t\t\tif Meteor.isClient\n\t\t\t\tif data._id == FlowRouter.current().params.instanceId\n\t\t\t\t\trow.setAttribute(\"class\", \"selected\")\n\t\tcolumns: [\n\t\t\t{\n\t\t\t\tdata: \"_id\",\n\t\t\t\torderable: false\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tmodifiedString = moment(doc.modified).format('YYYY-MM-DD');\n\n\t\t\t\t\tmodified = doc.modified\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.state != 'draft'\n\t\t\t\t\t\tmodified = doc.start_date || doc.modified\n\n\t\t\t\t\tif Session.get(\"box\") == 'outbox' || Session.get(\"box\") == 'monitor'\n\t\t\t\t\t\tmodified = doc.submit_date || doc.submit_date\n\n\t\t\t\t\tmodifiedFromNow = Steedos.momentReactiveFromNow(modified);\n\t\t\t\t\tflow_name = doc.flow_name\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.is_cc && !doc.inbox_users?.includes(Meteor.userId()) && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.current_step_name})</span></div>\"\n\t\t\t\t\telse\n\t\t\t\t\t\tif Session.get(\"box\") != 'draft' && doc.current_step_name\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.current_step_name})</span></div>\"\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}</div>\"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\t# isFavoriteSelected = Favorites.isRecordSelected(\"instances\", doc._id)\n\t\t\t\t\t# if Favorites.isRecordSelected(\"instances\", doc._id)\n\t\t\t\t\t# \tunread = '<i class=\"ion ion-ios-star-outline instance-favorite-selected\"></i>'\n\t\t\t\t\t# else \n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIcon = \"\"\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.name}#{cc_view}#{agent_view}\n\t\t\t\t\t\t\t\t\t<span>#{doc.applicant_name}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t<div class='instance-detail'>#{step_current_name_view}\n\t\t\t\t\t\t\t\t\t<span class='instance-modified' title='#{modifiedString}'>#{modifiedFromNow}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\"\"\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_organization_name\",\n\t\t\t\ttitle: t(\"instances_applicant_organization_name\"),\n\t\t\t\tvisible: false,\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"name\",\n\t\t\t\ttitle: t(\"instances_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.is_cc && !doc.inbox_users?.includes(Meteor.userId()) && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.name}#{cc_view}#{agent_view}</div>\n\t\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_name\",\n\t\t\t\ttitle: t(\"instances_applicant_name\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"submit_date\",\n\t\t\t\ttitle: t(\"instances_submit_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.submit_date\n\t\t\t\t\t\treturn moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"flow_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"current_step_name\",\n\t\t\t\ttitle: t(\"instances_step_current_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.state == \"completed\"\n\t\t\t\t\t\tjudge = doc.final_decision || \"approved\"\n\n\t\t\t\t\tstep_current_name = doc.current_step_name || ''\n\n\t\t\t\t\tcc_tag = ''\n\n\t\t\t\t\tif doc.cc_count > 0\n\t\t\t\t\t\tcc_tag = TAPi18n.__('cc_tag')\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t<div class=\"step-current-state #{judge}\">#{step_current_name}#{cc_tag}</div>\n\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\ttitle: t(\"instances_modified\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\treturn moment(doc.modified).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"start_date\",\n\t\t\t\ttitle: t(\"instances_start_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.start_date\n\t\t\t\t\t\treturn moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"my_finish_date\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.my_finish_date\n\t\t\t\t\t\treturn moment(doc.my_finish_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"keywords\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"is_archived\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc?.values?.record_need && doc.values.record_need == \"true\"\n\t\t\t\t\t\tif doc?.is_archived\n\t\t\t\t\t\t\treturn t(\"YES\")\n\t\t\t\t\t\treturn t(\"NO\")\n\t\t\t\tvisible: false\n\t\t\t\torderable: false\n\t\t\t}\n\t\t],\n\t\tdom: do ->\n\t\t\t# 手机上不显示一页显示多少条记录选项\n\t\t\tif Steedos.isMobile()\n\t\t\t\t'tp'\n\t\t\telse\n\t\t\t\t'tpl'\n\t\torder: [[4, \"desc\"]],\n\t\textraFields: [\"form\", \"flow\", \"inbox_users\", \"state\", \"space\", \"applicant\", \"form_version\",\n\t\t\t\"flow_version\", \"is_cc\", \"cc_count\", \"is_read\", \"current_step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n\t\tlengthChange: true,\n\t\tlengthMenu: [10,15,20,25,50,100],\n\t\tpageLength: 10,\n\t\tinfo: false,\n\t\tsearching: true,\n\t\tresponsive:\n\t\t\tdetails: false\n\t\tautoWidth: false,\n\t\tchangeSelector: (selector, userId) ->\n\t\t\tunless userId\n\t\t\t\treturn {_id: -1}\n\t\t\tspace = selector.space\n\t\t\tunless space\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tspace = selector.$and.getProperty('space')[0]\n\t\t\tunless space\n\t\t\t\treturn {_id: -1}\n\t\t\tspace_user = db.space_users.findOne({user: userId, space: space}, {fields: {_id: 1}})\n\t\t\tunless space_user\n\t\t\t\treturn {_id: -1}\n\t\t\treturn selector\n\t\tpagingType: \"numbers\"\n\t\t\n\t\t# getSort: (selector, sort) -> \n\t\t# \tconsole.log('selector:',selector)\n\t\t# \tconsole.log('sort:',sort)\n\t\t# \tnewSort = []\n\t\t# \t_.each selector, (v, k) ->\n\t\t# \t\tnewSort.push([k, 1])\n\t\t# \tnewSort = newSort.concat(sort)\n\t\t# \tconsole.log('newSort:',newSort)\n\t\t# \treturn newSort\n\t}\n\n\tif flowId\n\t\tkey = \"instanceFlow\" + flowId\n\n\t\toptions.name = key\n\n\t\tTabularTables.instances.fields = fields\n\n\t\tins_fields = _handleListFields TabularTables.instances.fields\n\n\t\tins_fields.forEach (f)->\n\t\t\tif f.type != 'table' && f.is_list_display\n\t\t\t\toptions.columns.push\n\t\t\t\t\tdata: (f.name || f.code),\n\t\t\t\t\ttitle: t(f.name || f.code),\n\t\t\t\t\tvisible: false,\n\t\t\t\t\torderable: false\n\t\t\t\t\trender: (val, type, doc) ->\n\n\t\t\t\t\t\tvalues = doc.values || {}\n\n\t\t\t\t\t\tvalue = values[f.code]\n\n\t\t\t\t\t\tswitch f.type\n\t\t\t\t\t\t\twhen 'user'\n\t\t\t\t\t\t\t\tvalue = value?.name\n\t\t\t\t\t\t\twhen 'group'\n\t\t\t\t\t\t\t\tvalue = value?.fullname\n\t\t\t\t\t\t\twhen 'date'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD')\n\t\t\t\t\t\t\twhen 'dateTime'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD HH:mm')\n\t\t\t\t\t\t\twhen 'checkbox'\n\t\t\t\t\t\t\t\tif value == true || value == 'true'\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\");\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\");\n\t\t\t\t\t\t\twhen 'odata'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tif _.isArray(value)\n\t\t\t\t\t\t\t\t\t\tvalue = _.pluck(value, '@label').toString()\n\t\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\t\tvalue = value['@label']\n\n\t\t\t\t\t\treturn value\n\n\n\treturn options;\n\n\n# 如果columns有加减，请修改Template.instance_list._tableColumns 函数\ninstanceTasksListTableTabular = (flowId, fields)->\n\toptions = {\n\t\tname: \"instance_tasks\",\n\t\tcollection: db.instance_tasks,\n\t\tpub: \"instance_tasks_tabular\",\n\t\tonUnload: ()->\n\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\n\t\tdrawCallback: (settings)->\n\t\t\temptyTd = $(\".dataTables_empty\")\n\t\t\tif emptyTd.length\n\t\t\t\temptyTd[0].colSpan = \"6\"\n\t\t\tif !Steedos.isMobile() && !Steedos.isPad()\n\t\t\t\tMeteor.setTimeout(Template.instance_list._tableColumns, 150)\n\t\t\t\t$(\".instance-list\").scrollTop(0).ready ->\n\t\t\t\t\t$(\".instance-list\").perfectScrollbar(\"update\")\n\t\t\telse\n\t\t\t\t$(\".instance-list\").scrollTop(0)\n\n\t\t\ttitle = t \"pager_input_hint\"\n\t\t\tellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a')\n\t\t\tellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click ->\n\t\t\t\tif !$(this).find('input').length\n\t\t\t\t\tinput = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>')\n\t\t\t\t\tif Steedos.isMobile()\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"20px\"\n\t\t\t\t\t\t})\n\t\t\t\t\telse\n\t\t\t\t\t\tinput.css({\n\t\t\t\t\t\t\twidth:\"52px\"\n\t\t\t\t\t\t\theight: \"16px\"\n\t\t\t\t\t\t})\n\t\t\t\t\tinput.attr(\"title\", title).attr(\"placeholder\", title)\n\t\t\t\t\t$(this).empty().append input\n\t\t\t\t\tgoPage = (index)->\n\t\t\t\t\t\tif index > 0\n\t\t\t\t\t\t\tpages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength)\n\t\t\t\t\t\t\tif index > pages\n\t\t\t\t\t\t\t\t# 页码超出索引时跳转到最后一页\n\t\t\t\t\t\t\t\tindex = pages\n\t\t\t\t\t\t\tindex--\n\t\t\t\t\t\t\tsettings.oInstance.DataTable().page(index).draw('page')\n\t\t\t\t\tinput.blur (e)->\n\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\tgoPage currentPage\n\t\t\t\t\t\t$(this).parent().html '...'\n\t\t\t\t\tinput.keydown (e)->\n\t\t\t\t\t\tif(e.keyCode.toString() == \"13\")\n\t\t\t\t\t\t\tcurrentPage = $(this).val()\n\t\t\t\t\t\t\tgoPage currentPage\n\n\t\tcreatedRow: (row, data, dataIndex) ->\n\t\t\tif Meteor.isClient\n\t\t\t\tif data.instance == FlowRouter.current().params.instanceId\n\t\t\t\t\trow.setAttribute(\"class\", \"selected\")\n\t\tcolumns: [\n\t\t\t{\n\t\t\t\tdata: \"_id\",\n\t\t\t\torderable: false\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tmodifiedString = moment(doc.modified).format('YYYY-MM-DD');\n\n\t\t\t\t\tmodified = doc.modified\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.instance_state != 'draft'\n\t\t\t\t\t\tmodified = doc.start_date || doc.modified\n\n\t\t\t\t\tif Session.get(\"box\") == 'outbox'\n\t\t\t\t\t\tmodified = doc.submit_date || doc.modified\n\n\t\t\t\t\tmodifiedFromNow = Steedos.momentReactiveFromNow(modified);\n\t\t\t\t\tflow_name = doc.flow_name\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.type == 'cc' && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.step_name})</span></div>\"\n\t\t\t\t\telse\n\t\t\t\t\t\tif doc.step_name\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}<span>(#{doc.step_name})</span></div>\"\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tstep_current_name_view = \"<div class='flow-name'>#{flow_name}</div>\"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIcon = \"\"\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.instance_name}#{cc_view}#{agent_view}\n\t\t\t\t\t\t\t\t\t<span>#{doc.applicant_name}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t<div class='instance-detail'>#{step_current_name_view}\n\t\t\t\t\t\t\t\t\t<span class='instance-modified' title='#{modifiedString}'>#{modifiedFromNow}</span>\n\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\"\"\"\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_organization_name\",\n\t\t\t\ttitle: t(\"instances_applicant_organization_name\"),\n\t\t\t\tvisible: false,\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"instance_name\",\n\t\t\t\ttitle: t(\"instances_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tcc_view = \"\";\n\t\t\t\t\tstep_current_name_view = \"\";\n\t\t\t\t\t# 当前用户在cc user中，但是不在inbox users时才显示'传阅'文字\n\t\t\t\t\tif doc.is_cc && !doc.inbox_users?.includes(Meteor.userId()) && Session.get(\"box\") == 'inbox'\n\t\t\t\t\t\tcc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \"\n\n\t\t\t\t\tagent_view = \"\";\n\t\t\t\t\tif doc.agent_user_name\n\t\t\t\t\t\tagent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {userName: doc.agent_user_name}) + \")</label>\"\n\n\t\t\t\t\tunread = ''\n\n\t\t\t\t\tif Session.get(\"box\") == 'inbox' && doc.is_read == false\n\t\t\t\t\t\tunread = '<i class=\"ion ion-record unread\"></i>'\n\t\t\t\t\telse if Session.get(\"box\") == 'monitor' && doc.is_hidden == true\n\t\t\t\t\t\tunread = '<i class=\"fa fa-lock\"></i>'\n\n\t\t\t\t\tpriorityIconClass = \"\"\n\t\t\t\t\tpriorityValue = doc.values?.priority\n\t\t\t\t\tswitch priorityValue\n\t\t\t\t\t\twhen \"特急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"danger\"\n\t\t\t\t\t\twhen \"紧急\"\n\t\t\t\t\t\t\tpriorityIconClass = \"warning\"\n\t\t\t\t\t\twhen \"办文\"\n\t\t\t\t\t\t\tpriorityIconClass = \"muted\"\n\t\t\t\t\tif priorityIconClass\n\t\t\t\t\t\tinstanceNamePriorityClass = \"color-priority color-priority-#{priorityIconClass}\"\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t\t<div class='instance-read-bar'>#{unread}</div>\n\t\t\t\t\t\t\t<div class='instance-name #{instanceNamePriorityClass}'>#{doc.instance_name}#{cc_view}#{agent_view}</div>\n\t\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"applicant_name\",\n\t\t\t\ttitle: t(\"instances_applicant_name\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"submit_date\",\n\t\t\t\ttitle: t(\"instances_submit_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.submit_date\n\t\t\t\t\t\treturn moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"flow_name\",\n\t\t\t\ttitle: t(\"instances_flow\"),\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"step_name\",\n\t\t\t\ttitle: t(\"instances_step_current_name\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.instance_state == \"completed\"\n\t\t\t\t\t\tjudge = doc.judge || \"approved\"\n\n\t\t\t\t\tstep_current_name = doc.step_name || ''\n\n\t\t\t\t\tcc_tag = ''\n\n\t\t\t\t\tif doc.cc_count > 0\n\t\t\t\t\t\tcc_tag = TAPi18n.__('cc_tag')\n\n\t\t\t\t\treturn \"\"\"\n\t\t\t\t\t\t<div class=\"step-current-state #{judge}\">#{step_current_name}#{cc_tag}</div>\n\t\t\t\t\t\"\"\"\n\t\t\t\tvisible: false,\n\t\t\t\torderable: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\ttitle: t(\"instances_modified\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\treturn moment(doc.modified).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"start_date\",\n\t\t\t\ttitle: t(\"instances_start_date\"),\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.start_date\n\t\t\t\t\t\treturn moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"finish_date\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc.finish_date\n\t\t\t\t\t\treturn moment(doc.finish_date).format('YYYY-MM-DD HH:mm');\n\t\t\t\t,\n\t\t\t\tvisible: false,\n\t\t\t\torderable: true\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"modified\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"keywords\",\n\t\t\t\tvisible: false\n\t\t\t},\n\t\t\t{\n\t\t\t\tdata: \"is_archived\",\n\t\t\t\trender: (val, type, doc) ->\n\t\t\t\t\tif doc?.values?.record_need && doc.values.record_need == \"true\"\n\t\t\t\t\t\tif doc?.is_archived\n\t\t\t\t\t\t\treturn t(\"YES\")\n\t\t\t\t\t\treturn t(\"NO\")\n\t\t\t\tvisible: false\n\t\t\t\torderable: false\n\t\t\t}\n\t\t],\n\t\tdom: do ->\n\t\t\t# 手机上不显示一页显示多少条记录选项\n\t\t\tif Steedos.isMobile()\n\t\t\t\t'tp'\n\t\t\telse\n\t\t\t\t'tpl'\n\t\torder: [[4, \"desc\"]],\n\t\textraFields: [\"instance\", \"form\", \"flow\", \"inbox_users\", \"instance_state\", \"space\", \"applicant\", \"form_version\",\n\t\t\t\"flow_version\", \"type\", \"is_read\", \"step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n\t\tlengthChange: true,\n\t\tlengthMenu: [10,15,20,25,50,100],\n\t\tpageLength: 10,\n\t\tinfo: false,\n\t\tsearching: true,\n\t\tresponsive:\n\t\t\tdetails: false\n\t\tautoWidth: false,\n\t\tchangeSelector: (selector, userId) ->\n\t\t\tunless userId\n\t\t\t\treturn {_id: -1}\n\t\t\tspace = selector.space\n\t\t\tunless space\n\t\t\t\tif selector?.$and?.length > 0\n\t\t\t\t\tspace = selector.$and.getProperty('space')[0]\n\t\t\tunless space\n\t\t\t\treturn {_id: -1}\n\t\t\tspace_user = db.space_users.findOne({user: userId, space: space}, {fields: {_id: 1}})\n\t\t\tunless space_user\n\t\t\t\treturn {_id: -1}\n\t\t\treturn selector\n\t\tpagingType: \"numbers\"\n\n\t}\n\n\tif flowId\n\t\tkey = \"instanceFlow\" + flowId\n\n\t\toptions.name = key\n\n\t\tTabularTables.instance_tasks.fields = fields\n\n\t\tins_fields = _handleListFields TabularTables.instance_tasks.fields\n\n\t\tins_fields.forEach (f)->\n\t\t\tif f.type != 'table' && f.is_list_display\n\t\t\t\toptions.columns.push\n\t\t\t\t\tdata: (f.name || f.code),\n\t\t\t\t\ttitle: t(f.name || f.code),\n\t\t\t\t\tvisible: false,\n\t\t\t\t\torderable: false\n\t\t\t\t\trender: (val, type, doc) ->\n\n\t\t\t\t\t\tvalues = doc.values || {}\n\n\t\t\t\t\t\tvalue = values[f.code]\n\n\t\t\t\t\t\tswitch f.type\n\t\t\t\t\t\t\twhen 'user'\n\t\t\t\t\t\t\t\tvalue = value?.name\n\t\t\t\t\t\t\twhen 'group'\n\t\t\t\t\t\t\t\tvalue = value?.fullname\n\t\t\t\t\t\t\twhen 'date'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD')\n\t\t\t\t\t\t\twhen 'dateTime'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tvalue = moment(value).format('YYYY-MM-DD HH:mm')\n\t\t\t\t\t\t\twhen 'checkbox'\n\t\t\t\t\t\t\t\tif value == true || value == 'true'\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\");\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\");\n\t\t\t\t\t\t\twhen 'odata'\n\t\t\t\t\t\t\t\tif value\n\t\t\t\t\t\t\t\t\tif _.isArray(value)\n\t\t\t\t\t\t\t\t\t\tvalue = _.pluck(value, '@label').toString()\n\t\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t\t\tvalue = value['@label']\n\n\t\t\t\t\t\treturn value\n\n\n\treturn options;\n\n\nMeteor.startup ()->\n\tTabularTables.instances = new Tabular.Table instancesListTableTabular()\n\tTabularTables.instance_tasks = new Tabular.Table instanceTasksListTableTabular()\n\tTabularTables.inbox_instances = new Tabular.Table GetBoxInstancesTabularOptions(\"inbox\")\n\tTabularTables.outbox_instances = new Tabular.Table GetBoxInstancesTabularOptions(\"outbox\")\n\n\nGetBoxInstancesTabularOptions = (box, flowId, fields)->\n\tkey = \"instanceFlow\" + box + flowId\n\tif box == \"inbox\"\n\t\toptions = _get_inbox_instances_tabular_options(flowId, fields)\n\telse if box == \"outbox\"\n\t\toptions = _get_outbox_instances_tabular_options(flowId, fields)\n\telse\n\t\toptions = instancesListTableTabular(flowId, fields)\n\t\tif !flowId\n\t\t\toptions.name = \"inbox_instances\"\n\tif flowId\n\t\toptions.name = key\n\treturn options\n\n_get_inbox_instances_tabular_options = (flowId, fields)->\n\toptions = instanceTasksListTableTabular(flowId, fields)\n\n\tif !flowId\n\t\toptions.name = \"inbox_instances\"\n\n\toptions.order = [[8, \"desc\"]]\n\n\toptions.getSort = (selector, sort) -> \n\t\tconsole.log('inbox_instances:',sort)\n\t\treturn sort\n\n\treturn options\n\n_get_outbox_instances_tabular_options = (flowId, fields)->\n\toptions = instanceTasksListTableTabular(flowId, fields)\n\n\tif !flowId\n\t\toptions.name = \"outbox_instances\"\n\n\toptions.order = [[9, -1]]\n\n\toptions.getSort = (selector, sort) -> \n\t\tconsole.log('outbox_instances:',sort)\n\t\t# newSort = [ \n\t\t# \t['space', 1],\n\t\t# \t['handler', 1],\n\t\t# \t['is_finished', 1],\n\t\t# ]\n\t\t# newSort = newSort.concat(sort)\n\t\t# return newSort\n\t\treturn sort\n\n\treturn options\n\nif Meteor.isClient\n\tTabularTables.flowInstances = new ReactiveVar()\n\nMeteor.startup ()->\n\tTracker.autorun (c) ->\n\t\tif Meteor.isClient && !Steedos.isMobile()\n\t\t\tif Session.get(\"flowId\") && Session.get(\"box\") != 'draft'\n\t\t\t\tMeteor.call \"newInstancesListTabular\", Session.get(\"box\"), Session.get(\"flowId\"), (error, result) ->\n\t\t\t\t\tnewInstancesListTabular Session.get(\"box\"), Session.get(\"flowId\"), result\n\t\t\t\t\tTemplate.instance_list._changeOrder()\n\n\nnewInstancesListTabular = (box, flowId, fields)->\n\tif !fields\n\t\tflow = db.flows.findOne({_id: flowId}, {fields: {form: 1}})\n\t\tfields = db.forms.findOne({ _id: flow?.form }, { fields: { 'current.fields': 1 } })?.current?.fields\n\n\tfields = _handleListFields fields\n\n\tif fields?.filterProperty(\"is_list_display\", true)?.length > 0\n\t\tkey = \"instanceFlow\" + box + flowId\n\t\tif Meteor.isClient\n\t\t\tTabularTables.flowInstances.set(new Tabular.Table GetBoxInstancesTabularOptions(box, flowId, fields))\n\t\telse\n\t\t\tnew Tabular.Table GetBoxInstancesTabularOptions(box, flowId, fields)\n\t\tconsole.log \"new TabularTables \", key\n\nif Meteor.isServer\n\tMeteor.methods\n\t\tnewInstancesListTabular: (box, flowId)->\n\t\t\tnewInstancesListTabular(box, flowId)\n\n\t\t\tflow = db.flows.findOne({_id: flowId}, {fields: {form: 1}})\n\t\t\tfields = db.forms.findOne({ _id: flow?.form }, { fields: { 'current.fields': 1 } })?.current?.fields\n\t\t\treturn fields\n\n\n","var GetBoxInstancesTabularOptions, _get_inbox_instances_tabular_options, _get_outbox_instances_tabular_options, _handleListFields, instanceTasksListTableTabular, instancesListTableTabular, newInstancesListTabular, updateTabularTitle;\n\nSteedos.subs[\"InstanceTabular\"] = new SubsManager();\n\n_handleListFields = function(fields) {\n  var ins_fields;\n  ins_fields = new Array();\n  if (fields != null) {\n    fields.forEach(function(f) {\n      var ref;\n      if (f.type === 'table') {\n        return console.log('ignore opinion field in table');\n      } else if (f.type === 'section') {\n        return f != null ? (ref = f.fields) != null ? ref.forEach(function(f1) {\n          return ins_fields.push(f1);\n        }) : void 0 : void 0;\n      } else {\n        return ins_fields.push(f);\n      }\n    });\n  }\n  return ins_fields;\n};\n\nupdateTabularTitle = function() {};\n\ninstancesListTableTabular = function(flowId, fields) {\n  var ins_fields, key, options;\n  options = {\n    name: \"instances\",\n    collection: db.instances,\n    pub: \"instance_tabular\",\n    onUnload: function() {\n      return Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n    },\n    drawCallback: function(settings) {\n      var ellipsisLink, emptyTd, title;\n      emptyTd = $(\".dataTables_empty\");\n      if (emptyTd.length) {\n        emptyTd[0].colSpan = \"6\";\n      }\n      if (!Steedos.isMobile() && !Steedos.isPad()) {\n        Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n        $(\".instance-list\").scrollTop(0).ready(function() {\n          return $(\".instance-list\").perfectScrollbar(\"update\");\n        });\n      } else {\n        $(\".instance-list\").scrollTop(0);\n      }\n      title = t(\"pager_input_hint\");\n      ellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a');\n      return ellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click(function() {\n        var goPage, input;\n        if (!$(this).find('input').length) {\n          input = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>');\n          if (Steedos.isMobile()) {\n            input.css({\n              width: \"52px\",\n              height: \"20px\"\n            });\n          } else {\n            input.css({\n              width: \"52px\",\n              height: \"16px\"\n            });\n          }\n          input.attr(\"title\", title).attr(\"placeholder\", title);\n          $(this).empty().append(input);\n          goPage = function(index) {\n            var pages;\n            if (index > 0) {\n              pages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength);\n              if (index > pages) {\n                index = pages;\n              }\n              index--;\n              return settings.oInstance.DataTable().page(index).draw('page');\n            }\n          };\n          input.blur(function(e) {\n            var currentPage;\n            currentPage = $(this).val();\n            goPage(currentPage);\n            return $(this).parent().html('...');\n          });\n          return input.keydown(function(e) {\n            var currentPage;\n            if (e.keyCode.toString() === \"13\") {\n              currentPage = $(this).val();\n              return goPage(currentPage);\n            }\n          });\n        }\n      });\n    },\n    createdRow: function(row, data, dataIndex) {\n      if (Meteor.isClient) {\n        if (data._id === FlowRouter.current().params.instanceId) {\n          return row.setAttribute(\"class\", \"selected\");\n        }\n      }\n    },\n    columns: [\n      {\n        data: \"_id\",\n        orderable: false,\n        render: function(val, type, doc) {\n          var agent_view, cc_view, flow_name, instanceNamePriorityClass, modified, modifiedFromNow, modifiedString, priorityIcon, priorityIconClass, priorityValue, ref, ref1, step_current_name_view, unread;\n          modifiedString = moment(doc.modified).format('YYYY-MM-DD');\n          modified = doc.modified;\n          if (Session.get(\"box\") === 'inbox' && doc.state !== 'draft') {\n            modified = doc.start_date || doc.modified;\n          }\n          if (Session.get(\"box\") === 'outbox' || Session.get(\"box\") === 'monitor') {\n            modified = doc.submit_date || doc.submit_date;\n          }\n          modifiedFromNow = Steedos.momentReactiveFromNow(modified);\n          flow_name = doc.flow_name;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.is_cc && !((ref = doc.inbox_users) != null ? ref.includes(Meteor.userId()) : void 0) && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n            step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.current_step_name + \")</span></div>\";\n          } else {\n            if (Session.get(\"box\") !== 'draft' && doc.current_step_name) {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.current_step_name + \")</span></div>\";\n            } else {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"</div>\";\n            }\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name && Session.get(\"box\") === 'inbox') {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIcon = \"\";\n          priorityIconClass = \"\";\n          priorityValue = (ref1 = doc.values) != null ? ref1.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.name + cc_view + agent_view + \"\\n\t<span>\" + doc.applicant_name + \"</span>\\n</div>\\n<div class='instance-detail'>\" + step_current_name_view + \"\\n\t<span class='instance-modified' title='\" + modifiedString + \"'>\" + modifiedFromNow + \"</span>\\n</div>\";\n        }\n      }, {\n        data: \"applicant_organization_name\",\n        title: t(\"instances_applicant_organization_name\"),\n        visible: false\n      }, {\n        data: \"name\",\n        title: t(\"instances_name\"),\n        render: function(val, type, doc) {\n          var agent_view, cc_view, instanceNamePriorityClass, priorityIconClass, priorityValue, ref, ref1, step_current_name_view, unread;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.is_cc && !((ref = doc.inbox_users) != null ? ref.includes(Meteor.userId()) : void 0) && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name) {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIconClass = \"\";\n          priorityValue = (ref1 = doc.values) != null ? ref1.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.name + cc_view + agent_view + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"applicant_name\",\n        title: t(\"instances_applicant_name\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"submit_date\",\n        title: t(\"instances_submit_date\"),\n        render: function(val, type, doc) {\n          if (doc.submit_date) {\n            return moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"flow_name\",\n        title: t(\"instances_flow\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"current_step_name\",\n        title: t(\"instances_step_current_name\"),\n        render: function(val, type, doc) {\n          var cc_tag, judge, step_current_name;\n          if (doc.state === \"completed\") {\n            judge = doc.final_decision || \"approved\";\n          }\n          step_current_name = doc.current_step_name || '';\n          cc_tag = '';\n          if (doc.cc_count > 0) {\n            cc_tag = TAPi18n.__('cc_tag');\n          }\n          return \"<div class=\\\"step-current-state \" + judge + \"\\\">\" + step_current_name + cc_tag + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"modified\",\n        title: t(\"instances_modified\"),\n        render: function(val, type, doc) {\n          return moment(doc.modified).format('YYYY-MM-DD HH:mm');\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"start_date\",\n        title: t(\"instances_start_date\"),\n        render: function(val, type, doc) {\n          if (doc.start_date) {\n            return moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"my_finish_date\",\n        render: function(val, type, doc) {\n          if (doc.my_finish_date) {\n            return moment(doc.my_finish_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"modified\",\n        visible: false\n      }, {\n        data: \"keywords\",\n        visible: false\n      }, {\n        data: \"is_archived\",\n        render: function(val, type, doc) {\n          var ref;\n          if ((doc != null ? (ref = doc.values) != null ? ref.record_need : void 0 : void 0) && doc.values.record_need === \"true\") {\n            if (doc != null ? doc.is_archived : void 0) {\n              return t(\"YES\");\n            }\n            return t(\"NO\");\n          }\n        },\n        visible: false,\n        orderable: false\n      }\n    ],\n    dom: (function() {\n      if (Steedos.isMobile()) {\n        return 'tp';\n      } else {\n        return 'tpl';\n      }\n    })(),\n    order: [[4, \"desc\"]],\n    extraFields: [\"form\", \"flow\", \"inbox_users\", \"state\", \"space\", \"applicant\", \"form_version\", \"flow_version\", \"is_cc\", \"cc_count\", \"is_read\", \"current_step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n    lengthChange: true,\n    lengthMenu: [10, 15, 20, 25, 50, 100],\n    pageLength: 10,\n    info: false,\n    searching: true,\n    responsive: {\n      details: false\n    },\n    autoWidth: false,\n    changeSelector: function(selector, userId) {\n      var ref, space, space_user;\n      if (!userId) {\n        return {\n          _id: -1\n        };\n      }\n      space = selector.space;\n      if (!space) {\n        if ((selector != null ? (ref = selector.$and) != null ? ref.length : void 0 : void 0) > 0) {\n          space = selector.$and.getProperty('space')[0];\n        }\n      }\n      if (!space) {\n        return {\n          _id: -1\n        };\n      }\n      space_user = db.space_users.findOne({\n        user: userId,\n        space: space\n      }, {\n        fields: {\n          _id: 1\n        }\n      });\n      if (!space_user) {\n        return {\n          _id: -1\n        };\n      }\n      return selector;\n    },\n    pagingType: \"numbers\"\n  };\n  if (flowId) {\n    key = \"instanceFlow\" + flowId;\n    options.name = key;\n    TabularTables.instances.fields = fields;\n    ins_fields = _handleListFields(TabularTables.instances.fields);\n    ins_fields.forEach(function(f) {\n      if (f.type !== 'table' && f.is_list_display) {\n        return options.columns.push({\n          data: f.name || f.code,\n          title: t(f.name || f.code),\n          visible: false,\n          orderable: false,\n          render: function(val, type, doc) {\n            var value, values;\n            values = doc.values || {};\n            value = values[f.code];\n            switch (f.type) {\n              case 'user':\n                value = value != null ? value.name : void 0;\n                break;\n              case 'group':\n                value = value != null ? value.fullname : void 0;\n                break;\n              case 'date':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD');\n                }\n                break;\n              case 'dateTime':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD HH:mm');\n                }\n                break;\n              case 'checkbox':\n                if (value === true || value === 'true') {\n                  value = TAPi18n.__(\"form_field_checkbox_yes\");\n                } else {\n                  value = TAPi18n.__(\"form_field_checkbox_no\");\n                }\n                break;\n              case 'odata':\n                if (value) {\n                  if (_.isArray(value)) {\n                    value = _.pluck(value, '@label').toString();\n                  } else {\n                    value = value['@label'];\n                  }\n                }\n            }\n            return value;\n          }\n        });\n      }\n    });\n  }\n  return options;\n};\n\ninstanceTasksListTableTabular = function(flowId, fields) {\n  var ins_fields, key, options;\n  options = {\n    name: \"instance_tasks\",\n    collection: db.instance_tasks,\n    pub: \"instance_tasks_tabular\",\n    onUnload: function() {\n      return Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n    },\n    drawCallback: function(settings) {\n      var ellipsisLink, emptyTd, title;\n      emptyTd = $(\".dataTables_empty\");\n      if (emptyTd.length) {\n        emptyTd[0].colSpan = \"6\";\n      }\n      if (!Steedos.isMobile() && !Steedos.isPad()) {\n        Meteor.setTimeout(Template.instance_list._tableColumns, 150);\n        $(\".instance-list\").scrollTop(0).ready(function() {\n          return $(\".instance-list\").perfectScrollbar(\"update\");\n        });\n      } else {\n        $(\".instance-list\").scrollTop(0);\n      }\n      title = t(\"pager_input_hint\");\n      ellipsisLink = settings.oInstance.parent().find('.paging_numbers .pagination .disabled a');\n      return ellipsisLink.attr(\"title\", title).css(\"cursor\", \"pointer\").click(function() {\n        var goPage, input;\n        if (!$(this).find('input').length) {\n          input = $('<input class=\"paginate_input form-control input-sm\" type=\"text\" style=\"border: none; padding:0 2px;\"/>');\n          if (Steedos.isMobile()) {\n            input.css({\n              width: \"52px\",\n              height: \"20px\"\n            });\n          } else {\n            input.css({\n              width: \"52px\",\n              height: \"16px\"\n            });\n          }\n          input.attr(\"title\", title).attr(\"placeholder\", title);\n          $(this).empty().append(input);\n          goPage = function(index) {\n            var pages;\n            if (index > 0) {\n              pages = Math.ceil(settings.fnRecordsDisplay() / settings._iDisplayLength);\n              if (index > pages) {\n                index = pages;\n              }\n              index--;\n              return settings.oInstance.DataTable().page(index).draw('page');\n            }\n          };\n          input.blur(function(e) {\n            var currentPage;\n            currentPage = $(this).val();\n            goPage(currentPage);\n            return $(this).parent().html('...');\n          });\n          return input.keydown(function(e) {\n            var currentPage;\n            if (e.keyCode.toString() === \"13\") {\n              currentPage = $(this).val();\n              return goPage(currentPage);\n            }\n          });\n        }\n      });\n    },\n    createdRow: function(row, data, dataIndex) {\n      if (Meteor.isClient) {\n        if (data.instance === FlowRouter.current().params.instanceId) {\n          return row.setAttribute(\"class\", \"selected\");\n        }\n      }\n    },\n    columns: [\n      {\n        data: \"_id\",\n        orderable: false,\n        render: function(val, type, doc) {\n          var agent_view, cc_view, flow_name, instanceNamePriorityClass, modified, modifiedFromNow, modifiedString, priorityIcon, priorityIconClass, priorityValue, ref, step_current_name_view, unread;\n          modifiedString = moment(doc.modified).format('YYYY-MM-DD');\n          modified = doc.modified;\n          if (Session.get(\"box\") === 'inbox' && doc.instance_state !== 'draft') {\n            modified = doc.start_date || doc.modified;\n          }\n          if (Session.get(\"box\") === 'outbox') {\n            modified = doc.submit_date || doc.modified;\n          }\n          modifiedFromNow = Steedos.momentReactiveFromNow(modified);\n          flow_name = doc.flow_name;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.type === 'cc' && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n            step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.step_name + \")</span></div>\";\n          } else {\n            if (doc.step_name) {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"<span>(\" + doc.step_name + \")</span></div>\";\n            } else {\n              step_current_name_view = \"<div class='flow-name'>\" + flow_name + \"</div>\";\n            }\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name && Session.get(\"box\") === 'inbox') {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIcon = \"\";\n          priorityIconClass = \"\";\n          priorityValue = (ref = doc.values) != null ? ref.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.instance_name + cc_view + agent_view + \"\\n\t<span>\" + doc.applicant_name + \"</span>\\n</div>\\n<div class='instance-detail'>\" + step_current_name_view + \"\\n\t<span class='instance-modified' title='\" + modifiedString + \"'>\" + modifiedFromNow + \"</span>\\n</div>\";\n        }\n      }, {\n        data: \"applicant_organization_name\",\n        title: t(\"instances_applicant_organization_name\"),\n        visible: false\n      }, {\n        data: \"instance_name\",\n        title: t(\"instances_name\"),\n        render: function(val, type, doc) {\n          var agent_view, cc_view, instanceNamePriorityClass, priorityIconClass, priorityValue, ref, ref1, step_current_name_view, unread;\n          cc_view = \"\";\n          step_current_name_view = \"\";\n          if (doc.is_cc && !((ref = doc.inbox_users) != null ? ref.includes(Meteor.userId()) : void 0) && Session.get(\"box\") === 'inbox') {\n            cc_view = \"<label class='cc-label'>(\" + TAPi18n.__(\"instance_cc_title\") + \")</label> \";\n          }\n          agent_view = \"\";\n          if (doc.agent_user_name) {\n            agent_view = \"<label class='cc-label'>(\" + TAPi18n.__('process_delegation_rules_description', {\n              userName: doc.agent_user_name\n            }) + \")</label>\";\n          }\n          unread = '';\n          if (Session.get(\"box\") === 'inbox' && doc.is_read === false) {\n            unread = '<i class=\"ion ion-record unread\"></i>';\n          } else if (Session.get(\"box\") === 'monitor' && doc.is_hidden === true) {\n            unread = '<i class=\"fa fa-lock\"></i>';\n          }\n          priorityIconClass = \"\";\n          priorityValue = (ref1 = doc.values) != null ? ref1.priority : void 0;\n          switch (priorityValue) {\n            case \"特急\":\n              priorityIconClass = \"danger\";\n              break;\n            case \"紧急\":\n              priorityIconClass = \"warning\";\n              break;\n            case \"办文\":\n              priorityIconClass = \"muted\";\n          }\n          if (priorityIconClass) {\n            instanceNamePriorityClass = \"color-priority color-priority-\" + priorityIconClass;\n          }\n          return \"<div class='instance-read-bar'>\" + unread + \"</div>\\n<div class='instance-name \" + instanceNamePriorityClass + \"'>\" + doc.instance_name + cc_view + agent_view + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"applicant_name\",\n        title: t(\"instances_applicant_name\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"submit_date\",\n        title: t(\"instances_submit_date\"),\n        render: function(val, type, doc) {\n          if (doc.submit_date) {\n            return moment(doc.submit_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"flow_name\",\n        title: t(\"instances_flow\"),\n        visible: false,\n        orderable: false\n      }, {\n        data: \"step_name\",\n        title: t(\"instances_step_current_name\"),\n        render: function(val, type, doc) {\n          var cc_tag, judge, step_current_name;\n          if (doc.instance_state === \"completed\") {\n            judge = doc.judge || \"approved\";\n          }\n          step_current_name = doc.step_name || '';\n          cc_tag = '';\n          if (doc.cc_count > 0) {\n            cc_tag = TAPi18n.__('cc_tag');\n          }\n          return \"<div class=\\\"step-current-state \" + judge + \"\\\">\" + step_current_name + cc_tag + \"</div>\";\n        },\n        visible: false,\n        orderable: false\n      }, {\n        data: \"modified\",\n        title: t(\"instances_modified\"),\n        render: function(val, type, doc) {\n          return moment(doc.modified).format('YYYY-MM-DD HH:mm');\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"start_date\",\n        title: t(\"instances_start_date\"),\n        render: function(val, type, doc) {\n          if (doc.start_date) {\n            return moment(doc.start_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"finish_date\",\n        render: function(val, type, doc) {\n          if (doc.finish_date) {\n            return moment(doc.finish_date).format('YYYY-MM-DD HH:mm');\n          }\n        },\n        visible: false,\n        orderable: true\n      }, {\n        data: \"modified\",\n        visible: false\n      }, {\n        data: \"keywords\",\n        visible: false\n      }, {\n        data: \"is_archived\",\n        render: function(val, type, doc) {\n          var ref;\n          if ((doc != null ? (ref = doc.values) != null ? ref.record_need : void 0 : void 0) && doc.values.record_need === \"true\") {\n            if (doc != null ? doc.is_archived : void 0) {\n              return t(\"YES\");\n            }\n            return t(\"NO\");\n          }\n        },\n        visible: false,\n        orderable: false\n      }\n    ],\n    dom: (function() {\n      if (Steedos.isMobile()) {\n        return 'tp';\n      } else {\n        return 'tpl';\n      }\n    })(),\n    order: [[4, \"desc\"]],\n    extraFields: [\"instance\", \"form\", \"flow\", \"inbox_users\", \"instance_state\", \"space\", \"applicant\", \"form_version\", \"flow_version\", \"type\", \"is_read\", \"step_name\", \"values\", \"keywords\", \"final_decision\", \"flow_name\", \"is_hidden\", \"agent_user_name\"],\n    lengthChange: true,\n    lengthMenu: [10, 15, 20, 25, 50, 100],\n    pageLength: 10,\n    info: false,\n    searching: true,\n    responsive: {\n      details: false\n    },\n    autoWidth: false,\n    changeSelector: function(selector, userId) {\n      var ref, space, space_user;\n      if (!userId) {\n        return {\n          _id: -1\n        };\n      }\n      space = selector.space;\n      if (!space) {\n        if ((selector != null ? (ref = selector.$and) != null ? ref.length : void 0 : void 0) > 0) {\n          space = selector.$and.getProperty('space')[0];\n        }\n      }\n      if (!space) {\n        return {\n          _id: -1\n        };\n      }\n      space_user = db.space_users.findOne({\n        user: userId,\n        space: space\n      }, {\n        fields: {\n          _id: 1\n        }\n      });\n      if (!space_user) {\n        return {\n          _id: -1\n        };\n      }\n      return selector;\n    },\n    pagingType: \"numbers\"\n  };\n  if (flowId) {\n    key = \"instanceFlow\" + flowId;\n    options.name = key;\n    TabularTables.instance_tasks.fields = fields;\n    ins_fields = _handleListFields(TabularTables.instance_tasks.fields);\n    ins_fields.forEach(function(f) {\n      if (f.type !== 'table' && f.is_list_display) {\n        return options.columns.push({\n          data: f.name || f.code,\n          title: t(f.name || f.code),\n          visible: false,\n          orderable: false,\n          render: function(val, type, doc) {\n            var value, values;\n            values = doc.values || {};\n            value = values[f.code];\n            switch (f.type) {\n              case 'user':\n                value = value != null ? value.name : void 0;\n                break;\n              case 'group':\n                value = value != null ? value.fullname : void 0;\n                break;\n              case 'date':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD');\n                }\n                break;\n              case 'dateTime':\n                if (value) {\n                  value = moment(value).format('YYYY-MM-DD HH:mm');\n                }\n                break;\n              case 'checkbox':\n                if (value === true || value === 'true') {\n                  value = TAPi18n.__(\"form_field_checkbox_yes\");\n                } else {\n                  value = TAPi18n.__(\"form_field_checkbox_no\");\n                }\n                break;\n              case 'odata':\n                if (value) {\n                  if (_.isArray(value)) {\n                    value = _.pluck(value, '@label').toString();\n                  } else {\n                    value = value['@label'];\n                  }\n                }\n            }\n            return value;\n          }\n        });\n      }\n    });\n  }\n  return options;\n};\n\nMeteor.startup(function() {\n  TabularTables.instances = new Tabular.Table(instancesListTableTabular());\n  TabularTables.instance_tasks = new Tabular.Table(instanceTasksListTableTabular());\n  TabularTables.inbox_instances = new Tabular.Table(GetBoxInstancesTabularOptions(\"inbox\"));\n  return TabularTables.outbox_instances = new Tabular.Table(GetBoxInstancesTabularOptions(\"outbox\"));\n});\n\nGetBoxInstancesTabularOptions = function(box, flowId, fields) {\n  var key, options;\n  key = \"instanceFlow\" + box + flowId;\n  if (box === \"inbox\") {\n    options = _get_inbox_instances_tabular_options(flowId, fields);\n  } else if (box === \"outbox\") {\n    options = _get_outbox_instances_tabular_options(flowId, fields);\n  } else {\n    options = instancesListTableTabular(flowId, fields);\n    if (!flowId) {\n      options.name = \"inbox_instances\";\n    }\n  }\n  if (flowId) {\n    options.name = key;\n  }\n  return options;\n};\n\n_get_inbox_instances_tabular_options = function(flowId, fields) {\n  var options;\n  options = instanceTasksListTableTabular(flowId, fields);\n  if (!flowId) {\n    options.name = \"inbox_instances\";\n  }\n  options.order = [[8, \"desc\"]];\n  options.getSort = function(selector, sort) {\n    console.log('inbox_instances:', sort);\n    return sort;\n  };\n  return options;\n};\n\n_get_outbox_instances_tabular_options = function(flowId, fields) {\n  var options;\n  options = instanceTasksListTableTabular(flowId, fields);\n  if (!flowId) {\n    options.name = \"outbox_instances\";\n  }\n  options.order = [[9, -1]];\n  options.getSort = function(selector, sort) {\n    console.log('outbox_instances:', sort);\n    return sort;\n  };\n  return options;\n};\n\nif (Meteor.isClient) {\n  TabularTables.flowInstances = new ReactiveVar();\n}\n\nMeteor.startup(function() {\n  return Tracker.autorun(function(c) {\n    if (Meteor.isClient && !Steedos.isMobile()) {\n      if (Session.get(\"flowId\") && Session.get(\"box\") !== 'draft') {\n        return Meteor.call(\"newInstancesListTabular\", Session.get(\"box\"), Session.get(\"flowId\"), function(error, result) {\n          newInstancesListTabular(Session.get(\"box\"), Session.get(\"flowId\"), result);\n          return Template.instance_list._changeOrder();\n        });\n      }\n    }\n  });\n});\n\nnewInstancesListTabular = function(box, flowId, fields) {\n  var flow, key, ref, ref1, ref2;\n  if (!fields) {\n    flow = db.flows.findOne({\n      _id: flowId\n    }, {\n      fields: {\n        form: 1\n      }\n    });\n    fields = (ref = db.forms.findOne({\n      _id: flow != null ? flow.form : void 0\n    }, {\n      fields: {\n        'current.fields': 1\n      }\n    })) != null ? (ref1 = ref.current) != null ? ref1.fields : void 0 : void 0;\n  }\n  fields = _handleListFields(fields);\n  if ((fields != null ? (ref2 = fields.filterProperty(\"is_list_display\", true)) != null ? ref2.length : void 0 : void 0) > 0) {\n    key = \"instanceFlow\" + box + flowId;\n    if (Meteor.isClient) {\n      TabularTables.flowInstances.set(new Tabular.Table(GetBoxInstancesTabularOptions(box, flowId, fields)));\n    } else {\n      new Tabular.Table(GetBoxInstancesTabularOptions(box, flowId, fields));\n    }\n    return console.log(\"new TabularTables \", key);\n  }\n};\n\nif (Meteor.isServer) {\n  Meteor.methods({\n    newInstancesListTabular: function(box, flowId) {\n      var fields, flow, ref, ref1;\n      newInstancesListTabular(box, flowId);\n      flow = db.flows.findOne({\n        _id: flowId\n      }, {\n        fields: {\n          form: 1\n        }\n      });\n      fields = (ref = db.forms.findOne({\n        _id: flow != null ? flow.form : void 0\n      }, {\n        fields: {\n          'current.fields': 1\n        }\n      })) != null ? (ref1 = ref.current) != null ? ref1.fields : void 0 : void 0;\n      return fields;\n    }\n  });\n}\n"]} diff --git a/server/bundle/programs/server/packages/steedos_workflow.js.map b/server/bundle/programs/server/packages/steedos_workflow.js.map index ba2f4480e0..ad2ae87737 100644 --- a/server/bundle/programs/server/packages/steedos_workflow.js.map +++ b/server/bundle/programs/server/packages/steedos_workflow.js.map @@ -1 +1 @@ -{"version":3,"sources":["meteor://💻app/packages/steedos:workflow/checkNpm.js","meteor://💻app/packages/steedos:workflow/lib/URI.js","meteor://💻app/packages/steedos_workflow/lib/core.coffee","meteor://💻app/lib/core.coffee","meteor://💻app/packages/steedos_workflow/lib/models/instance_tasks.coffee","meteor://💻app/packages/steedos_workflow/lib/models/auth_tokens.coffee","meteor://💻app/packages/steedos_workflow/client/lib/instance_readonly_template.coffee","meteor://💻app/client/lib/instance_readonly_template.coffee","meteor://💻app/packages/steedos_workflow/client/lib/template_manager.coffee","meteor://💻app/client/lib/template_manager.coffee","meteor://💻app/packages/steedos:workflow/client/coreform/inputTypes/coreform-table/steedos-table.js","meteor://💻app/packages/steedos_workflow/client/views/instance/_image_sign.coffee","meteor://💻app/client/views/instance/_image_sign.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_traces_handler.coffee","meteor://💻app/client/views/instance/_traces_handler.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_instance_form.coffee","meteor://💻app/client/views/instance/_instance_form.coffee","meteor://💻app/packages/steedos:workflow/client/views/instance/_instance_attachments.js","meteor://💻app/packages/steedos_workflow/client/views/instance/_instance_sign_text.coffee","meteor://💻app/client/views/instance/_instance_sign_text.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_traces_help.coffee","meteor://💻app/client/views/instance/_traces_help.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_related_instances.coffee","meteor://💻app/client/views/instance/_related_instances.coffee","meteor://💻app/packages/steedos_workflow/client/views/instance/_related_records.coffee","meteor://💻app/client/views/instance/_related_records.coffee","meteor://💻app/packages/steedos:workflow/routes/getSpaceUsers.js","meteor://💻app/packages/steedos:workflow/routes/getFormulaUserObjects.js","meteor://💻app/packages/steedos:workflow/routes/init_formula_values.js","meteor://💻app/packages/steedos:workflow/routes/api_workflow_forward.js","meteor://💻app/packages/steedos_workflow/routes/test_webhook.coffee","meteor://💻app/routes/test_webhook.coffee","meteor://💻app/packages/steedos_workflow/server/methods/set_instance_step_approve.coffee","meteor://💻app/packages/steedos:workflow/server/methods/get_instance_data.js","meteor://💻app/packages/steedos:workflow/server/methods/save_instance.js","meteor://💻app/packages/steedos:workflow/server/methods/trace_approve_cc.js","meteor://💻app/packages/steedos:workflow/server/methods/forward_instance.js","meteor://💻app/packages/steedos:workflow/server/methods/cfs_instances.js","meteor://💻app/packages/steedos_workflow/server/methods/instance_approve.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_return.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_remind.coffee","meteor://💻app/packages/steedos_workflow/server/methods/next_step_users_not_found.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_number_rules.coffee","meteor://💻app/packages/steedos_workflow/server/methods/check_main_attach.coffee","meteor://💻app/packages/steedos_workflow/server/methods/related_instances.coffee","meteor://💻app/packages/steedos_workflow/server/methods/edit_flow_positions.coffee","meteor://💻app/packages/steedos_workflow/server/methods/start_flow.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_traces.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_batch.coffee","meteor://💻app/packages/steedos_workflow/server/methods/flow.coffee","meteor://💻app/packages/steedos_workflow/server/methods/hide_instance.coffee","meteor://💻app/packages/steedos_workflow/server/methods/instance_value.coffee","meteor://💻app/packages/steedos_workflow/server/routes/instance.coffee","meteor://💻app/server/routes/instance.coffee","meteor://💻app/packages/steedos_workflow/server/routes/steedos_css.coffee","meteor://💻app/server/routes/steedos_css.coffee","meteor://💻app/packages/steedos_workflow/server/routes/instance_draft_view.coffee","meteor://💻app/server/routes/instance_draft_view.coffee","meteor://💻app/packages/steedos:workflow/server/lib/1_form_formula.js","meteor://💻app/packages/steedos_workflow/server/publications/categories.coffee","meteor://💻app/server/publications/categories.coffee","meteor://💻app/packages/steedos_workflow/server/publications/cfs_instances.coffee","meteor://💻app/server/publications/cfs_instances.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_positions.coffee","meteor://💻app/server/publications/flow_positions.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_positions_tabular.coffee","meteor://💻app/server/publications/flow_positions_tabular.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_roles.coffee","meteor://💻app/server/publications/flow_roles.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flows.coffee","meteor://💻app/server/publications/flows.coffee","meteor://💻app/packages/steedos_workflow/server/publications/forms.coffee","meteor://💻app/server/publications/forms.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_data.coffee","meteor://💻app/server/publications/instance_data.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_list.coffee","meteor://💻app/server/publications/instance_list.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_tabular.coffee","meteor://💻app/server/publications/instance_tabular.coffee","meteor://💻app/packages/steedos_workflow/server/publications/instance_draft.coffee","meteor://💻app/server/publications/instance_draft.coffee","meteor://💻app/packages/steedos_workflow/server/publications/distributed_instances_state_by_ids.coffee","meteor://💻app/server/publications/distributed_instances_state_by_ids.coffee","meteor://💻app/packages/steedos_workflow/server/publications/related_instaces.coffee","meteor://💻app/server/publications/related_instaces.coffee","meteor://💻app/packages/steedos_workflow/server/publications/space_user_signs.coffee","meteor://💻app/server/publications/space_user_signs.coffee","meteor://💻app/packages/steedos_workflow/server/publications/user_inbox_instance.coffee","meteor://💻app/server/publications/user_inbox_instance.coffee","meteor://💻app/packages/steedos_workflow/server/publications/flow_main_attach_template.coffee","meteor://💻app/server/publications/flow_main_attach_template.coffee","meteor://💻app/packages/steedos_workflow/server/flow-template/workflow_template.coffee","meteor://💻app/server/flow-template/workflow_template.coffee","meteor://💻app/packages/steedos_workflow/server/schedule/auto_finish_process_delegation.coffee","meteor://💻app/server/schedule/auto_finish_process_delegation.coffee","meteor://💻app/packages/steedos_workflow/server/schedule/timeout_auto_submit.coffee","meteor://💻app/server/schedule/timeout_auto_submit.coffee","meteor://💻app/packages/steedos_workflow/related_instances_tabular.coffee","meteor://💻app/related_instances_tabular.coffee","meteor://💻app/packages/steedos_workflow/tabular.coffee","meteor://💻app/tabular.coffee"],"names":["checkNpmVersions","module","link","v","root","factory","define","amd","URI","punycode","IPv6","SecondLevelDomains","SLD","_URI","url","base","_urlSupplied","arguments","length","_baseSupplied","undefined","TypeError","location","href","absoluteTo","version","p","prototype","hasOwn","Object","hasOwnProperty","escapeRegEx","string","replace","getType","value","String","toString","call","slice","isArray","obj","filterArrayValues","data","lookup","i","_match","test","splice","arrayContains","list","_type","match","arraysEqual","one","two","sort","l","trimSlashes","text","trim_expression","_parts","protocol","username","password","hostname","urn","port","path","query","fragment","duplicateQueryParameters","escapeQuerySpace","protocol_expression","idn_expression","punycode_expression","ip4_expression","ip6_expression","find_uri_expression","findUri","start","end","trim","defaultPorts","http","https","ftp","gopher","ws","wss","invalid_hostname_characters","domAttributes","getDomAttribute","node","nodeName","toLowerCase","type","escapeForDumbFirefox36","escape","strictEncodeURIComponent","encodeURIComponent","encode","decode","decodeURIComponent","iso8859","unescape","unicode","characters","pathname","expression","map","reserved","urnpath","encodeQuery","escaped","decodeQuery","e","_part","generateAccessor","_group","c","generateSegmentedPathFunction","_sep","_codingFuncName","_innerCodingFuncName","actualCodingFunc","segments","split","join","decodePath","decodeUrnPath","recodePath","recodeUrnPath","encodeReserved","parse","parts","pos","indexOf","substring","parseAuthority","parseHost","bracketPos","t","charAt","firstColon","firstSlash","nextColon","parseUserinfo","lastIndexOf","shift","parseQuery","items","splits","name","push","build","buildAuthority","buildHost","buildUserinfo","buildQuery","unique","key","buildQueryParameter","addQuery","concat","removeQuery","hasQuery","withinArray","_booly","Boolean","op","commonPath","Math","min","withinString","callback","options","_start","_end","_trim","_attributeOpen","lastIndex","exec","index","ignoreHtml","attributeOpen","max","search","ignore","result","ensureValidHostname","toASCII","noConflict","removeAll","unconflicted","URITemplate","deferBuild","_deferred_build","_string","clone","valueOf","generateSimpleAccessor","generatePrefixAccessor","_key","hash","res","_object","attribute","src","is","what","ip","ip4","ip6","sld","idn","relative","has","_protocol","_port","_hostname","scheme","x","origin","authority","host","userinfo","resource","subdomain","domain","sub","RegExp","tld","get","ReferenceError","directory","filename","decodePathSegment","mutatedDirectory","normalizePath","suffix","s","segment","separator","absolute","Error","pop","unshift","segmentCoded","q","setQuery","setSearch","addSearch","removeSearch","hasSearch","normalize","normalizeProtocol","normalizeQuery","normalizeFragment","normalizeHostname","normalizePort","best","_path","_was_relative","_leadingParents","_parent","_pos","normalizePathname","normalizeSearch","normalizeHash","d","readable","uri","toUnicode","qp","kv","resolved","properties","basedir","relativeTo","relativeParts","baseParts","common","relativePath","basePath","parents","equals","one_map","two_map","checked","one_query","two_query","Workflow","ImageSign","TracesHandler","TracesTemplate","InstanceformTemplate","InstanceAttachmentTemplate","InstanceSignText","RelatedInstances","RelatedRecords","InstanceMacro","context","TracesManager","isOpinionField_from_string","field_formula","includesOpinionField","form","form_version","_form_version","field_formulas","fields","Array","Meteor","isServer","uuflowManager","getFormVersion","db","forms","findOne","_id","form_versions","forEach","f","ref","console","log","f1","formula","_","some","helpers","instance_tasks","Collection","_simpleSchema","SimpleSchema","instance","trace","is_finished","user","user_name","handler","handler_name","handler_organization","handler_organization_name","handler_organization_fullname","start_date","Date","due_date","is_read","is_error","values","deadline","remind_date","reminded_count","Number","read_date","description","modified","modified_by","sign_show","judge","next_steps","finish_date","cost_time","space","instance_name","submitter","submitter_name","applicant","applicant_name","applicant_organization_name","submit_date","flow","flow_name","step","step_name","category_name","instance_state","distribute_from_instance","forward_from_instance","keywords","is_archived","category","auth_tokens","_getLocale","_getRequiredFields","_getStartStepEditableFields","_getStartStepRequiredFields","_getTemplateData","_getViewHtml","getLinkText","marked","require","InstanceReadOnlyTemplate","instance_attachment","afSelectUserRead","afFormGroupRead","afFormGroup","create","tempalteName","steedosData","template","templateCompiled","templateRenderFunction","SpacebarsCompiler","compile","isBody","eval","Template","Blaze","createInstanceSignText","instanceSignTextCompiled","instanceSignTextHtml","instanceSignTextRenderFunction","instanceSignText","createImageSign","imageSignCompiled","imageSignHtml","imageSignRenderFunction","imageSign","createTracesHanlder","tracesHanlderCompiled","tracesHanlderHtml","tracesHanlderRenderFunction","instance_traces_handler","init","item","label","detail_url","Steedos","absoluteUrl","getValue","field","locale","utcOffset","date","fieldOptions","hours","month","nameField","records","seconds","selectedOption","selectedOptions","splitedValues","t0","t1","uiSchema","year","n","itemSplits","encodeURI","error","is_multiselect","getProperty","fullname","TAPi18n","__","formatDate","formatTime","is_textarea","find","filter","is_percent","numberToPercentString","digits","numberToString","isClient","authRequest","JSON","stringify","async","objectFind","filters","fileName","filePreviewHtml","fileUrl","original","Creator","getObject","reference_to","NAME_FIELD_KEY","reference_to_field","getObjectNameFieldKey","getLabel","code","findPropertyByPK","getInstanceFormVersion","form_fields","current","where","historys","getFlowVersion","flow_version","flows","viewHtml","Assets","getText","ref1","toLocaleLowerCase","rev","is_required","steps","editableCode","startStep","keys","permissions","requiredFields","intersection","WorkflowManager","WorkflowManager_format","getAutoformSchemaValues","insname","ins_state","state","ins_final_decision","ins_code","ins_is_archived","ins_is_deleted","applicantContext","sessionUserId","editable","startStepEditableFields","passing","moment","format","getInstanceView","body","instanceCompiled","instanceRenderFunction","instanceTemplate","TemplateManager","getTemplate","templateName","instance_readonly_view","toHTMLWithData","getTracesView","traceCompiled","traceRenderFunction","tracesHtml","instance_style","trace_readonly_view","traces","getAttachmentView","attachmentCompiled","attachmentHtml","attachmentRenderFunction","attachments_readonly_view","getRelatedInstancesView","relatedInstancesCompiled","relatedInstancesHtml","relatedInstancesRenderFunction","related_instances_view","getRelatedRecordsView","relatedRecordsCompiled","relatedRecordsHtml","relatedRecordsRenderFunction","related_records_view","getOnLoadScript","form_script","getInstanceHtml","allCssLink","attachment","creatorService","cssHref","formDescription","formDescriptionHtml","html","ins_record_ids","instanceBoxStyle","jqHref","onLoadScript","openFileScript","related_instances","related_records","showTracesBtn","showTracesScript","traceCheck","width","settings","webservices","creator","record_ids","isMobile","showTrace","final_decision","showAttachments","isEmpty","tagger","styles","plugins","add_styles","formId","instance_title","pageTitle","pageTitleTrClass","val","CoreForm","pageTitleFieldName","handleTableTemplate","_export","table_fields","table_field","field_permission","pureCode","required","title_permission","removeSpecialCharacter","isOpinionField","tr_start","td_colspan","tr_end","includes","permission","_template","table","_templateHelps","steedos_instance","getInstance","atts","id","style","disabled","instanceId","form_types","ApproveManager","isReadOnly","steedos_form","innersubformContext","doc_values","Session","a","b","getAutoformSchema","instance_box_style","box","ins","print_template","instance_template","SteedosTable","checkItem","item_index","fieldObj","getField","fieldVal","getItemModalValue","sf_name","sfields","sf","InstanceManager","checkFormFieldValue","$","setTableItemValue","item_value","tableValue","getTableValue","getTableItemValue","removeTableItem","removed","setTableValue","getValidValue","validValue","handleData","instanceFields","getInstanceFields","getModalData","Form_formula","getFormulaFieldVariable","AutoForm","getFormValues","insertDoc","addItem","_item_value","getKeys","append","getTr","updateItem","tds","getRemoveTd","sfield","getTd","empty","runFormula","removeItem","hide","showModal","method","modalData","setTimeout","Modal","show","getCurrentDataForForm","ss","getFormSchema","schema","objectKeys","_makeGeneric","getThead","isObject","thead","trs","sf_length","wide_fields","filterProperty","is_wide","getTbody","sfieldsEditable","tbody","tr","td","td_value","getTDValue","view","CFDataManager","getFormulaSpaceUsers","u","getFormulaOrganizations","o","getFormulaOrganization","pluck","addInputType","valueOut","valueConverters","stringToStringArray","stringToNumber","stringToNumberArray","stringToBoolean","stringToBooleanArray","stringToDate","stringToDateArray","contextAdjust","maxlength","afTable","events","event","new_item_index","currentTarget","dataset","set","rendered","str","addItemTr","getCurrentStep","step_type","ccHasEditPermission","autorun","currentData","spaceUserSign","userId","space_user_signs","imageURL","sign","showSignImage","traceShowSignImage","objectUrl","object_name","record_id","app_id","getObjectUrl","unempty","unequals","include","ref2","ref3","getInstanceFlowVersion","approves","ref4","approve","judge_name","opinion_fields_code","sign_field_code","after_field","before_field","pre_fields","pre_wide_fields","sort_approve","order","p1","p2","_p1","_p2","getTime","_t","isTextarea","getCfClass","getTableThead","getTableBody","showLabel","templateData","getOpinionFieldStepsName","top_keywords","foo1","opinionFields","foo","json_formula","s1","error1","yijianlan","stepName","image_sign","only_cc_opinion","only_cc","default_description","only_handler","showCCOpinion","markDownToHtml","markDownString","Npm","Spacebars","SafeString","f_label","that","isSection","registerHelper","ins_attach_download_url","getPermissions","instanceformChangeEvent","preventDefault","openWindow","target","onCreated","compiled","instanceCustomTemplate","instanceView","renderFunction","View","instance_custom_template","onRendered","currentApprove","currentStep","formula_fields","instanceNumberFields","setInstanceFormApplicant","nextSteps","nextStepUsers","InstanceEvent","initEvents","getCurrentApprove","each","element","schemaKey","toastr","reason","getFieldValue","InstanceNumberRules","instanceNumberBuilder","trigger","run","showMainTitle","workflowMainAttachTitle","enabled_add_main_attachment","current_step","currentTrace","getCurrentTrace","main_attach_count","cfs","instances","count","distribute_main_attach_count","start_step","getStartStep","can_edit_main_attach","enabled_edit_normal_attachment","getFlow","upload_after_being_distributed","isCC","getCCStep","can_edit_normal_attach","main_attachment","main_attach","normal_attachments","selector","$ne","dfis","distribute_from_instances","$in","distribute_main","firstVersionMain","metadata","parent","attachmentUploadedAt","uploadedAt","firstVersion","sortBy","instanceIds","attachments_count","flow_files","files","isDraftAndFlowfilesExist","compact","attachments","$or","fetch","myApprove","myTrace","isInbox","defaultDescription","approve_sort","approvesGroup","approves_sorted","completed_date","hasNext","haveDescriptionApprove","is_completed","last","top_approves","union","top_approve","groupBy","handlerApproves","descriptionApproves","workflow","showBlankApproveDescription","_display","isMyApprove","myApproveDescription","approveId","now","isOpinionOfField","imageSignData","getLastSignApprove","getHandlerSignShowApproves","lastMyApproveDescription","showApprove","judge_description","is_approved","is_rejected","is_readed","addClass","dateFormat","getFullYear","getStepName","stepId","getInstanceStep","showDeleteButton","approved","from_user","isShowModificationButton","approve_admins","isShow","contains","isEditing","is_editing","isShowDescription","getApproveStatusIcon","approveJudge","autoSubmitted","approveStatusIcon","getApproveStatusText","approveStatusText","getApproveJudgeClass","isForward","showForwardDeleteButton","forward_instance","isDistribute","showDistributeDeleteButton","hasFlowAdminPermission","finishDateSchema","isAndroidOrIOS","autoform","optional","readonly","dateTimePickerOptions","ignoreReadonly","widgetPositioning","horizontal","finishDateValues","showTracesView","show_modal_traces_list","space_settings","getInstanceStateText","instance_id","getInstanceStateColor","cla","firstTrace","last_distribute_from","dis_info","$exists","created","created_by","UUflow_api","getNameForUser","users","from_user_name","isCCOrDistributeOrForwardTerminated","judgeTerminated","instanceExists","agentDescription","userName","traceName","traceId","handlerDoc","handlerId","users_can_read_cc_handler_detail_info","getContactInfoForUser","stopPropagation","calling","err","removeClass","success","allowMultiple","closest","target_user_id","openSafeObjectUrl","forward_space","forwardspace","forwardinstance","Tracker","afterFlush","on","scrollTop","finish_input","opinion_input","showRelatedInstaces","related_instaces","related_instace_url","isCordova","show_delete","showRelatedRecords","relatedRecordUrl","objcetName","ids","process","env","CREATOR_NODE_ENV","JsonRoutes","add","req","next","hashData","action","to_users","sendResult","stack","errors","errorMessage","message","workflowMethods","methods","set_instance_step_approve","ins_id","step_approve","stepsApprovesOptions","apply","set_instance_skip_steps","get_instance_data","formCached","flowCached","draft_save_instance","inbox_save_instance","cc_do","cc_user_ids","cc_read","cc_submit","cc_remove","batch_cancel_cc","approve_ids","cc_save","space_id","flow_id","hasSaveInstanceToAttachment","isForwardAttachments","selectedUsers","action_type","related","from_approve_id","forward_remove","trace_id","approve_id","cancelDistribute","cfs_instances_remove","file_id","cfs_instances_set_current","cfs_instances_lock","user_id","cfs_instances_unlock","download_space_instance_attachments_to_disk","spaceId","cfsRecordIds","set_approve_have_read","change_approve_info","update_approve_sign","sign_type","lastSignApprove","update_sign_show","objs","myApprove_id","instance_return","instance_remind","remind_users","remind_count","remind_deadline","action_types","next_step_users_not_found","deal_type","params","_eval","check_main_attach","remove_related","re_ins_id","update_instance_related","updateFlowPosition","updateFlowRole","start_flow","flowId","get_instance_traces","categoryId","flowIds","get_batch_instances","get_batch_instances_count","get_my_approves","change_flow_state","hide_instance","insId","is_hidden","getInstanceValues","Cookies","getInstanceReadOnly","_hasPermission","_locale","_parent_instances","dataBuf","hide_traces","spaceUserCount","getAPILoginUser","access_token","getUserIdFromAccessToken","spaces","space_users","hasInstancePermissions","_parent_id","_parent_ins","charset","Buffer","setHeader","statusCode","ret_sync_token","spaceUser","spaceUserOrganizations","sync_token","APIAuthenticationCheck","headers","isSpaceAdmin","organizations","canMonitor","canAdmin","$gt","$nin","inbox_uers","cc_users","outbox_users","skip","limit","copies","allCss","WebApp","getRefreshableAssets","css","rootUrl","__meteor_runtime_config__","ROOT_URL_PATH_PREFIX","ROOT_URL","endsWith","h","g","m","k","getEach","uniq","mixin","dest","handerUserObject","organization","hr","sort_no","mobile","work_phone","position","userRoles","roles","handerOrgObject","org","init_formula_values","autoFormDoc","approver","__values","tableFields","tableValues","formulaTableValues","__tableValues","tablefield","getFormulaUserObjects","getFormulaOrgObjects","getFormulaUserObject","publish","check","ready","categories","app","flow_positions","role","publishComposite","tableName","Match","Optional","unblock","children","flow_roles","createTemplateFormAndFlow","perms","company_id","distribute_optional_users","distribute_to_self","enable_amisform","versionId","handle","self","latest","observeChanges","changed","added","onStop","stop","flow_ids","distribute_end_notification","allow_select_step","amis_schema","getMiniInstance","getMyapproveModified","instance_fields_0","miniApproveFields","needChange","triggerChangeFields","triggerChangeFieldsValues","myApproveModifieds","_instanceId","_trace","changeFields","_change","_rev","_my_approve_modifieds","isEqual","getInstanceTraces","_insId","inbox_users","asyncLastFinishedApprove","lastFinishedApproveAggregate","instanceid","dataMap","operation","rawCollection","aggregate","toArray","doc","isFunction","wrapAsync","getMyApprove","getMyLastFinishedApprove","getStepCurrentName","notFinishedTraces","agent","stepCurrentName","$slice","myLastFinishedApprove","agent_user_name","my_finish_date","is_cc","cc_count","tabularName","instance_ids","related_instance_ids","_async_get_flow_instances_aggregate","_get_flow_instances_aggregate","_items","$match","$group","$sum","_changeData","_flowsData","_init","dataItem","flow_instance","observe","getCollection","workflowTemplate","startup","absolute_path_cn","absolute_path_us","filesList_cn","filesList_us","fs","mime","path_cn","path_us","readFileList","pathDir","filesList","readdirSync","stat","statSync","isDirectory","workflowTemplates","resolve","existsSync","file","readFileSync","go_next","rule","schedule","cron","auto_finish_process_delegation","scheduleJob","bindEnvironment","time","process_delegation_rules","update","enabled","end_time","$lte","$set","multi","timeEnd","timeout_auto_submit","timeoutAutoSubmit","TabularTables","related_instances_tabular","Tabular","Table","collection","columns","title","orderable","render","input","step_current_name","current_step_name","dom","lengthChange","extraFields","pageLength","info","searching","responsive","details","autoWidth","changeSelector","curSpaceUser","$and","admins","fl","extend","GetBoxInstancesTabularOptions","_get_inbox_instances_tabular_options","_get_outbox_instances_tabular_options","_handleListFields","instanceTasksListTableTabular","instancesListTableTabular","newInstancesListTabular","updateTabularTitle","subs","SubsManager","ins_fields","pub","onUnload","instance_list","_tableColumns","drawCallback","ellipsisLink","emptyTd","colSpan","isPad","perfectScrollbar","oInstance","attr","click","goPage","height","pages","ceil","fnRecordsDisplay","_iDisplayLength","DataTable","page","draw","blur","currentPage","keydown","keyCode","createdRow","row","dataIndex","FlowRouter","setAttribute","agent_view","cc_view","instanceNamePriorityClass","modifiedFromNow","modifiedString","priorityIcon","priorityIconClass","priorityValue","step_current_name_view","unread","momentReactiveFromNow","priority","visible","cc_tag","record_need","lengthMenu","space_user","pagingType","is_list_display","inbox_instances","outbox_instances","getSort","flowInstances","ReactiveVar","_changeOrder"],"mappings":"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,CAAL;;AAEA,QAAG1wB,QAAH;AACC,aAAOqE,OAAOsH,WAAP,CAAmB,WAAS8kB,UAAT,GAAoB,QAApB,GAA4BhZ,EAA/C,CAAP;AADD;AAGC,aAAO/L,QAAQC,WAAR,CAAoB,WAAS8kB,UAAT,GAAoB,QAApB,GAA4BhZ,EAAhD,CAAP;ACIE;AD9BJ;AAAA,CADD,C;;;;;;;;;;;;;;;;;;;;;;;AEAA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;AC/BA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;AC/BA;;;;;;;AAOA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpCA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AAEA;AACA;AAEA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AACA;AAEA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,K;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACzmBA,IAAGkZ,QAAQC,GAAR,CAAYC,gBAAZ,KAAgC,aAAnC;AACIC,aAAWC,GAAX,CAAe,MAAf,EAAuB,eAAvB,EAAwC,UAACC,GAAD,EAAMvzB,GAAN,EAAWwzB,IAAX;AACpC,QAAAj5B,CAAA,EAAAk5B,QAAA;;AAAA;AAEIA,iBAAWF,IAAIpf,IAAf;AACA3M,cAAQC,GAAR,CAAY,UAAZ,EAAwBgsB,SAASC,MAAjC;AACAlsB,cAAQC,GAAR,CAAY,aAAZ,EAA2BgsB,SAAS7F,SAApC;AACApmB,cAAQC,GAAR,CAAY,YAAZ,EAA0BgsB,SAASE,QAAnC;ACCN,aDEMN,WAAWO,UAAX,CAAsB5zB,GAAtB,EACQ;AAAAyR,cAAM,GAAN;AACA3b,cAAM;AADN,OADR,CCFN;ADNE,aAAA0Z,KAAA;AAWMjV,UAAAiV,KAAA;AACFhI,cAAQgI,KAAR,CAAcjV,EAAEs5B,KAAhB;ACCN,aDAMR,WAAWO,UAAX,CAAsB5zB,GAAtB,EACI;AAAAyR,cAAM,GAAN;AACA3b,cAAM;AAAEg+B,kBAAQ,CAAC;AAACC,0BAAcx5B,EAAEy5B;AAAjB,WAAD;AAAV;AADN,OADJ,CCAN;AAUD;ADxBD;AC0BH,C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC3BD,IAAAC,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAC,6BAA2B,UAACC,MAAD,EAASC,YAAT,EAAuBC,oBAAvB;AAC1B,WAAOL,gBAAgBE,yBAAhB,CAA0CI,KAA1C,CAAgD,IAAhD,EAAsDngC,SAAtD,CAAP;AADD;AAEAogC,2BAAyB,UAACJ,MAAD,EAAS5G,MAAT,EAAiBkG,MAAjB;AACxB,WAAOO,gBAAgBO,uBAAhB,CAAwCD,KAAxC,CAA8C,IAA9C,EAAoDngC,SAApD,CAAP;AAHD;AAAA,CADD,E;;;;;;;;;;;ACDA;;;;;;;AAOA,MAAM;AAAE6/B;AAAF,IAAsBroB,OAAO,CAAC,mBAAD,CAAnC;;AACAhF,MAAM,CAACstB,OAAP,CAAe;AAEdO,mBAAiB,EAAE,UAAU1E,WAAV,EAAuB2E,UAAvB,EAAmCC,UAAnC,EAA+C;AACjE,WAAOV,eAAe,CAACQ,iBAAhB,CAAkCF,KAAlC,CAAwC,IAAxC,EAA8CngC,SAA9C,CAAP;AACA;AAJa,CAAf,E;;;;;;;;;;;ACRA,MAAM;AAAE6/B;AAAF,IAAsBroB,OAAO,CAAC,mBAAD,CAAnC;;AACAhF,MAAM,CAACstB,OAAP,CAAe;AAEdU,qBAAmB,EAAE,UAAU5Z,GAAV,EAAe;AACnC,WAAOiZ,eAAe,CAACW,mBAAhB,CAAoCL,KAApC,CAA0C,IAA1C,EAAgDngC,SAAhD,CAAP;AACA,GAJa;AAMdygC,qBAAmB,EAAE,UAAU1R,OAAV,EAAmB;AACvC,WAAO8Q,eAAe,CAACY,mBAAhB,CAAoCN,KAApC,CAA0C,IAA1C,EAAgDngC,SAAhD,CAAP;AACA;AARa,CAAf,E;;;;;;;;;;;ACDA;;;;;;;AAOA,MAAM;AAAE6/B;AAAF,IAAsBroB,OAAO,CAAC,mBAAD,CAAnC;;AACAhF,MAAM,CAACstB,OAAP,CAAe;AACdY,OAAK,EAAE,UAAU3R,OAAV,EAAmB4R,WAAnB,EAAgCvrB,WAAhC,EAA6C;AACnD,WAAOyqB,eAAe,CAACa,KAAhB,CAAsBP,KAAtB,CAA4B,IAA5B,EAAkCngC,SAAlC,CAAP;AACA,GAHa;AAKd4gC,SAAO,EAAE,UAAU7R,OAAV,EAAmB;AAC3B,WAAO8Q,eAAe,CAACe,OAAhB,CAAwBT,KAAxB,CAA8B,IAA9B,EAAoCngC,SAApC,CAAP;AACA,GAPa;AASd6gC,WAAS,EAAE,UAAUb,MAAV,EAAkB5qB,WAAlB,EAA+ByhB,SAA/B,EAA0CrJ,mBAA1C,EAA+D;AACzE,WAAOqS,eAAe,CAACgB,SAAhB,CAA0BV,KAA1B,CAAgC,IAAhC,EAAsCngC,SAAtC,CAAP;AACA,GAXa;AAad8gC,WAAS,EAAE,UAAU/a,UAAV,EAAsBqS,SAAtB,EAAiC;AAC3C,WAAOyH,eAAe,CAACiB,SAAhB,CAA0BX,KAA1B,CAAgC,IAAhC,EAAsCngC,SAAtC,CAAP;AACA,GAfa;AAiBd+gC,iBAAe,EAAE,UAAUpF,WAAV,EAAuBqF,WAAvB,EAAoC;AACpD,WAAOnB,eAAe,CAACkB,eAAhB,CAAgCZ,KAAhC,CAAsC,IAAtC,EAA4CngC,SAA5C,CAAP;AACA,GAnBa;AAqBdihC,SAAO,EAAE,UAAUjB,MAAV,EAAkB5qB,WAAlB,EAA+ByhB,SAA/B,EAA0CrJ,mBAA1C,EAA+D;AACvE,WAAOqS,eAAe,CAACoB,OAAhB,CAAwBd,KAAxB,CAA8B,IAA9B,EAAoCngC,SAApC,CAAP;AACA;AAvBa,CAAf,E;;;;;;;;;;;ACRA;;;;;;;AAOA,MAAM;AAAE6/B;AAAF,IAAsBroB,OAAO,CAAC,mBAAD,CAAnC;;AACAhF,MAAM,CAACstB,OAAP,CAAe;AACd;AACArF,kBAAgB,EAAE,UAAUkB,WAAV,EAAuBuF,QAAvB,EAAiCC,OAAjC,EAA0CC,2BAA1C,EAAuEhsB,WAAvE,EAAoFisB,oBAApF,EAA0GC,aAA1G,EAAyHC,WAAzH,EAAsIC,OAAtI,EAA+IC,eAA/I,EAAgK;AACjL,QAAI,CAAC,KAAK7T,MAAV,EACC,MAAM,IAAIpb,MAAM,CAACpE,KAAX,CAAiB,gBAAjB,CAAN;AAED;AACA,GAPa;AAUdszB,gBAAc,EAAE,UAAU/F,WAAV,EAAuBgG,QAAvB,EAAiCC,UAAjC,EAA6C;AAC5D,WAAO/B,eAAe,CAAC6B,cAAhB,CAA+BvB,KAA/B,CAAqC,IAArC,EAA2CngC,SAA3C,CAAP;AACA,GAZa;AAcd6hC,kBAAgB,EAAE,UAAUlG,WAAV,EAAuBqF,WAAvB,EAAoC;AACrD,WAAOnB,eAAe,CAACgC,gBAAhB,CAAiC1B,KAAjC,CAAuC,IAAvC,EAA6CngC,SAA7C,CAAP;AACA;AAhBa,CAAf,E;;;;;;;;;;;ACRA;;;;;;;AAOA,MAAM;AAAE6/B;AAAF,IAAsBroB,OAAO,CAAC,mBAAD,CAAnC;;AACAhF,MAAM,CAACstB,OAAP,CAAe;AACXgC,sBAAoB,EAAE,UAAUC,OAAV,EAAmB;AACrC,WAAOlC,eAAe,CAACiC,oBAAhB,CAAqC3B,KAArC,CAA2C,IAA3C,EAAiDngC,SAAjD,CAAP;AACH,GAHU;AAKXgiC,2BAAyB,EAAE,UAAUD,OAAV,EAAmB;AAC1C,WAAOlC,eAAe,CAACmC,yBAAhB,CAA0C7B,KAA1C,CAAgD,IAAhD,EAAsDngC,SAAtD,CAAP;AACH,GAPU;AASXiiC,oBAAkB,EAAE,UAAUF,OAAV,EAAmBG,OAAnB,EAA4B/tB,SAA5B,EAAuC;AACvD,WAAO0rB,eAAe,CAACoC,kBAAhB,CAAmC9B,KAAnC,CAAyC,IAAzC,EAA+CngC,SAA/C,CAAP;AACH,GAXU;AAaXmiC,sBAAoB,EAAE,UAAUJ,OAAV,EAAmB;AACrC,WAAOlC,eAAe,CAACsC,oBAAhB,CAAqChC,KAArC,CAA2C,IAA3C,EAAiDngC,SAAjD,CAAP;AACH,GAfU;AAiBXoiC,6CAA2C,EAAE,UAAUC,OAAV,EAAmBC,YAAnB,EAAiC;AAC1E,WAAOzC,eAAe,CAACuC,2CAAhB,CAA4DjC,KAA5D,CAAkE,IAAlE,EAAwEngC,SAAxE,CAAP;AACH;AAnBU,CAAf,E;;;;;;;;;;;;ACRA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAyC,yBAAuB,UAACxc,UAAD,EAAa+W,OAAb,EAAsB1E,SAAtB;AACtB,WAAOyH,gBAAgB0C,qBAAhB,CAAsCpC,KAAtC,CAA4C,IAA5C,EAAkDngC,SAAlD,CAAP;AADD;AAGAwiC,uBAAqB,UAACzc,UAAD,EAAa+W,OAAb,EAAsB1E,SAAtB,EAAiChjB,WAAjC,EAA8CM,WAA9C;AACpB,WAAOmqB,gBAAgB2C,mBAAhB,CAAoCrC,KAApC,CAA0C,IAA1C,EAAgDngC,SAAhD,CAAP;AAJD;AAMAyiC,uBAAqB,UAAC1c,UAAD,EAAa+W,OAAb,EAAsB1E,SAAtB,EAAiClJ,eAAjC,EAAkD9Z,WAAlD,EAA+DstB,SAA/D,EAA0EC,eAA1E;AACpB,WAAO9C,gBAAgB4C,mBAAhB,CAAoCtC,KAApC,CAA0C,IAA1C,EAAgDngC,SAAhD,CAAP;AAPD;AAUA4iC,oBAAkB,UAACC,IAAD,EAAOC,YAAP;AACjB,WAAOjD,gBAAgB+C,gBAAhB,CAAiCzC,KAAjC,CAAuC,IAAvC,EAA6CngC,SAA7C,CAAP;AAXD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAiD,mBAAiB,UAAChU,OAAD,EAAU2E,MAAV;AAChB,WAAOmM,gBAAgBkD,eAAhB,CAAgC5C,KAAhC,CAAsC,IAAtC,EAA4CngC,SAA5C,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAkD,mBAAiB,UAACC,YAAD,EAAeC,YAAf,EAA6BC,eAA7B,EAA8CxH,WAA9C,EAA2DyH,YAA3D,EAAyEzB,QAAzE;AAChB,WAAO9B,gBAAgBmD,eAAhB,CAAgC7C,KAAhC,CAAsC,IAAtC,EAA4CngC,SAA5C,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAuD,6BAA2B,UAACC,SAAD,EAAY/sB,SAAZ,EAAuBgtB,MAAvB;AAC1B,WAAO1D,gBAAgBwD,yBAAhB,CAA0ClD,KAA1C,CAAgD,IAAhD,EAAsDngC,SAAtD,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAAwjC,KAAA,EAAA3D,eAAA;;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACF2D,QAAQhsB,QAAQ,MAAR,CAAR;AAEAhF,OAAOstB,OAAP,CACC;AAAAjM,yBAAuB,UAACwO,OAAD,EAAU75B,IAAV;AACtB,WAAOq3B,gBAAgBhM,qBAAhB,CAAsCsM,KAAtC,CAA4C,IAA5C,EAAkDngC,SAAlD,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACHA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAA2D,qBAAmB,UAACzD,MAAD,EAASx3B,IAAT;AAClB,WAAOq3B,gBAAgB4D,iBAAhB,CAAkCtD,KAAlC,CAAwC,IAAxC,EAA8CngC,SAA9C,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAA4D,kBAAgB,UAAC1D,MAAD,EAAS2D,SAAT;AACf,WAAO9D,gBAAgB6D,cAAhB,CAA+BvD,KAA/B,CAAqC,IAArC,EAA2CngC,SAA3C,CAAP;AADD;AAGA4jC,2BAAyB,UAAC5D,MAAD,EAASnd,iBAAT;AACxB,WAAOgd,gBAAgB+D,uBAAhB,CAAwCzD,KAAxC,CAA8C,IAA9C,EAAoDngC,SAApD,CAAP;AAJD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAA+D,sBAAoB,UAACniC,IAAD;AACnB,WAAOm+B,gBAAgBgE,kBAAhB,CAAmC1D,KAAnC,CAAyC,IAAzC,EAA+CngC,SAA/C,CAAP;AADD;AAGA8jC,kBAAgB,UAACpiC,IAAD;AACf,WAAOm+B,gBAAgBiE,cAAhB,CAA+B3D,KAA/B,CAAqC,IAArC,EAA2CngC,SAA3C,CAAP;AAJD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAiE,cAAY,UAACnuB,KAAD,EAAQouB,MAAR,EAAgBjgC,KAAhB;AAEX,WAAO87B,gBAAgBkE,UAAhB,CAA2B5D,KAA3B,CAAiC,IAAjC,EAAuCngC,SAAvC,CAAP;AAFD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAmE,uBAAqB,UAACjE,MAAD;AACpB,WAAOH,gBAAgBoE,mBAAhB,CAAoC9D,KAApC,CAA0C,IAA1C,EAAgDngC,SAAhD,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAA,yBAAuB,UAAClqB,KAAD,EAAQsuB,UAAR,EAAoBC,OAApB;AACtB,WAAOtE,gBAAgBuE,mBAAhB,CAAoCjE,KAApC,CAA0C,IAA1C,EAAgDngC,SAAhD,CAAP;AADD;AAGA,+BAA6B,UAAC4V,KAAD,EAAQsuB,UAAR,EAAoBC,OAApB;AAC5B,WAAOtE,gBAAgBwE,yBAAhB,CAA0ClE,KAA1C,CAAgD,IAAhD,EAAsDngC,SAAtD,CAAP;AAJD;AAMA,qBAAmB,UAACo2B,WAAD;AAClB,WAAOyJ,gBAAgByE,eAAhB,CAAgCnE,KAAhC,CAAsC,IAAtC,EAA4CngC,SAA5C,CAAP;AAPD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAAyE,qBAAmB,UAACzmB,KAAD;AAClB,WAAO+hB,gBAAgB0E,iBAAhB,CAAkCpE,KAAlC,CAAwC,IAAxC,EAA8CngC,SAA9C,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CAEC;AAAA0E,iBAAe,UAACC,KAAD,EAAQC,SAAR;AACd,WAAO7E,gBAAgB2E,aAAhB,CAA8BrE,KAA9B,CAAoC,IAApC,EAA0CngC,SAA1C,CAAP;AADD;AAAA,CAFD,E;;;;;;;;;;;;ACDA,IAAA6/B,eAAA;AAAEA,kBAAoBroB,QAAQ,mBAAR,EAAAqoB,eAApB;AACFrtB,OAAOstB,OAAP,CACC;AAAA6E,qBAAmB,UAACF,KAAD;AAClB,WAAO5E,gBAAgB8E,iBAAhB,CAAkCxE,KAAlC,CAAwC,IAAxC,EAA8CngC,SAA9C,CAAP;AADD;AAAA,CADD,E;;;;;;;;;;;;ACDA,IAAA4kC,OAAA,EAAAC,mBAAA;AAAAD,UAAUptB,QAAQ,SAAR,CAAV;;AAEAqtB,sBAAsB,UAAC1F,GAAD,EAAMvzB,GAAN,EAAWwzB,IAAX,EAAiBr1B,OAAjB;AAErB,MAAA+6B,cAAA,EAAAC,OAAA,EAAAC,iBAAA,EAAAC,OAAA,EAAA7pB,KAAA,EAAA8pB,WAAA,EAAA3iB,IAAA,EAAAxO,QAAA,EAAAgS,UAAA,EAAA5S,GAAA,EAAA+K,IAAA,EAAAtI,KAAA,EAAAysB,OAAA,EAAA8C,cAAA,EAAAjxB,IAAA,EAAA0Z,MAAA;;AAAA1Z,SAAO2F,QAAQurB,eAAR,CAAwBjG,GAAxB,EAA6BvzB,GAA7B,CAAP;;AAEA,MAAAuzB,OAAA,QAAAhsB,MAAAgsB,IAAA/7B,KAAA,YAAA+P,IAAekyB,YAAf,GAAe,MAAf,GAAe,MAAf;AACCzX,aAAS/T,QAAQyrB,wBAAR,CAAiCnG,IAAI/7B,KAAJ,CAAUiiC,YAA3C,CAAT;;AACA,QAAGzX,MAAH;AACC1Z,aAAO1B,OAAO8pB,KAAP,CAAaxpB,OAAb,CAAqB;AAACC,aAAK6a;AAAN,OAArB,CAAP;AAHF;ACQE;;ADHFyU,YAAUlD,IAAIoE,MAAJ,CAAW3tB,KAArB;AAEAmQ,eAAaoZ,IAAIoE,MAAJ,CAAW5H,WAAxB;AAEA5nB,aAAWnB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,SAAKgT;AAAN,GAArB,CAAX;AAEAnQ,UAAQhD,GAAG2yB,MAAH,CAAUzyB,OAAV,CAAkB;AAACC,SAAKsvB;AAAN,GAAlB,CAAR;AAEA6C,gBAAA,CAAAhnB,OAAAihB,IAAA/7B,KAAA,YAAA8a,KAAyBgnB,WAAzB,GAAyB,MAAzB;;AAEA,MAAG,CAACn7B,OAAJ;AACCA,cAAU;AAACyZ,iBAAW;AAAZ,KAAV;AADD;AAGCzZ,YAAQyZ,SAAR,GAAoB,IAApB;ACMC;;ADJF,MAAG0hB,gBAAe,GAAlB;AACC,QAAGn7B,OAAH;AACCA,cAAQyZ,SAAR,GAAoB,KAApB;AADD;AAGCzZ,gBAAU;AAACyZ,mBAAW;AAAZ,OAAV;AAJF;ACaE;;ADPF,MAAG,CAACzZ,QAAQ2Z,eAAZ;AACC3Z,YAAQ2Z,eAAR,GAA0B,IAA1B;ACSC;;ADPF,MAAG,CAAC9N,KAAJ;AACCqpB,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS,mCAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;ACWC;;ADTF,MAAI,CAACqS,QAAL;AACCkrB,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS,sCAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;ACaC;;ADXF,MAAG,CAACwS,IAAJ;AACC+qB,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS,oDAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;ACeC;;ADbF,MAAGqS,SAAS6B,KAAT,KAAkBysB,OAArB;AACCpD,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS,+CAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;ACiBC;;ADbFyjC,mBAAiBvyB,GAAG4yB,WAAH,CAAe3pB,IAAf,CAAoB;AAAE3H,UAAMA,KAAKnB,GAAb;AAAkB6C,WAAOysB;AAAzB,GAApB,EAAwD5N,KAAxD,EAAjB;;AAEA,MAAG0Q,mBAAkB,CAArB;AACC,QAAG,CAACvvB,KAAJ;AACCqpB,iBAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,cAAM,GAAN;AACA3b,cACC;AAAA,mBAAS,uCAAT;AACA,qBAAW;AADX;AAFD,OADD;AAKA;AAPF;AC2BE;;ADjBFojC,mBAAiBjmB,gBAAgB4mB,sBAAhB,CAAuCvxB,IAAvC,EAA6CH,QAA7C,CAAjB;;AAEA,MAAG,CAAC+wB,cAAD,IAAoB/wB,SAAS2C,wBAAhC;AACCsuB,wBAAoBxxB,EAAEkkB,KAAF,CAAQ,CAAC3jB,SAAS2C,wBAAV,CAAR,EAA6C3C,SAAS2hB,yBAAT,IAAsC,EAAnF,CAApB;AAEAoP,qBAAiBtxB,EAAEqI,IAAF,CAAOmpB,iBAAP,EAA0B,UAACU,UAAD;AAC1C,UAAAC,WAAA;;AAAAA,oBAAc/yB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,aAAI2yB;AAAL,OAArB,EAAuC;AAACpzB,gBAAQ;AAACwO,kBAAQ;AAAT;AAAT,OAAvC,CAAd;AAEA,aAAOjC,gBAAgB4mB,sBAAhB,CAAuCvxB,IAAvC,EAA6CyxB,WAA7C,CAAP;AAHgB,MAAjB;AC2BC;;ADtBF,MAAG,CAACb,cAAJ;AACCC,cAAUlrB,QAAQI,MAAR,CAAe/F,KAAKnB,GAApB,EAAyB,IAAzB,CAAV;AACAqI,YAAQI,QAAQC,EAAR,CAAW,4BAAX,EAAyC,EAAzC,EAA6CspB,OAA7C,CAAR;AACAn5B,QAAIg6B,OAAJ,GAAc,OAAd;AACA3G,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS0Z,KAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;AC0BC;;ADxBFmH,SAAO9K,yBAAyBuK,eAAzB,CAAyC9N,IAAzC,EAA+C0B,KAA/C,EAAsD7B,QAAtD,EAAgEhK,OAAhE,CAAP;AACAk7B,YAAU,IAAIY,MAAJ,CAAWtjB,IAAX,CAAV;AACA3W,MAAIk6B,SAAJ,CAAc,cAAd,EAA8B,0BAA9B;AACAl6B,MAAIk6B,SAAJ,CAAc,gBAAd,EAAgCb,QAAQhlC,MAAxC;AACA2L,MAAIk6B,SAAJ,CAAc,eAAd,EAA+B,cAAWb,QAAQhlC,MAAR,GAAiB,CAA5B,IAA8B,GAA9B,GAAiCglC,QAAQhlC,MAAxE;AACA2L,MAAIm6B,UAAJ,GAAiB,GAAjB;AC0BC,SDzBDn6B,IAAI5H,GAAJ,CAAQue,IAAR,CCyBC;ADnIoB,CAAtB;;AA4GA0c,WAAWC,GAAX,CAAe,KAAf,EAAsB,mDAAtB,EAA2E2F,mBAA3E;AAEA5F,WAAWC,GAAX,CAAe,KAAf,EAAsB,kEAAtB,EAA0F,UAACC,GAAD,EAAMvzB,GAAN,EAAWwzB,IAAX;AACzF,MAAAr1B,OAAA;AAAA6B,MAAIk6B,SAAJ,CAAc,cAAd,EAA8B,0BAA9B;AACAl6B,MAAIk6B,SAAJ,CAAc,qBAAd,EAAqC,yBAAuB3qB,UAAUgkB,IAAIoE,MAAJ,CAAW1tB,aAArB,CAA5D;AACAjK,MAAIk6B,SAAJ,CAAc,mBAAd,EAAmC,EAAnC;AAEA/7B,YAAU;AAACoE,cAAU;AAAX,GAAV;AAEA,SAAO02B,oBAAoB1F,GAApB,EAAyBvzB,GAAzB,EAA8BwzB,IAA9B,EAAoCr1B,OAApC,CAAP;AAPD,G,CAQA;;;;;AAKAk1B,WAAWC,GAAX,CAAe,KAAf,EAAsB,yBAAtB,EAAiD,UAACC,GAAD,EAAMvzB,GAAN,EAAWwzB,IAAX;AAEhD,MAAAlsB,CAAA,EAAA8wB,MAAA,EAAAG,OAAA,EAAArmB,KAAA,EAAAlc,CAAA,EAAA4yB,SAAA,EAAApxB,KAAA,EAAA+P,GAAA,EAAA+K,IAAA,EAAAwQ,IAAA,EAAAC,IAAA,EAAAqX,cAAA,EAAA3D,OAAA,EAAA4D,SAAA,EAAAC,sBAAA,EAAAC,UAAA,EAAAjE,OAAA;;AAAA,MAAG,CAACroB,QAAQusB,sBAAR,CAA+BjH,GAA/B,EAAoCvzB,GAApC,CAAJ;AACC;ACgCC;;AD9BFs2B,YAAU/C,IAAIvR,MAAd;AAEAyU,YAAUlD,IAAIkH,OAAJ,CAAY,YAAZ,CAAV;;AAEA,MAAG,CAAIhE,OAAP;AACCpD,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS,wCAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;ACgCC;;AD9BFsiC,WAAA,CAAA7wB,MAAAgsB,IAAA/7B,KAAA,YAAA+P,IAAoB6wB,MAApB,GAAoB,MAApB;;AAEA,MAAG,CAACA,MAAJ;AACC/E,eAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,YAAM,GAAN;AACA3b,YACC;AAAA,iBAAS,oCAAT;AACA,mBAAW;AADX;AAFD,KADD;AAKA;ACiCC;;AD/BF0B,UAAQ,EAAR;AAEA4iC,mBAAiB,IAAItxB,IAAJ,GAAWmb,OAAX,EAAjB;AAEAsU,YAAUH,OAAOl9B,KAAP,CAAa,GAAb,CAAV;AAGAgX,UAAQlL,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAC9I,SAAK;AAAC4iB,WAAKwO;AAAN;AAAN,GAAd,EAAqCvN,KAArC,EAAR;AAEAh1B,MAAI,CAAJ;;AACA,SAAMA,IAAIkc,MAAM7d,MAAhB;AACCiT,QAAI4K,MAAMlc,CAAN,CAAJ;AACAqkC,gBAAYrzB,GAAG4yB,WAAH,CAAe1yB,OAAf,CAAuB;AAAC8C,aAAO1C,EAAE0C,KAAV;AAAiB1B,YAAMguB;AAAvB,KAAvB,CAAZ;;AACA,QAAG,CAAC+D,SAAJ;AACChH,iBAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,cAAM,GAAN;AACA3b,cACC;AAAA,mBAAS,gDAA8CwR,EAAEH,GAAzD;AACA,qBAAW;AADX;AAFD,OADD;AAKA;AAND,YC6CG;;ADnCH,QAAG,CAAC8G,QAAQysB,YAAR,CAAqBjE,OAArB,EAA8BH,OAA9B,CAAJ;AACCgE,+BAAyBtzB,GAAG2zB,aAAH,CAAiB1qB,IAAjB,CAAsB;AAC9C9I,aAAK;AACJ4iB,eAAKsQ,UAAUM;AADX;AADyC,OAAtB,EAItB3P,KAJsB,EAAzB;;AAMA,UAAG,CAAC/X,gBAAgB2nB,UAAhB,CAA2BtzB,CAA3B,EAA8B+yB,SAA9B,EAAyCC,sBAAzC,CAAD,IAAqE,CAACrnB,gBAAgB4nB,QAAhB,CAAyBvzB,CAAzB,EAA4B+yB,SAA5B,EAAuCC,sBAAvC,CAAzE;AACCjH,mBAAWO,UAAX,CAAsB5zB,GAAtB,EACC;AAAAyR,gBAAM,GAAN;AACA3b,gBACC;AAAA,qBAAS,gDAA8CwR,EAAEH,GAAzD;AACA,uBAAW;AADX;AAFD,SADD;AAKA;AAbF;ACoDG;;ADtCHnR;AA3BD;;AA8BAwB,QAAMgT,IAAN,GAAa;AAACuf,SAAKwO;AAAN,GAAb;AAEA/gC,QAAMwS,KAAN,GAAcysB,OAAd;;AAEA,OAAAnkB,OAAAihB,IAAA/7B,KAAA,YAAA8a,KAAcioB,UAAd,GAAc,MAAd;AACCA,iBAAa,IAAIzxB,IAAJ,CAASQ,OAAOiqB,IAAI/7B,KAAJ,CAAU+iC,UAAjB,CAAT,CAAb;AACA/iC,UAAMiS,QAAN,GAAiB;AAACqxB,WAAKP;AAAN,KAAjB;ACyCC;;ADvCF,OAAAzX,OAAAyQ,IAAA/7B,KAAA,YAAAsrB,KAAcjL,cAAd,GAAc,MAAd;AACCrgB,UAAMqgB,cAAN,GAAuB;AAACkS,WAAMwJ,IAAI/7B,KAAJ,CAAUqgB,cAAV,CAAyB3c,KAAzB,CAA+B,GAA/B;AAAP,KAAvB;AADD;AAGC1D,UAAMqgB,cAAN,GAAuB;AAACkjB,YAAM,CAAC,YAAD,EAAe,UAAf;AAAP,KAAvB;AC6CC;;AD3CF,OAAAhY,OAAAwQ,IAAA/7B,KAAA,YAAAurB,KAAczP,KAAd,GAAc,MAAd;AACC9b,UAAM8b,KAAN,GAAc;AAACyW,WAAKwJ,IAAI/7B,KAAJ,CAAU8b,KAAV,CAAgBpY,KAAhB,CAAsB,GAAtB;AAAN,KAAd;AADD;AAGC1D,UAAM8b,KAAN,GAAc,WAAd;AC+CC;;AD5CFsV,cAAY5hB,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkBzY,KAAlB,EAAyB;AAACkP,YAAQ;AAACs0B,kBAAY,CAAb;AAAgBC,gBAAU,CAA1B;AAA6BC,oBAAc,CAA3C;AAA8ChmB,cAAQ,CAAtD;AAAyD4V,mBAAa;AAAtE,KAAT;AAAmFqQ,UAAM,CAAzF;AAA4FC,WAAO;AAAnG,GAAzB,EAAkIpQ,KAAlI,EAAZ;AACApC,YAAUvhB,OAAV,CAAkB,UAACc,QAAD;AAEjB,QAAA2iB,WAAA;AAAAA,kBAAcnC,IAAIC,SAAJ,CAAc3Y,IAAd,CAAmB;AAAC,2BAAqB9H,SAAShB,GAA/B;AAAmC,0BAAoB,IAAvD;AAA6D,6BAAuB;AAACyiB,aAAK;AAAN;AAApF,KAAnB,EAAqH;AAACljB,cAAQ;AAAC20B,gBAAQ;AAAT;AAAT,KAArH,EAA4IrQ,KAA5I,EAAd;ACkEE,WDhEF7iB,SAAS2iB,WAAT,GAAuBA,WCgErB;ADpEH;AAOAuI,aAAWO,UAAX,CAAsB5zB,GAAtB,EACE;AAAAyR,UAAM,GAAN;AACA3b,UACC;AAAA,gBAAU,SAAV;AACA,oBAAcskC,cADd;AAEA,cAAQxR;AAFR;AAFD,GADF;AA9FD,G;;;;;;;;;;;;AE5HAyK,WAAWC,GAAX,CAAe,KAAf,EAAsB,cAAtB,EAAsC,UAACC,GAAD,EAAMvzB,GAAN,EAAWwzB,IAAX;AACrC,MAAA8H,MAAA,EAAAjlB,UAAA;AAAArW,MAAIk6B,SAAJ,CAAc,cAAd,EAA8B,UAA9B;AACAoB,WAASC,OAAOC,oBAAP,EAAT;AAEAnlB,eAAa,EAAb;AAEAilB,SAAOj0B,OAAP,CAAe,UAACo0B,GAAD;AACd,QAAAjlB,OAAA,EAAAklB,OAAA;;AAAA,QAAGC,0BAA0BC,oBAA7B;AACCF,gBAAUC,0BAA0BE,QAApC;;AACA,UAAGH,QAAQI,QAAR,CAAiB,GAAjB,CAAH;AACCtlB,kBAAUklB,QAAQtmC,OAAR,CAAgBumC,0BAA0BC,oBAA1B,GAAiD,GAAjE,EAAsE,EAAtE,IAA4EH,IAAIxnC,GAA1F;AADD;AAGCuiB,kBAAUklB,QAAQtmC,OAAR,CAAgBumC,0BAA0BC,oBAA1C,EAAgE,EAAhE,IAAsEH,IAAIxnC,GAApF;AALF;AAAA;AAOCuiB,gBAAU5P,OAAOsH,WAAP,CAAmButB,IAAIxnC,GAAvB,CAAV;ACCE;;AACD,WDDFoiB,cAAc,iBAAeG,OAAf,GAAuB,ICCnC;ADVH;AAWAxW,MAAIm6B,UAAJ,GAAiB,GAAjB;ACEC,SDDDn6B,IAAI5H,GAAJ,CAAQie,UAAR,CCCC;ADnBF,G;;;;;;;;;;;;AEDAgd,WAAWC,GAAX,CAAe,KAAf,EAAsB,6CAAtB,EAAqE,UAACC,GAAD,EAAMvzB,GAAN,EAAWwzB,IAAX;AACpE,MAAA6F,OAAA,EAAA7uB,IAAA,EAAA4tB,MAAA,EAAA9xB,IAAA,EAAAqQ,IAAA,EAAAxO,QAAA,EAAAhK,OAAA,EAAA6L,KAAA,EAAAysB,OAAA,EAAAnuB,IAAA,EAAAguB,OAAA;;AAAA,MAAG,CAACroB,QAAQusB,sBAAR,CAA+BjH,GAA/B,EAAoCvzB,GAApC,CAAJ;AACC;ACEC;;ADAFs2B,YAAU/C,IAAIvR,MAAd;AAEA1Z,SAAOtB,GAAG0pB,KAAH,CAASxpB,OAAT,CAAiB;AAAEC,SAAKmvB;AAAP,GAAjB,CAAP;AAEAG,YAAUlD,IAAIoE,MAAJ,CAAW3tB,KAArB;AAEAouB,WAAS7E,IAAIoE,MAAJ,CAAWntB,IAApB;AAEAR,UAAQhD,GAAG2yB,MAAH,CAAUzyB,OAAV,CAAkB;AAAEC,SAAKsvB;AAAP,GAAlB,CAAR;AAEAjsB,SAAOxD,GAAGkL,KAAH,CAAShL,OAAT,CAAiB;AAAEC,SAAKixB;AAAP,GAAjB,EAAkC;AAAE1xB,YAAQ;AAAE9J,YAAM,CAAR;AAAW,qBAAe,CAA1B;AAA6B0J,YAAM;AAAnC;AAAV,GAAlC,CAAP;AAEAA,SAAOU,GAAGC,KAAH,CAASC,OAAT,CAAiB;AAAEC,SAAKqD,KAAKlE;AAAZ,GAAjB,EAAqC;AAAEI,YAAQ;AAAE,qBAAe;AAAjB;AAAV,GAArC,CAAP;AAEAvI,YAAU;AACTyZ,eAAW,KADF;AAETE,qBAAiB,KAFR;AAGTrD,kBAAc,SAHL;AAITZ,cAAU,IAJD;AAKTyD,WAAO,MALE;AAMTtC,oBAAgB,kBANP;AAOTkD,aAAS,wMAKC1N,KAAK5N,IALN,GAKW;AAZX,GAAV;AA6BAuL,aAAW;AACVqC,UAAMA,KAAKrD,GADD;AAEV8K,kBAAczH,KAAKqH,OAAL,CAAa1K,GAFjB;AAGVb,UAAMA,KAAKa,GAHD;AAIVZ,kBAAcD,KAAKuL,OAAL,CAAa1K,GAJjB;AAKV+B,YAAQ,EALE;AAMVtM,UAAM4N,KAAK5N,IAND;AAOVoN,WAAOysB;AAPG,GAAX;AAUA9f,SAAO9K,yBAAyBuK,eAAzB,CAAyC9N,IAAzC,EAA+C0B,KAA/C,EAAsD7B,QAAtD,EAAgEhK,OAAhE,CAAP;AAEAk7B,YAAU,IAAIY,MAAJ,CAAWtjB,IAAX,CAAV;AAEA3W,MAAIk6B,SAAJ,CAAc,gBAAd,EAAgCb,QAAQhlC,MAAxC;AAEA2L,MAAIk6B,SAAJ,CAAc,eAAd,EAA+B,cAAWb,QAAQhlC,MAAR,GAAiB,CAA5B,IAA8B,GAA9B,GAAiCglC,QAAQhlC,MAAxE;AAEA2L,MAAIm6B,UAAJ,GAAiB,GAAjB;ACZC,SDcDn6B,IAAI5H,GAAJ,CAAQue,IAAR,CCdC;ADrDF,G;;;;;;;;;;;AEAAhQ,KAAK,CAAC7R,SAAN,CAAgBqqB,cAAhB,GAAiC,UAAS4c,CAAT,EAAYnlC,CAAZ,EAAc;AAC3C,MAAIolC,CAAC,GAAG,EAAR;AACA,OAAK30B,OAAL,CAAa,UAASpL,CAAT,EAAW;AACpB,QAAIggC,CAAC,GAAGhgC,CAAC,GAAEA,CAAC,CAAC8/B,CAAD,CAAH,GAAO,IAAhB;AACA,QAAI93B,CAAC,GAAG,KAAR;;AACA,QAAGg4B,CAAC,YAAYt1B,KAAhB,EAAsB;AAClB1C,OAAC,GAAGg4B,CAAC,CAACziB,QAAF,CAAW5iB,CAAX,CAAJ;AACH,KAFD,MAEK;AACDqN,OAAC,GAAIrN,CAAC,KAAKrC,SAAP,GAAmB,KAAnB,GAAyB0nC,CAAC,IAAErlC,CAAhC;AACH;;AACD,QAAGqN,CAAH,EAAK;AACD+3B,OAAC,CAACn/B,IAAF,CAAOZ,CAAP;AACH;AACJ,GAXD;AAYA,SAAO+/B,CAAP;AACH,CAfD;;AAiBAr1B,KAAK,CAAC7R,SAAN,CAAgB4a,WAAhB,GAA8B,UAASwsB,CAAT,EAAW;AACrC,MAAI5oC,CAAC,GAAG,IAAIqT,KAAJ,EAAR;AACA,OAAKU,OAAL,CAAa,UAASpL,CAAT,EAAW;AACpB,QAAIggC,CAAC,GAAGhgC,CAAC,GAAEA,CAAC,CAACigC,CAAD,CAAH,GAAO,IAAhB;AACA5oC,KAAC,CAACuJ,IAAF,CAAOo/B,CAAP;AACH,GAHD;AAIA,SAAO3oC,CAAP;AACH,CAPD;;AASAqT,KAAK,CAAC7R,SAAN,CAAgBqnC,OAAhB,GAA0B,UAAS1qB,IAAT,EAAc;AACpC,MAAIe,GAAG,GAAG,EAAV;;AACA,OAAI,IAAIxc,CAAC,GAAG,CAAZ,EAAgBA,CAAC,GAAG,KAAK3B,MAAzB,EAAkC2B,CAAC,EAAnC,EAAsC;AAClCwc,OAAG,CAAC3V,IAAJ,CAAS,KAAK7G,CAAL,EAAQyb,IAAR,CAAT;AACH;;AACD,SAAOe,GAAP;AACH,CAND;;AAQA7L,KAAK,CAAC7R,SAAN,CAAgBsnC,IAAhB,GAAuB,YAAU;AAC7B,MAAIzhB,CAAC,GAAG,EAAR;AACA,OAAKtT,OAAL,CAAa,UAASuT,CAAT,EAAW;AACpB,QAAGD,CAAC,CAAC/e,OAAF,CAAUgf,CAAV,IAAe,CAAlB,EACI;AAACD,OAAC,CAACA,CAAC,CAACtmB,MAAH,CAAD,GAAcumB,CAAd;AAAgB;AACxB,GAHD;AAIA,SAAOD,CAAP;AACH,CAPD;;AASAmC,YAAY,GAAG,EAAf;;AAGAA,YAAY,CAACuf,KAAb,GAAqB,UAASC,IAAT,EAAen8B,GAAf,EAAmB;AACpC,OAAI,IAAI/C,GAAR,IAAe+C,GAAf,EAAmB;AACfm8B,QAAI,CAACl/B,GAAD,CAAJ,GAAY+C,GAAG,CAAC/C,GAAD,CAAf;AACH;;AACD,SAAOk/B,IAAP;AACH,CALD;;AAQAxf,YAAY,CAACyf,gBAAb,GAAgC,UAASxc,CAAT,EAAW;AAEvC,MAAGA,CAAC,YAAYpZ,KAAhB,EAAsB;AAClB,QAAI2B,IAAI,GAAG,EAAX;AAEAA,QAAI,CAAC1L,IAAL,GAAYmjB,CAAC,CAACrQ,WAAF,CAAc,MAAd,CAAZ;AACApH,QAAI,CAACk0B,YAAL,GAAoB,EAApB;AACAl0B,QAAI,CAACk0B,YAAL,CAAkB5/B,IAAlB,GAAyBmjB,CAAC,CAACrQ,WAAF,CAAc,cAAd,EAA8BA,WAA9B,CAA0C,MAA1C,CAAzB;AACApH,QAAI,CAACk0B,YAAL,CAAkB7sB,QAAlB,GAA6BoQ,CAAC,CAACrQ,WAAF,CAAc,cAAd,EAA8BA,WAA9B,CAA0C,UAA1C,CAA7B;AAEApH,QAAI,CAACm0B,EAAL,GAAU1c,CAAC,CAACrQ,WAAF,CAAc,IAAd,CAAV;AAEApH,QAAI,CAACo0B,OAAL,GAAe3c,CAAC,CAACrQ,WAAF,CAAc,SAAd,CAAf;AAENpH,QAAI,CAACq0B,MAAL,GAAc5c,CAAC,CAACrQ,WAAF,CAAc,QAAd,CAAd;AAEApH,QAAI,CAACs0B,UAAL,GAAkB7c,CAAC,CAACrQ,WAAF,CAAc,YAAd,CAAlB;AAEApH,QAAI,CAACu0B,QAAL,GAAgB9c,CAAC,CAACrQ,WAAF,CAAc,UAAd,CAAhB;AAEM,QAAIotB,SAAS,GAAG/c,CAAC,CAACrQ,WAAF,CAAc,OAAd,CAAhB;AACA,QAAIqtB,KAAK,GAAG,IAAIp2B,KAAJ,EAAZ;AACAm2B,aAAS,CAACz1B,OAAV,CAAkB,UAASrR,CAAT,EAAW;AACzB+mC,WAAK,GAAGA,KAAK,CAACx/B,MAAN,CAAavH,CAAb,CAAR;AACH,KAFD;AAGA+mC,SAAK,CAACX,IAAN;AACA9zB,QAAI,CAACy0B,KAAL,GAAaA,KAAb;AACA,WAAOz0B,IAAP;AACH,GA1BD,MA0BK;AACD,WAAOyX,CAAP;AACH;AACJ,CA/BD;;AAiCAjD,YAAY,CAACkgB,eAAb,GAA+B,UAAS/c,CAAT,EAAW;AAEtC,MAAGA,CAAC,YAAYtZ,KAAhB,EAAsB;AAClB,QAAIs2B,GAAG,GAAG,EAAV;AACNA,OAAG,CAACjjB,EAAJ,GAASiG,CAAC,CAACvQ,WAAF,CAAc,KAAd,CAAT;AACMutB,OAAG,CAACrgC,IAAJ,GAAWqjB,CAAC,CAACvQ,WAAF,CAAc,MAAd,CAAX;AACAutB,OAAG,CAACttB,QAAJ,GAAesQ,CAAC,CAACvQ,WAAF,CAAc,UAAd,CAAf;AAEA,WAAOutB,GAAP;AACH,GAPD,MAOK;AACD,WAAOhd,CAAP;AACH;AACJ,CAZD;AAgBA;;;;;;;AAKAnD,YAAY,CAACogB,mBAAb,GAAmC,UAASx2B,MAAT,EAAiBy2B,WAAjB,EAA8BC,QAA9B,EAAwChzB,SAAxC,EAAmDqsB,OAAnD,EAA2D;AAC1F,MAAI4G,QAAQ,GAAG,EAAf,CAD0F,CAE1F;;AACA,MAAG32B,MAAM,IAAIA,MAAM,CAACrS,MAAjB,IAA2B8oC,WAA9B,EAA2C;AACvC;AACAz2B,UAAM,CAACW,OAAP,CAAe,UAAS+G,KAAT,EAAe;AAC1B,UAAIjV,IAAI,GAAGiV,KAAK,CAACjV,IAAjB;;AACA,UAAGA,IAAH,EAAS;AACL,YAAGA,IAAI,KAAK,OAAZ,EAAqB;AACjB;;;;;;;AAOA,cAAImkC,WAAW,GAAGlvB,KAAK,CAACuN,OAAxB;AAAA,cACI4hB,WAAW,GAAGJ,WAAW,CAAC/uB,KAAK,CAACqD,IAAP,CAD7B;AAAA,cAEI+rB,kBAAkB,GAAG,EAFzB;AAAA,cAGIC,aAAa,GAAG,EAHpB,CARiB,CAYjB;;AACA,cAAGH,WAAW,IAAIA,WAAW,CAACjpC,MAA3B,IAAqCkpC,WAArC,IAAoDA,WAAW,YAAY52B,KAA9E,EAAqF;AACjF42B,uBAAW,CAACl2B,OAAZ,CAAoB,UAAS6U,UAAT,EAAoB;AACpCshB,gCAAkB,CAAC3gC,IAAnB,CAAwBigB,YAAY,CAACogB,mBAAb,CAAiCI,WAAjC,EAA8CphB,UAA9C,CAAxB;AACH,aAFD,EAEG,IAFH,EADiF,CAIjF;;AACAohB,uBAAW,CAACj2B,OAAZ,CAAoB,UAASq2B,UAAT,EAAoB;AACpCD,2BAAa,CAACC,UAAU,CAACjsB,IAAZ,CAAb,GAAiC+rB,kBAAkB,CAACrB,OAAnB,CAA2BuB,UAAU,CAACjsB,IAAtC,CAAjC;AACH,aAFD;AAGA4rB,oBAAQ,GAAGvgB,YAAY,CAACuf,KAAb,CAAmBgB,QAAnB,EAA6BI,aAA7B,CAAX;AACH;AACJ,SAvBD,MAuBO,IAAItkC,IAAI,IAAI,MAAZ,EAAmB;AACtBkkC,kBAAQ,CAACjvB,KAAK,CAACqD,IAAP,CAAR,GAAuBqL,YAAY,CAACyf,gBAAb,CAA8BtpB,eAAe,CAAC0qB,qBAAhB,CAAsClH,OAAtC,EAA+C0G,WAAW,CAAC/uB,KAAK,CAACqD,IAAP,CAA1D,CAA9B,CAAvB;AAEH,SAHM,MAGA,IAAItY,IAAI,IAAI,OAAZ,EAAoB;AACvBkkC,kBAAQ,CAACjvB,KAAK,CAACqD,IAAP,CAAR,GAAuBqL,YAAY,CAACkgB,eAAb,CAA6B/pB,eAAe,CAAC2qB,oBAAhB,CAAqCT,WAAW,CAAC/uB,KAAK,CAACqD,IAAP,CAAhD,CAA7B,CAAvB;AAEH,SAHM,MAGA,IAAItY,IAAI,IAAI,OAAZ,EAAoB;AACtCkkC,kBAAQ,CAACjvB,KAAK,CAACqD,IAAP,CAAR,GAAuB0rB,WAAW,CAAC/uB,KAAK,CAACqD,IAAP,CAAX,IAA2B,EAAlD;AAEA,SAHkB,MAGZ;AACS;AACA4rB,kBAAQ,CAACjvB,KAAK,CAACqD,IAAP,CAAR,GAAuB0rB,WAAW,CAAC/uB,KAAK,CAACqD,IAAP,CAAlC;AACH;AACJ;AACJ,KAxCD,EAwCG,IAxCH;AAyCH,GA9CyF,CA+C1F;;;AACA4rB,UAAQ,CAAC,UAAD,CAAR,GAAuBpqB,eAAe,CAAC4qB,oBAAhB,CAAqCpH,OAArC,EAA8C2G,QAA9C,CAAvB,CAhD0F,CAiD1F;;AACAC,UAAQ,CAAC,WAAD,CAAR,GAAwBpqB,eAAe,CAAC4qB,oBAAhB,CAAqCpH,OAArC,EAA8CrsB,SAA9C,CAAxB;AAEA,SAAOizB,QAAP;AACH,CArDD,C;;;;;;;;;;;;AC5GAz2B,OAAOk3B,OAAP,CAAe,YAAf,EAA6B,UAACrH,OAAD;AAC5BsH,QAAMtH,OAAN,EAAelhC,MAAf;;AAEA,OAAO,KAAKysB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACAC;;ADEF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACAC;;ADGF,SAAOh3B,GAAGi3B,UAAH,CAAchuB,IAAd,CAAmB;AAAEjG,WAAOysB;AAAT,GAAnB,EAAuC;AAAE/vB,YAAQ;AAAE9J,YAAM,CAAR;AAAWoN,aAAO,CAAlB;AAAqB0yB,eAAS,CAA9B;AAAiCwB,WAAK;AAAtC;AAAV,GAAvC,CAAP;AAVD,G;;;;;;;;;;;;AECAt3B,OAAOk3B,OAAP,CAAe,eAAf,EAAgC,UAACtT,WAAD;AAC/BuT,QAAMvT,WAAN,EAAmB7jB,KAAnB;;AAEA,OAAO,KAAKqb,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACDC;;ADGF,OAAOxT,WAAP;AACE,WAAO,KAAKwT,KAAL,EAAP;ACDA;;ADGF,SAAOrV,IAAIC,SAAJ,CAAc3Y,IAAd,CAAmB;AAAC,yBAAqB;AAAC8Z,WAAKS;AAAN,KAAtB;AAA2CO,SAAK,CAAC;AAAC,6BAAuB;AAACnB,aAAK;AAAN;AAAxB,KAAD,EAAsC;AAAC,6BAAuB,IAAxB;AAA8B,wBAAkB,KAAK5H;AAArD,KAAtC;AAAhD,GAAnB,CAAP;AATD,G;;;;;;;;;;;;AECApb,OAAOk3B,OAAP,CAAe,gBAAf,EAAiC,UAACrH,OAAD;AAEhC,OAAO,KAAKzU,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACFC;;ADIF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACFC;;ADIF,SAAOh3B,GAAGm3B,cAAH,CAAkBluB,IAAlB,CAAuB;AAACjG,WAAOysB;AAAR,GAAvB,EAAyC;AAAC/vB,YAAQ;AAAC03B,YAAK,CAAN;AAAS1N,aAAO,CAAhB;AAAmBuM,WAAK;AAAxB;AAAT,GAAzC,CAAP;AARD,G;;;;;;;;;;;;AEFAr2B,OAAOy3B,gBAAP,CAAwB,wBAAxB,EAAkD,UAACC,SAAD,EAAYrL,GAAZ,EAAiBvsB,MAAjB;AACjDq3B,QAAMO,SAAN,EAAiB/oC,MAAjB;AACAwoC,QAAM9K,GAAN,EAAWtsB,KAAX;AACAo3B,QAAMr3B,MAAN,EAAc63B,MAAMC,QAAN,CAAexpC,MAAf,CAAd;;AAEA,OAAO,KAAKgtB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACAC;;ADEF,OAAKS,OAAL;ACAC,SDED;AAAAxuB,UAAM;AACL,WAAKwuB,OAAL;ACAI,aDCJz3B,GAAGm3B,cAAH,CAAkBluB,IAAlB,CAAuB;AAAC9I,aAAK;AAAC4iB,eAAKkJ;AAAN;AAAN,OAAvB,EAA0C;AAAAvsB,gBAAQA;AAAR,OAA1C,CCDI;ADDL;AAIAg4B,cAAU,CACT;AACCzuB,YAAM,UAAC4sB,QAAD;AACL,aAAC4B,OAAD;ACMM,eDJNz3B,GAAG23B,UAAH,CAAc1uB,IAAd,CAAmB;AAAE9I,eAAK01B,SAASuB;AAAhB,SAAnB,EAA2C;AAAA13B,kBAAQ;AAAA9J,kBAAM;AAAN;AAAR,SAA3C,CCIM;ADRR;AAAA,KADS,EAOT;AACCqT,YAAM,UAAC4sB,QAAD;AACL,aAAC4B,OAAD;ACWM,eDTNz3B,GAAG2zB,aAAH,CAAiB1qB,IAAjB,CAAsB;AAAE9I,eAAK01B,SAASI;AAAhB,SAAtB,EAA6C;AAAAv2B,kBAAQ;AAAAiJ,sBAAU;AAAV;AAAR,SAA7C,CCSM;ADbR;AAAA,KAPS,EAaT;AACCM,YAAM,UAAC4sB,QAAD;AACL,aAAC4B,OAAD;ACgBM,eDdNz3B,GAAG4yB,WAAH,CAAe3pB,IAAf,CAAoB;AACnBjG,iBAAO6yB,SAAS7yB,KADG;AAEnB1B,gBAAM;AAAAyhB,iBAAK8S,SAASnM;AAAd;AAFa,SAApB,EAGG;AAAAhqB,kBACF;AAAAsD,mBAAO,CAAP;AACA1B,kBAAM,CADN;AAEA1L,kBAAM;AAFN;AADE,SAHH,CCcM;ADlBR;AAAA,KAbS;AAJV,GCFC;ADRF,G;;;;;;;;;;;;AEECgK,OAAOk3B,OAAP,CAAe,YAAf,EAA6B,UAACrH,OAAD;AAE5B,OAAO,KAAKzU,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACFA;;ADID,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACFA;;ADKD,SAAOh3B,GAAG23B,UAAH,CAAc1uB,IAAd,CAAmB;AAACjG,WAAOysB;AAAR,GAAnB,EAAqC;AAAC/vB,YAAQ;AAAC9J,YAAK;AAAN;AAAT,GAArC,CAAP;AATD,G;;;;;;;;;;;;AEFDgK,OAAOk3B,OAAP,CAAe,OAAf,EAAwB,UAACrH,OAAD;AACvB,OAAO,KAAKzU,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACCC;;ADCF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACCC;;ADEF,MAAGh3B,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAACjG,WAAOysB;AAAR,GAAd,EAAgC5N,KAAhC,OAA2C,CAA9C;AACC7hB,OAAG2yB,MAAH,CAAUiF,yBAAV,CAAoCnI,OAApC;ACEC;;ADAF,SAAOzvB,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAACjG,WAAOysB;AAAR,GAAd,EAAgC;AACtC/vB,YAAQ;AACP9J,YAAM,CADC;AAEP0J,YAAM,CAFC;AAGPgN,aAAO,CAHA;AAIPurB,aAAO,CAJA;AAKP70B,aAAO,CALA;AAMP80B,kBAAY,CANL;AAOPpC,eAAS,CAPF;AAQPqC,iCAA2B,CARpB;AASPC,0BAAoB,CATb;AAUPC,uBAAiB;AAVV;AAD8B,GAAhC,CAAP;AAXD;AA0BAr4B,OAAOk3B,OAAP,CAAe,eAAf,EAAgC,UAACrH,OAAD,EAAU2B,MAAV;AAC/B,OAAO,KAAKpW,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACKC;;ADHF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACKC;;ADHF,OAAO5F,MAAP;AACC,WAAO,KAAK4F,KAAL,EAAP;ACKC;;ADHF,SAAOh3B,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAC9I,SAAKixB,MAAN;AAAcpuB,WAAOysB;AAArB,GAAd,EAA6C;AACnD/vB,YAAQ;AACP9J,YAAM,CADC;AAEP0J,YAAM,CAFC;AAGPgN,aAAO,CAHA;AAIPurB,aAAO,CAJA;AAKP70B,aAAO,CALA;AAMP80B,kBAAY,CANL;AAOPpC,eAAS,CAPF;AAQPqC,iCAA2B,CARpB;AASPC,0BAAoB,CATb;AAUPC,uBAAiB;AAVV;AAD2C,GAA7C,CAAP;AAVD;AA0BAr4B,OAAOk3B,OAAP,CAAe,cAAf,EAA+B,UAACrH,OAAD,EAAU2B,MAAV,EAAkB8G,SAAlB;AAC9B,MAAAltB,cAAA,EAAAmtB,MAAA,EAAAC,IAAA;;AAAA,OAAO,KAAKpd,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACSC;;ADPF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACSC;;ADPF,OAAO5F,MAAP;AACC,WAAO,KAAK4F,KAAL,EAAP;ACSC;;ADPF,OAAOkB,SAAP;AACC,WAAO,KAAKlB,KAAL,EAAP;ACSC;;ADNFoB,SAAO,IAAP;;AAEAptB,mBAAiB,UAACgI,EAAD,EAAMklB,SAAN;AAChB,QAAA10B,IAAA,EAAAyH,YAAA;AAAAzH,WAAOxD,GAAGkL,KAAH,CAAShL,OAAT,CAAiB;AAACC,WAAM6S;AAAP,KAAjB,CAAP;;AACA,QAAGxP,IAAH;AACCyH,qBAAezH,KAAKqH,OAApB;AACAI,mBAAaotB,MAAb,GAAsB,IAAtB;;AAEA,UAAGptB,aAAa9K,GAAb,KAAoB+3B,SAAvB;AACCjtB,uBAAezH,KAAKuH,QAAL,CAAcL,gBAAd,CAA+B,KAA/B,EAAsCwtB,SAAtC,CAAf;AACAjtB,qBAAaotB,MAAb,GAAsB,KAAtB;ACSG;;ADPJ,aAAOptB,YAAP;ACSE;ADnBa,GAAjB;;AAWAktB,WAASn4B,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAC9I,SAAKixB;AAAN,GAAd,EAA6B;AAAC1xB,YAAQ;AAACS,WAAK,CAAN;AAAS,0BAAoB;AAA7B;AAAT,GAA7B,EAAwEm4B,cAAxE,CAAuF;AAC/FC,aAAS,UAACvlB,EAAD;ACkBL,aDjBHolB,KAAKG,OAAL,CAAa,eAAb,EAA8BL,SAA9B,EAAyCltB,eAAegI,EAAf,EAAmBklB,SAAnB,CAAzC,CCiBG;ADnB2F;AAAA,GAAvF,CAAT;AAMAE,OAAKI,KAAL,CAAW,eAAX,EAA4BN,SAA5B,EAAuCltB,eAAeomB,MAAf,EAAuB8G,SAAvB,CAAvC;AACAE,OAAKpB,KAAL;ACiBC,SDhBDoB,KAAKK,MAAL,CAAY;ACiBT,WDhBFN,OAAOO,IAAP,ECgBE;ADjBH,ICgBC;ADnDF;AAsCA94B,OAAOk3B,OAAP,CAAe,2BAAf,EAA4C,UAAC6B,QAAD;AAC3C,OAAO,KAAK3d,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACmBC;;ADjBF,OAAO2B,QAAP;AACC,WAAO,KAAK3B,KAAL,EAAP;ACmBC;;ADjBF,SAAOh3B,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAC9I,SAAK;AAAC4iB,WAAK4V;AAAN;AAAN,GAAd,EAAsC;AAC5Cj5B,YAAQ;AACP9J,YAAM,CADC;AAEP0J,YAAM,CAFC;AAGPgN,aAAO,CAHA;AAIPurB,aAAO,CAJA;AAKP70B,aAAO,CALA;AAMP+0B,iCAA2B,CANpB;AAOPC,0BAAoB,CAPb;AAQPY,mCAA6B,CARtB;AASPd,kBAAY,CATL;AAUPG,uBAAiB;AAVV;AADoC,GAAtC,CAAP;AAPD;AAsBAr4B,OAAOk3B,OAAP,CAAe,MAAf,EAAuB,UAACrH,OAAD,EAAU2B,MAAV;AACtB,OAAO,KAAKpW,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACwBC;;ADtBF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACwBC;;ADtBF,OAAO5F,MAAP;AACC,WAAO,KAAK4F,KAAL,EAAP;ACwBC;;ADrBF,SAAOh3B,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAC9I,SAAKixB,MAAN;AAAcpuB,WAAOysB;AAArB,GAAd,EAA6C;AACnD/vB,YAAQ;AACPuU,sBAAgB,CADT;AAEPC,yBAAmB,CAFZ;AAGP+F,cAAQ,CAHD;AAIP8d,iCAA2B,CAJpB;AAKPC,0BAAoB,CALb;AAMP5V,sCAAgC,CANzB;AAOPwW,mCAA6B,CAPtB;AAQPd,kBAAY,CARL;AASPe,yBAAmB,CATZ;AAUPZ,uBAAiB;AAVV;AAD2C,GAA7C,CAAP;AAXD;AAyBAr4B,OAAOk3B,OAAP,CAAe,YAAf,EAA6B,UAACrH,OAAD,EAAU2B,MAAV;AAC5B,OAAO,KAAKpW,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;AC4BC;;AD1BF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;AC4BC;;AD1BF,OAAO5F,MAAP;AACC,WAAO,KAAK4F,KAAL,EAAP;AC4BC;;AD1BF,SAAOrV,IAAIgC,KAAJ,CAAU1a,IAAV,CAAe;AAAE,sBAAkBwmB,OAApB;AAA6B,4BAAwB,OAArD;AAA8D,0BAAsB2B;AAApF,GAAf,CAAP;AAVD;AAYAxxB,OAAOy3B,gBAAP,CAAwB,eAAxB,EAAyC,UAACC,SAAD,EAAYrL,GAAZ,EAAiBvsB,MAAjB;AACxCq3B,QAAMO,SAAN,EAAiB/oC,MAAjB;AACAwoC,QAAM9K,GAAN,EAAWtsB,KAAX;AACAo3B,QAAMr3B,MAAN,EAAc63B,MAAMC,QAAN,CAAexpC,MAAf,CAAd;;AAEA,OAAO,KAAKgtB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACgCC;;AD9BF,OAAKS,OAAL;ACgCC,SD9BD;AAAAxuB,UAAM;AACL,WAAKwuB,OAAL;ACgCI,aD/BJz3B,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAC9I,aAAK;AAAC4iB,eAAKkJ;AAAN;AAAN,OAAd,EAAiC;AAAAvsB,gBAAQA;AAAR,OAAjC,CC+BI;ADjCL;AAIAg4B,cAAU,CACT;AACCzuB,YAAM,UAACzF,IAAD;AACL,aAACi0B,OAAD;ACsCM,eDpCNz3B,GAAG4yB,WAAH,CAAe3pB,IAAf,CAAoB;AACnBjG,iBAAOQ,KAAKR,KADO;AAEnB1B,gBAAMkC,KAAKqH,OAAL,CAAanI;AAFA,SAApB,EAGG;AAAAhD,kBACF;AAAAsD,mBAAO,CAAP;AACA1B,kBAAM,CADN;AAEA1L,kBAAM;AAFN;AADE,SAHH,CCoCM;ADxCR;AAAA,KADS,EAaT;AACCqT,YAAM,UAACzF,IAAD;AACL,aAACi0B,OAAD;ACwCM,eDtCNz3B,GAAGC,KAAH,CAASgJ,IAAT,CAAc;AACbjG,iBAAOQ,KAAKR,KADC;AAEb7C,eAAKqD,KAAKlE;AAFG,SAAd,EAGG;AAAAI,kBACF;AAAAsD,mBAAO,CAAP;AACA7C,iBAAK,CADL;AAEAvK,kBAAM,CAFN;AAGAsO,sBAAU;AAHV;AADE,SAHH,CCsCM;AD1CR;AAAA,KAbS,EA0BT;AACC+E,YAAM,UAACzF,IAAD;AACL,aAACi0B,OAAD;AC0CM,eDxCNz3B,GAAGi3B,UAAH,CAAchuB,IAAd,CAAmB;AAClBjG,iBAAOQ,KAAKR;AADM,SAAnB,EAEG;AAAAtD,kBACF;AAAAsD,mBAAO,CAAP;AACA7C,iBAAK,CADL;AAEAvK,kBAAM;AAFN;AADE,SAFH,CCwCM;AD5CR;AAAA,KA1BS;AAJV,GC8BC;ADxCF,G;;;;;;;;;;;;AErJAgK,OAAOk3B,OAAP,CAAe,OAAf,EAAwB,UAACrH,OAAD;AACvB,OAAO,KAAKzU,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACCC;;ADCF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACCC;;ADEF,SAAOh3B,GAAGC,KAAH,CAASgJ,IAAT,CAAc;AAACjG,WAAOysB;AAAR,GAAd,EAAgC;AAAC/vB,YAAQ;AAAC9J,YAAM,CAAP;AAAUsO,gBAAU,CAApB;AAAuBoI,aAAO,CAA9B;AAAiC9J,mBAAa,CAA9C;AAAiDwL,sBAAgB,CAAjE;AAAoE8qB,mBAAa;AAAjF;AAAT,GAAhC,CAAP;AARD;AAUAl5B,OAAOk3B,OAAP,CAAe,eAAf,EAAgC,UAACrH,OAAD,EAAUre,MAAV;AAC/B,OAAO,KAAK4J,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACYC;;ADVF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACYC;;ADTF,SAAOh3B,GAAGC,KAAH,CAASgJ,IAAT,CAAc;AAAC9I,SAAKiR,MAAN;AAAcpO,WAAOysB;AAArB,GAAd,EAA6C;AAAC/vB,YAAQ;AAAC9J,YAAM,CAAP;AAAUsO,gBAAU,CAApB;AAAuBoI,aAAO,CAA9B;AAAiC9J,mBAAa,CAA9C;AAAiDwL,sBAAgB,CAAjE;AAAoE8qB,mBAAa;AAAjF;AAAT,GAA7C,CAAP;AARD;AAWAl5B,OAAOk3B,OAAP,CAAe,cAAf,EAA+B,UAACrH,OAAD,EAAUre,MAAV,EAAkB8mB,SAAlB;AAC9B,MAAAn4B,cAAA,EAAAo4B,MAAA,EAAAC,IAAA;;AAAA,OAAO,KAAKpd,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACwBC;;ADtBF,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACwBC;;ADtBF,OAAO5lB,MAAP;AACC,WAAO,KAAK4lB,KAAL,EAAP;ACwBC;;ADtBF,OAAOkB,SAAP;AACC,WAAO,KAAKlB,KAAL,EAAP;ACwBC;;ADrBFoB,SAAO,IAAP;;AAEAr4B,mBAAiB,UAACiT,EAAD,EAAMklB,SAAN;AAChB,QAAA54B,IAAA,EAAAC,YAAA;AAAAD,WAAOU,GAAGC,KAAH,CAASC,OAAT,CAAiB;AAACC,WAAM6S;AAAP,KAAjB,CAAP;;AACA,QAAG,CAAC1T,IAAJ;AACC,aAAO,EAAP;ACyBE;;ADxBHC,mBAAeD,KAAKuL,OAApB;AACAtL,iBAAa84B,MAAb,GAAsB,IAAtB;;AACA,QAAG94B,aAAaY,GAAb,KAAoB+3B,SAAvB;AACC34B,qBAAeD,KAAKyL,QAAL,CAAcL,gBAAd,CAA+B,KAA/B,EAAsCwtB,SAAtC,CAAf;AACA34B,mBAAa84B,MAAb,GAAsB,KAAtB;AC0BE;;ADzBH,WAAO94B,YAAP;AATgB,GAAjB;;AAWA44B,WAASn4B,GAAGC,KAAH,CAASgJ,IAAT,CAAc;AAAC9I,SAAKiR;AAAN,GAAd,EAA6B;AAAC1R,YAAQ;AAACS,WAAK,CAAN;AAAS,0BAAoB;AAA7B;AAAT,GAA7B,EAAwEm4B,cAAxE,CAAuF;AAC/FC,aAAS,UAACvlB,EAAD;ACkCL,aDjCHolB,KAAKG,OAAL,CAAa,eAAb,EAA8BL,SAA9B,EAAyCn4B,eAAeiT,EAAf,EAAmBklB,SAAnB,CAAzC,CCiCG;ADnC2F;AAAA,GAAvF,CAAT;AAKAE,OAAKI,KAAL,CAAW,eAAX,EAA4BN,SAA5B,EAAuCn4B,eAAeqR,MAAf,EAAuB8mB,SAAvB,CAAvC;AACAE,OAAKpB,KAAL;ACkCC,SDjCDoB,KAAKK,MAAL,CAAY;ACkCT,WDjCFN,OAAOO,IAAP,ECiCE;ADlCH,ICiCC;ADnEF,G;;;;;;;;;;;;AErBA94B,OAAOk3B,OAAP,CAAe,eAAf,EAAgC,UAAC3jB,UAAD,EAAaY,GAAb;AAC/B,MAAAglB,eAAA,EAAAC,oBAAA,EAAAb,MAAA,EAAAh3B,QAAA,EAAA83B,iBAAA,EAAAC,iBAAA,EAAAC,UAAA,EAAAf,IAAA,EAAAgB,mBAAA,EAAAC,yBAAA;;AAAA,OAAO,KAAKre,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACEC;;ADAF,QAAQ7jB,cAAcnT,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAAC9I,SAAKgT;AAAN,GAAlB,EAAqC0O,KAArC,EAAtB;AACC,WAAO,KAAKmV,KAAL,EAAP;ACIC;;ADFFoB,SAAO,IAAP;AAEAc,sBAAoB,CAAC,KAAD,EAAQ,aAAR,EAAuB,MAAvB,EAA+B,SAA/B,EAA0C,cAA1C,EAA0D,MAA1D,EAAkE,YAAlE,EAAgF,aAAhF,EACnB,SADmB,EACR,OADQ,EACC,aADD,EACgB,gBADhB,EACkC,WADlC,EAC+C,gBAD/C,EACiE,gBADjE,CAApB;AAGAE,wBAAsB,CAAC,cAAD,EAAiB,cAAjB,EAAiC,mBAAjC,EAAsD,wBAAtD,EAAgF,QAAhF,EAA0F,aAA1F,CAAtB;AAEAC,8BAA4B,EAA5B;AAEAJ,sBAAoB;AACnB,qBAAiB,CADE;AAInB,iDAA6C,CAJ1B;AAKnB,4CAAwC,CALrB;AAMnB,iCAA6B,CANV;AAQnB,gCAA4B,CART;AAUnB,gCAA4B,CAVT;AAWnB,mCAA+B,CAXZ;AAYnB,sCAAkC,CAZf;AAanB,mCAA+B,CAbZ;AAcnB,gCAA4B,CAdT;AAenB,mCAA+B,CAfZ;AAgBnB,gCAA4B,CAhBT;AAiBnB,uCAAmC,CAjBhB;AAkBnB,sCAAkC;AAlBf,GAApB;;AAqBAD,yBAAuB,UAAC9qB,MAAD;AACtB,QAAAorB,kBAAA;AAAAA,yBAAqB,IAAI35B,KAAJ,EAArB;;ACLE,QAAIuO,UAAU,IAAd,EAAoB;ADOtBA,aAAQ7N,OAAR,CAAgB,UAACe,KAAD;AACf,YAAAb,GAAA;ACLK,eAAOa,SAAS,IAAT,GAAgB,CAACb,MAAMa,MAAM6a,QAAb,KAA0B,IAA1B,GAAiC1b,IDK5CF,OCL4C,CDKpC,UAAC8b,OAAD;AACxB,cAAIA,QAAQ7a,IAAR,KAAgB82B,KAAKpd,MAArB,IAA+BmB,QAAQ3a,OAAR,KAAmB42B,KAAKpd,MAA3D;ACJQ,mBDQPse,mBAAmBzjC,IAAnB,CAAwBsmB,QAAQ5Z,SAAhC,CCRO;AACD;ADER,SCL6D,CAAjC,GDK5B,MCLY,GDKZ,MCLK;ADIN;ACEG;;ADMH,WAAO+2B,kBAAP;AAXsB,GAAvB;;AAcAP,oBAAkB,UAACQ,WAAD;AACjB,QAAAp4B,QAAA,EAAAZ,GAAA,EAAA+K,IAAA,EAAAsd,sBAAA,EAAA1a,MAAA;AAAA/M,eAAWnB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,WAAKo5B;AAAN,KAArB,EAAyC;AAAC75B,cAAQu5B;AAAT,KAAzC,CAAX;;AAEA,QAAG93B,QAAH;AAECi4B,0BAAoB/4B,OAApB,CAA4B,UAACjK,GAAD;AAC3B,YAAGA,QAAO,wBAAV;ACFM,iBDGLijC,0BAA0BjjC,GAA1B,IAAiC4iC,qBAAqB73B,SAAS+M,MAA9B,CCH5B;ADEN;ACAM,iBDGLmrB,0BAA0BjjC,GAA1B,IAAiC+K,SAAS/K,GAAT,CCH5B;AACD;ADFN;AAQAwyB,+BAAA,EAAAroB,MAAAP,GAAA6oB,cAAA,CAAA3oB,OAAA;ACHK8C,eAAO7B,SAAS6B,KDGrB;ACFK5M,aAAK;ADEV,SCDM;AACDsJ,gBAAQ;AACNwC,kBAAQ;AADF;AADP,ODCN,MCGU,IDHV,GCGiB3B,IDHwH2B,MAAzI,GAAyI,MAAzI,KAAmJ,KAAnJ;;AAEA,UAAG0mB,sBAAH;AAEC1a,iBAAS,IAAIvO,KAAJ,EAAT;;ACEI,YAAIwB,YAAY,IAAhB,EAAsB;AACpB,cAAI,CAACmK,OAAOnK,SAAS+M,MAAjB,KAA4B,IAAhC,EAAsC;AACpC5C,iBDFUjL,OCEV,CDFkB,UAACe,KAAD;AACzB,kBAAAo4B,MAAA,EAAAvd,QAAA,EAAAH,IAAA;;AAAA0d,uBAAS54B,EAAElI,KAAF,CAAQ0I,KAAR,CAAT;AAEA6a,yBAAW,IAAItc,KAAJ,EAAX;;ACGS,kBAAIyB,SAAS,IAAb,EAAmB;AACjB,oBAAI,CAAC0a,OAAO1a,MAAM6a,QAAd,KAA2B,IAA/B,EAAqC;AACnCH,uBDHIzb,OCGJ,CDHY,UAAC8b,OAAD;AACxB,wBAAGA,QAAQhqB,IAAR,KAAgB,IAAhB,IAAwBgqB,QAAQ7a,IAAR,KAAgB82B,KAAKpd,MAA7C,IAAuDmB,QAAQ3a,OAAR,KAAmB42B,KAAKpd,MAA/E,IAA0F,CAACpa,EAAEmQ,OAAF,CAAUoL,QAAQG,eAAlB,CAA9F;ACIgB,6BDHfL,SAASpmB,IAAT,CAAcsmB,OAAd,CCGe;AACD;ADNhB,mBCGa;AAKD;AACF;;ADLVqd,qBAAOvd,QAAP,GAAkBA,QAAlB;ACOS,qBDLT/N,OAAOrY,IAAP,CAAY2jC,MAAZ,CCKS;ADhBV,aCEQ;AAgBD;AACF;;ADNLr4B,iBAAS+M,MAAT,GAAkBA,MAAlB;AA7BF;ACsCG;;ADPH,WAAO/M,QAAP;AAlCiB,GAAlB;;AAqCAg4B,eAAa,UAACM,YAAD;AACZ,QAAAC,OAAA,EAAAC,IAAA;;AAAA,QAAGF,YAAH;AAECC,gBAAU,KAAV;AAEAC,aAAO/4B,EAAEqI,IAAF,CAAOmwB,mBAAP,EAA4B,UAAChjC,GAAD;AAClC,YAAA0C,IAAA,EAAA8gC,qBAAA;;AAAA9gC,eAAO1C,GAAP;;AAEA,YAAGA,QAAO,wBAAV;AACC0C,iBAAO,QAAP;ACOI;;ADLL,YAAG8H,EAAEhH,GAAF,CAAM6/B,YAAN,EAAoB3gC,IAApB,CAAH;AAEC,cAAG1C,QAAO,wBAAV;AAECwjC,oCAAwBZ,qBAAqBS,aAAavrB,MAAlC,CAAxB;AAIA,mBAAO,CAACtN,EAAEi5B,OAAF,CAAUR,0BAA0BjjC,GAA1B,CAAV,EAA0CwjC,qBAA1C,CAAR;AAND;AAQC,mBAAO,CAACh5B,EAAEi5B,OAAF,CAAUR,0BAA0BjjC,GAA1B,CAAV,EAA0CqjC,aAAarjC,GAAb,CAA1C,CAAR;AAVF;ACaK;ADnBC,QAAP;;AAkBA,UAAGujC,IAAH;AACCD,kBAAU,IAAV;ACIG;;ADAJ,aAAOA,OAAP;ACEE;;ADAH,WAAO,IAAP;AA9BY,GAAb;;AAgCAvB,WAASn4B,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAAC9I,SAAKgT;AAAN,GAAlB,EAAqCmlB,cAArC,CAAoD;AAC5DC,aAAS,UAACvlB,EAAD,EAAKtT,MAAL;AACR,UAAGqU,QAAO,OAAP,IAAkBolB,WAAWz5B,MAAX,CAArB;ACIK,eDHJ04B,KAAKG,OAAL,CAAa,WAAb,EAA0BvlB,EAA1B,EAA8B+lB,gBAAgB/lB,EAAhB,CAA9B,CCGI;AACD;ADPuD;AAI5DsC,aAAS,UAACtC,EAAD;ACML,aDLHolB,KAAK9iB,OAAL,CAAa,WAAb,EAA0BtC,EAA1B,CCKG;ADVwD;AAAA,GAApD,CAAT;AAQA7R,aAAW43B,gBAAgB5lB,UAAhB,CAAX;AAEAilB,OAAKI,KAAL,CAAW,WAAX,EAAAr3B,YAAA,OAAwBA,SAAUhB,GAAlC,GAAkC,MAAlC,EAAuCgB,QAAvC;AAEAi3B,OAAKpB,KAAL;ACIC,SDFDoB,KAAKK,MAAL,CAAY;ACGT,WDFFN,OAAOO,IAAP,ECEE;ADHH,ICEC;ADxIF;AA0IA94B,OAAOk3B,OAAP,CAAe,iBAAf,EAAkC,UAAC3jB,UAAD;AACjC,MAAA2mB,iBAAA,EAAA3B,MAAA,EAAAC,IAAA;;AAAA,OAAO,KAAKpd,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACKC;;ADHF,OAAO7jB,UAAP;AACC,WAAO,KAAK6jB,KAAL,EAAP;ACKC;;ADHFoB,SAAO,IAAP;;AAEA0B,sBAAoB,UAACC,MAAD;AACnB,WAAO/5B,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,WAAK45B;AAAN,KAArB,EAAoC;AAACr6B,cAAQ;AAACS,aAAK,CAAN;AAAS+N,gBAAQ;AAAjB;AAAT,KAApC,CAAP;AADmB,GAApB;;AAIAiqB,WAAUn4B,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAAC9I,SAAKgT;AAAN,GAAlB,EAAqCmlB,cAArC,CAAoD;AAC7DC,aAAS,UAACvlB,EAAD;ACYL,aDXHolB,KAAKG,OAAL,CAAa,iBAAb,EAAgCplB,UAAhC,EAA4C2mB,kBAAkB3mB,UAAlB,CAA5C,CCWG;ADbyD;AAAA,GAApD,CAAV;AAKAilB,OAAKI,KAAL,CAAW,iBAAX,EAA8BrlB,UAA9B,EAA0C2mB,kBAAkB3mB,UAAlB,CAA1C;AAEAilB,OAAKpB,KAAL;ACWC,SDVDoB,KAAKK,MAAL,CAAY;ACWT,WDVFN,OAAOO,IAAP,ECUE;ADXH,ICUC;AD/BF,G;;;;;;;;;;;;AEzIC94B,OAAOk3B,OAAP,CAAe,gBAAf,EAAiC,UAACrH,OAAD,EAAU1b,GAAV,EAAeqd,MAAf;AAEhC,MAAA5gC,KAAA;;AAAA,OAAO,KAAKwqB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACAA;;ADED,OAAOvH,OAAP;AACC,WAAO,KAAKuH,KAAL,EAAP;ACAA;;ADEDxmC,UAAQ;AAACwS,WAAOysB;AAAR,GAAR;;AACA,MAAG1b,QAAO,OAAV;AACCvjB,UAAMwpC,WAAN,GAAoB,KAAKhf,MAAzB;AADD,SAEK,IAAGjH,QAAO,QAAV;AACJvjB,UAAM0jC,YAAN,GAAqB,KAAKlZ,MAA1B;AADI,SAEA,IAAGjH,QAAO,OAAV;AACJvjB,UAAM0S,SAAN,GAAkB,KAAK8X,MAAvB;AACAxqB,UAAM8b,KAAN,GAAc,OAAd;AAFI,SAGA,IAAGyH,QAAO,SAAV;AACJvjB,UAAM0S,SAAN,GAAkB,KAAK8X,MAAvB;AACAxqB,UAAM8b,KAAN,GAAc,SAAd;AAFI,SAGA,IAAGyH,QAAO,WAAV;AACJvjB,UAAM0S,SAAN,GAAkB,KAAK8X,MAAvB;AACAxqB,UAAM8b,KAAN,GAAc,WAAd;AAFI,SAGA,IAAGyH,QAAO,SAAV;AACJvjB,UAAMgT,IAAN,GAAa4tB,MAAb;AACA5gC,UAAM8b,KAAN,GAAc;AAACyW,WAAK,CAAC,SAAD,EAAW,WAAX;AAAN,KAAd;AAFI;AAIJvyB,UAAM8b,KAAN,GAAc,MAAd;ACIA;;ADFD,SAAOtM,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkBzY,KAAlB,EAAyB;AAACkP,YAAQ;AAAC9J,YAAK,CAAN;AAAS0zB,eAAQ,CAAjB;AAAoBhqB,YAAK,CAAzB;AAA4BkE,YAAM,CAAlC;AAAqCR,aAAM,CAA3C;AAA8CP,gBAAS,CAAvD;AAA0DW,iBAAW,CAArE;AAAwEa,mBAAY,CAApF;AAAuF1E,oBAAc,CAArG;AAAwG0L,oBAAc;AAAtH;AAAT,GAAzB,CAAP;AA5BD,G;;;;;;;;;;;;AEDD,IAAAgvB,wBAAA,EAAAC,4BAAA;;AAAAA,+BAA+B,UAACC,UAAD,EAAanf,MAAb,EAAqBof,OAArB,EAA8BljC,QAA9B;AAC9B,MAAAmjC,SAAA;AAAAA,cAAY,CAAC;AACZ,cAAU;AACT,aAAOF;AADE;AADE,GAAD,EAIT;AAAC,gBAAY;AAAC,cAAQ,CAAT;AAAY,kBAAY;AAAxB;AAAb,GAJS,EAIkD;AAAC,eAAW;AAAZ,GAJlD,EAI4E;AAAC,eAAW;AAAZ,GAJ5E,EAKX;AAAC,cAAU;AAAC,8BAAwB,IAAzB;AAA+BpW,WAAI,CAAC;AAAC,4BAAoB/I;AAArB,OAAD,EAA8B;AAAC,yBAAiBA;AAAlB,OAA9B;AAAnC;AAAX,GALW,EAMX;AAAC,cAAU;AAAC,aAAO,MAAR;AAAgB,qBAAe;AAAC,iBAAS;AAAV;AAA/B;AAAX,GANW,CAAZ;ACqCC,SD5BDhb,GAAG4hB,SAAH,CAAa0Y,aAAb,GAA6BC,SAA7B,CAAuCF,SAAvC,EAAkDG,OAAlD,CAA0D,UAAC/P,GAAD,EAAM37B,IAAN;AACzD,QAAG27B,GAAH;AACC,YAAM,IAAIjvB,KAAJ,CAAUivB,GAAV,CAAN;AC6BE;;AD3BH37B,SAAKuR,OAAL,CAAa,UAACo6B,GAAD;AC6BT,aD5BHL,QAAQvkC,IAAR,CAAa4kC,GAAb,CC4BG;AD7BJ;;AAGA,QAAGvjC,YAAY0J,EAAE85B,UAAF,CAAaxjC,QAAb,CAAf;AACCA;AC6BE;ADrCJ,IC4BC;ADtC6B,CAA/B;;AAqBA+iC,2BAA2Br6B,OAAO+6B,SAAP,CAAiBT,4BAAjB,CAA3B;AAEAt6B,OAAOk3B,OAAP,CAAe,kBAAf,EAAmC,UAACQ,SAAD,EAAYrL,GAAZ,EAAiBvsB,MAAjB;AAClC,MAAAk7B,YAAA,EAAAC,wBAAA,EAAAC,kBAAA,EAAA3C,MAAA,EAAAC,IAAA;;AAAA,OAAO,KAAKpd,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACgCC;;AD9BFD,QAAMO,SAAN,EAAiB/oC,MAAjB;AAEAwoC,QAAM9K,GAAN,EAAWtsB,KAAX;AAEAo3B,QAAMr3B,MAAN,EAAc63B,MAAMC,QAAN,CAAexpC,MAAf,CAAd;AAEA0R,SAAOu0B,QAAP,GAAkB,CAAlB;AAEAmE,SAAO,IAAP;;AAEAyC,6BAA2B,UAAC7f,MAAD,EAAS7H,UAAT;AAC1B,QAAArkB,IAAA;AAAAA,WAAO,EAAP;AACAmrC,6BAAyB9mB,UAAzB,EAAqC6H,MAArC,EAA6ClsB,IAA7C;;AACA,QAAGA,KAAKzB,MAAL,GAAc,CAAjB;AACC,aAAOyB,KAAK,CAAL,CAAP;AC4BE;ADhCuB,GAA3B;;AAOA8rC,iBAAe,UAAC5f,MAAD,EAAS7H,UAAT;AACd,QAAAgJ,OAAA,EAAAF,QAAA,EAAA9a,QAAA,EAAAa,OAAA,EAAAiiB,SAAA,EAAA8W,iBAAA;AAAA55B,eAAWnB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,WAAKgT;AAAN,KAArB,EAAwC;AAACzT,cAAQ;AAACwO,gBAAQ;AAAT;AAAT,KAAxC,CAAX;AACA+V,gBAAY,IAAZ;;AAEA,QAAG,CAAC9iB,QAAJ;AACC;ACkCE;;ADhCH,QAAG,CAACA,SAAS+M,MAAV,IAAoB/M,SAAS+M,MAAT,CAAgB7gB,MAAhB,GAAyB,CAAhD;AACC;ACkCE;;ADhCH0tC,wBAAoB55B,SAAS+M,MAAT,CAAgBiK,cAAhB,CAA+B,aAA/B,EAA8C,KAA9C,CAApB;;AAEA,QAAG4iB,kBAAkB1tC,MAAlB,GAA2B,CAA9B;AACC4uB,iBAAW8e,kBAAkB,CAAlB,EAAqB9e,QAArB,CAA8B9D,cAA9B,CAA6C,aAA7C,EAA4D,KAA5D,EAAmEA,cAAnE,CAAkF,SAAlF,EAA6F6C,MAA7F,CAAX;;AAEA,UAAGiB,SAAS5uB,MAAT,GAAkB,CAArB;AACC8uB,kBAAUF,SAAS,CAAT,CAAV;AACAgI,oBAAY;AACXjR,cAAImJ,QAAQhc,GADD;AAEXgB,oBAAUgb,QAAQhb,QAFP;AAGXC,iBAAO+a,QAAQ/a,KAHJ;AAIXY,mBAASma,QAAQna,OAJN;AAKXH,sBAAYsa,QAAQta,UALT;AAMXm5B,iBAAO7e,QAAQ6e,KANJ;AAOXz5B,qBAAW4a,QAAQ5a;AAPR,SAAZ;AALF;AC8CG;;AD/BH,QAAG,CAAC0iB,SAAJ;AACCjiB,gBAAU,KAAV;AACAb,eAAS+M,MAAT,CAAgB7N,OAAhB,CAAwB,UAACe,KAAD;AACvB,YAAAb,GAAA;ACiCI,eAAOa,SAAS,IAAT,GAAgB,CAACb,MAAMa,MAAM6a,QAAb,KAA0B,IAA1B,GAAiC1b,IDjC3CF,OCiC2C,CDjCnC,UAAC8b,OAAD;AACxB,cAAGA,QAAQhqB,IAAR,KAAgB,IAAhB,IAAyBgqB,QAAQ7a,IAAR,KAAgB0Z,MAAzC,IAAoDmB,QAAQ9a,WAAR,KAAuB,KAA9E;AACC,gBAAG8a,QAAQna,OAAX;AACCA,wBAAU,IAAV;ACkCM;;AACD,mBDlCNiiB,YAAY;AAACjR,kBAAImJ,QAAQhc,GAAb;AAAkB6B,uBAASA,OAA3B;AAAoCH,0BAAYsa,QAAQta,UAAxD;AAAoEm5B,qBAAO7e,QAAQ6e,KAAnF;AAA0Fz5B,yBAAW4a,QAAQ5a;AAA7G,aCkCN;AAOD;AD7CP,SCiC4D,CAAjC,GDjC3B,MCiCW,GDjCX,MCiCI;ADlCL;ACiDE;;AD1CH,WAAO0iB,SAAP;AApCc,GAAf;;AAsCA6W,uBAAqB,UAAC3nB,UAAD;AACpB,QAAAhS,QAAA,EAAAZ,GAAA,EAAA+K,IAAA,EAAA2vB,eAAA;AAAA95B,eAAWnB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,WAAKgT;AAAN,KAArB,EAAwC;AAACzT,cAAQ;AAAC,uBAAe,CAAhB;AAAmB,kBAAU;AAACw7B,kBAAQ,CAAC;AAAV;AAA7B;AAAT,KAAxC,CAAX;;AACA,QAAG/5B,QAAH;AACC85B,wBAAA,CAAA16B,MAAAY,SAAA+M,MAAA,aAAA5C,OAAA/K,IAAA,cAAA+K,KAAuC1V,IAAvC,GAAuC,MAAvC,GAAuC,MAAvC;ACsDE;;ADpDH,WAAOqlC,eAAP;AALoB,GAArB;;AAOA9C,WAASn4B,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAAC9I,SAAK;AAAC4iB,WAAKkJ;AAAN;AAAN,GAAlB,EAAqC;AAACvsB,YAAQ;AAACwO,cAAQ;AAAT;AAAT,GAArC,EAA4DoqB,cAA5D,CAA2E;AACnFC,aAAS,UAACvlB,EAAD;AACR,UAAAxK,KAAA,EAAArH,QAAA,EAAA8iB,SAAA,EAAAkX,qBAAA,EAAA56B,GAAA,EAAA+K,IAAA;AAAAnK,iBAAWnB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,aAAK6S;AAAN,OAArB,EAAgC;AAACtT,gBAAQA;AAAT,OAAhC,CAAX;;AACA,UAAU,CAAIyB,QAAd;AAAA;ACoEI;;ADnEJ8iB,kBAAY2W,aAAaxC,KAAKpd,MAAlB,EAA0BhI,EAA1B,CAAZ;AACAmoB,8BAAwBN,yBAAyBzC,KAAKpd,MAA9B,EAAsChI,EAAtC,CAAxB;;AACA,UAAGiR,SAAH;AACC9iB,iBAASa,OAAT,GAAmBiiB,UAAUjiB,OAA7B;AACAb,iBAASU,UAAT,GAAsBoiB,UAAUpiB,UAAhC;;AACA,YAAGoiB,UAAU+W,KAAb;AACC75B,mBAASi6B,eAAT,GAA2BnX,UAAU1iB,SAArC;AAJF;AAAA;AAMCJ,iBAASa,OAAT,GAAmB,IAAnB;ACsEG;;ADpEJ,UAAGm5B,qBAAH;AACCh6B,iBAASk6B,cAAT,GAA0BF,sBAAsBr4B,WAAhD;ACsEG;;ADpEJ3B,eAASm6B,KAAT,KAAA/6B,MAAAY,SAAA8yB,QAAA,YAAA1zB,IAAoCiS,QAApC,CAA6C4lB,KAAKpd,MAAlD,IAAiB,MAAjB,KAA6D,KAA7D;AACA7Z,eAASo6B,QAAT,KAAAjwB,OAAAnK,SAAA8yB,QAAA,YAAA3oB,KAAuCje,MAAvC,GAAuC,MAAvC,KAAiD,CAAjD;AACA,aAAO8T,SAAS8yB,QAAhB;;AACA;ACsEK,eDrEJmE,KAAKG,OAAL,CAAa,WAAb,EAA0BvlB,EAA1B,EAA8B7R,QAA9B,CCqEI;ADtEL,eAAA6c,MAAA;AAEMxV,gBAAAwV,MAAA;AACLxd,gBAAQC,GAAR,CAAY,iCAAZ,EAA+C+H,MAAMwkB,OAArD;AACAxsB,gBAAQC,GAAR,CAAY,eAAZ,EAA6B23B,KAAKpd,MAAlC;AACAxa,gBAAQC,GAAR,CAAY,aAAZ,EAA2B62B,SAA3B;AACA92B,gBAAQC,GAAR,CAAY,OAAZ,EAAqBgJ,KAAKC,SAAL,CAAeuiB,GAAf,CAArB;ACuEI,eDtEJzrB,QAAQC,GAAR,CAAY,aAAZ,EAA2BgJ,KAAKC,SAAL,CAAeua,SAAf,CAA3B,CCsEI;AACD;ADlG8E;AA4BnF3O,aAAS,UAACtC,EAAD;ACyEL,aDxEHolB,KAAK9iB,OAAL,CAAa,WAAb,EAA0BtC,EAA1B,CCwEG;ADrG+E;AAAA,GAA3E,CAAT;AAgCAiZ,MAAI5rB,OAAJ,CAAY,UAAC2S,EAAD;AACX,QAAA7R,QAAA,EAAA8iB,SAAA,EAAAkX,qBAAA,EAAA56B,GAAA,EAAA+K,IAAA;AAAAnK,eAAWnB,GAAG4hB,SAAH,CAAa1hB,OAAb,CAAqB;AAACC,WAAK6S;AAAN,KAArB,EAAgC;AAACtT,cAAQA;AAAT,KAAhC,CAAX;;AACA,QAAU,CAAIyB,QAAd;AAAA;AC+EG;;AD9EH8iB,gBAAY2W,aAAaxC,KAAKpd,MAAlB,EAA0BhI,EAA1B,CAAZ;AACAmoB,4BAAwBN,yBAAyBzC,KAAKpd,MAA9B,EAAsChI,EAAtC,CAAxB;;AACA,QAAGiR,SAAH;AACC9iB,eAASa,OAAT,GAAmBiiB,UAAUjiB,OAA7B;AACAb,eAASU,UAAT,GAAsBoiB,UAAUpiB,UAAhC;;AACA,UAAGoiB,UAAU+W,KAAb;AACE75B,iBAASi6B,eAAT,GAA2BnX,UAAU1iB,SAArC;AAJH;AAAA;AAMCJ,eAASa,OAAT,GAAmB,IAAnB;ACiFE;;AD/EH,QAAGm5B,qBAAH;AACCh6B,eAASk6B,cAAT,GAA0BF,sBAAsBr4B,WAAhD;ACiFE;;AD/EH3B,aAASm6B,KAAT,KAAA/6B,MAAAY,SAAA8yB,QAAA,YAAA1zB,IAAoCiS,QAApC,CAA6C4lB,KAAKpd,MAAlD,IAAiB,MAAjB,KAA6D,KAA7D;AACA7Z,aAASo6B,QAAT,KAAAjwB,OAAAnK,SAAA8yB,QAAA,YAAA3oB,KAAuCje,MAAvC,GAAuC,MAAvC,KAAiD,CAAjD;AACA,WAAO8T,SAAS8yB,QAAhB;ACiFE,WDhFFmE,KAAKI,KAAL,CAAW,WAAX,EAAwBxlB,EAAxB,EAA4B7R,QAA5B,CCgFE;ADnGH;AAqBAi3B,OAAKpB,KAAL;ACiFC,SDhFDoB,KAAKK,MAAL,CAAY;ACiFT,WDhFFN,OAAOO,IAAP,ECgFE;ADjFH,ICgFC;ADxMF;AA2HA94B,OAAOk3B,OAAP,CAAe,wBAAf,EAAyC,UAAC0E,WAAD,EAAcvP,GAAd,EAAmBvsB,MAAnB;AACxC,OAAO,KAAKsb,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACmFC;;ADjFFD,QAAMyE,WAAN,EAAmBjtC,MAAnB;AAEAwoC,QAAM9K,GAAN,EAAWtsB,KAAX;AAEAo3B,QAAMr3B,MAAN,EAAc63B,MAAMC,QAAN,CAAexpC,MAAf,CAAd;ACiFC,SD3EDgS,GAAGe,cAAH,CAAkBkI,IAAlB,CAAuB;AACtB9I,SAAK;AACJ4iB,WAAKkJ;AADD;AADiB,GAAvB,EAIG;AACFvsB,YAAQA;AADN,GAJH,CC2EC;ADzFF;AAsBAE,OAAOk3B,OAAP,CAAe,mBAAf,EAAoC,UAAC0E,WAAD,EAAcvP,GAAd,EAAmBvsB,MAAnB;AACnC,OAAO,KAAKsb,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;AC6EC;;AD3EFD,QAAMyE,WAAN,EAAmBjtC,MAAnB;AAEAwoC,QAAM9K,GAAN,EAAWtsB,KAAX;AAEAo3B,QAAMr3B,MAAN,EAAc63B,MAAMC,QAAN,CAAexpC,MAAf,CAAd;AC2EC,SDrEDgS,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AACjB9I,SAAK;AACJ4iB,WAAKkJ;AADD;AADY,GAAlB,EAIG;AACFvsB,YAAQA;AADN,GAJH,CCqEC;ADnFF,G;;;;;;;;;;;;AExKAE,OAAOk3B,OAAP,CAAe,iBAAf,EAAkC,UAACrH,OAAD;AACjC,MAAAzU,MAAA;AAAA+b,QAAMtH,OAAN,EAAelhC,MAAf;;AAEA,OAAO,KAAKysB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACCC;;ADCFhc,WAAS,KAAKA,MAAd;AACA,SAAOhb,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAACqD,WAAM,OAAP;AAAetJ,WAAMysB,OAArB;AAA6BvsB,eAAU8X,MAAvC;AAA8C+I,SAAI,CAAC;AAACiW,mBAAa;AAAC3Q,iBAAQ;AAAT;AAAd,KAAD,EAAiC;AAAC2Q,mBAAa;AAAd,KAAjC;AAAlD,GAAlB,EAA0H;AAACt6B,YAAQ;AAACS,WAAK,CAAN;AAASmM,aAAO,CAAhB;AAAmBtJ,aAAO,CAA1B;AAA6BE,iBAAW,CAAxC;AAA2C82B,mBAAa,CAAxD;AAA2Dv3B,gBAAU,CAArE;AAAwE7M,YAAM;AAA9E,KAAT;AAA2FjG,UAAK;AAAC8S,gBAAU,CAAC;AAAZ;AAAhG,GAA1H,CAAP;AAPD,G;;;;;;;;;;;;AEAA7C,OAAOk3B,OAAP,CAAe,oCAAf,EAAqD,UAAC2E,YAAD;AACpD,MAAAtD,MAAA,EAAAC,IAAA;AAAArB,QAAM0E,YAAN,EAAoB97B,KAApB;;AAEA,OAAO,KAAKqb,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACCC;;ADCF,OAAOyE,YAAP;AACC,WAAO,KAAKzE,KAAL,EAAP;ACCC;;ADCF,MAAGp2B,EAAEmQ,OAAF,CAAU0qB,YAAV,CAAH;AACC,WAAO,KAAKzE,KAAL,EAAP;ACCC;;ADCFoB,SAAO,IAAP;AAEAD,WAASn4B,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAAC9I,SAAK;AAAC4iB,WAAK0Y;AAAN;AAAN,GAAlB,EAA8C;AAAC/7B,YAAQ;AAAC4M,aAAO,CAAR;AAAW4B,cAAO;AAACgtB,gBAAQ;AAAT;AAAlB;AAAT,GAA9C,EAA0F5C,cAA1F,CAAyG;AACjHE,WAAO,UAACxlB,EAAD,EAAKtT,MAAL;ACWH,aDVH04B,KAAKI,KAAL,CAAW,WAAX,EAAwBxlB,EAAxB,EAA4B;AAAC1G,eAAO5M,OAAO4M,KAAf;AAAsBtK,iBAAStC,OAAOwO,MAAP,CAAc,CAAd,EAAiB+N,QAAjB,CAA0B,CAA1B,EAA6Bja;AAA5D,OAA5B,CCUG;ADZ6G;AAIjHu2B,aAAS,UAACvlB,EAAD,EAAKtT,MAAL;AACR,UAAGA,OAAO4M,KAAV;AACC8rB,aAAKG,OAAL,CAAa,WAAb,EAA0BvlB,EAA1B,EAA8B;AAAC1G,iBAAO5M,OAAO4M;AAAf,SAA9B;ACgBG;;ADfJ,UAAG5M,OAAOwO,MAAV;ACiBK,eDhBJkqB,KAAKG,OAAL,CAAa,WAAb,EAA0BvlB,EAA1B,EAA8B;AAAChR,mBAAStC,OAAOwO,MAAP,CAAc,CAAd,EAAiB+N,QAAjB,CAA0B,CAA1B,EAA6Bja;AAAvC,SAA9B,CCgBI;AAGD;AD3B4G;AAAA,GAAzG,CAAT;AAWA,OAAKg1B,KAAL;ACoBC,SDnBD,KAAKyB,MAAL,CAAY;ACoBT,WDnBFN,OAAOO,IAAP,ECmBE;ADpBH,ICmBC;AD7CF,G;;;;;;;;;;;;AEAA94B,OAAOk3B,OAAP,CAAe,kBAAf,EAAmC,UAAC3jB,UAAD,EAAalD,iBAAb;AAClC,MAAA1P,GAAA,EAAAm7B,oBAAA;;AAAA,OAAO,KAAK1gB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACEC;;ADAF,OAAO7jB,UAAP;AACC,WAAO,KAAK6jB,KAAL,EAAP;ACEC;;ADAF0E,yBAAA,CAAAn7B,MAAAP,GAAA4hB,SAAA,CAAA1hB,OAAA,CAAAiT,UAAA;ACEGzT,YAAQ;AACNuQ,yBAAmB;AADb;ADFX,SCKQ,IDLR,GCKe1P,IDL2E0P,iBAA1F,GAA0F,MAA1F;;AAEA,MAAGyrB,wBAAwB96B,EAAEjS,OAAF,CAAU+sC,oBAAV,CAA3B;AACC,WAAO17B,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkB;AAAC9I,WAAK;AAAC4iB,aAAM2Y;AAAP;AAAN,KAAlB,EAAuD;AAACh8B,cAAQ;AAACS,aAAK,CAAN;AAASvK,cAAM,CAAf;AAAkBoN,eAAO;AAAzB;AAAT,KAAvD,CAAP;AADD;AAGC,WAAO,KAAKg0B,KAAL,EAAP;ACeC;AD3BH,G;;;;;;;;;;;;AEAA,IAAGp3B,OAAOC,QAAV;AACID,SAAOk3B,OAAP,CAAe,kBAAf,EAAmC,UAACrH,OAAD;AAC/BsH,UAAMtH,OAAN,EAAelhC,MAAf;;AAEA,SAAO,KAAKysB,MAAZ;AACI,aAAO,KAAKgc,KAAL,EAAP;ACAP;;ADEG,WAAOh3B,GAAGib,gBAAH,CAAoBhS,IAApB,CAAyB;AAAEjG,aAAOysB;AAAT,KAAzB,EAA6C;AAAC/vB,cAAQ;AAAC6pB,oBAAY,CAAb;AAAgBD,iBAAS,CAAzB;AAA4B5mB,qBAAa;AAAzC;AAAT,KAA7C,CAAP;AANJ;ACeH,C;;;;;;;;;;;;AChBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAnCA,IAAAi5B,mCAAA,EAAAC,6BAAA;;AAqFAA,gCAAgC,UAACnM,OAAD,EAAUzU,MAAV,EAAkB6gB,MAAlB,EAA0B3kC,QAA1B;ACG9B,SDFD8I,GAAG4hB,SAAH,CAAa0Y,aAAb,GAA6BC,SAA7B,CAAuC,CACtC;AACCuB,YAAQ;AACP94B,aAAOysB,OADA;AAEP1L,WAAK,CAAC;AAACiW,qBAAahf;AAAd,OAAD,EAAwB;AAACiZ,kBAAUjZ;AAAX,OAAxB;AAFE;AADT,GADsC,EAOtC;AACC+gB,YAAQ;AACP57B,WAAK;AAACqD,cAAM,OAAP;AAAgBU,kBAAU;AAA1B,OADE;AACsC2d,aAAO;AAACma,cAAM;AAAP;AAD7C;AADT,GAPsC,CAAvC,EAYGxB,OAZH,CAYW,UAAC/P,GAAD,EAAM37B,IAAN;AACV,QAAG27B,GAAH;AACC,YAAM,IAAIjvB,KAAJ,CAAUivB,GAAV,CAAN;ACcE;;ADZH37B,SAAKuR,OAAL,CAAa,UAACo6B,GAAD;ACcT,aDbHoB,OAAOhmC,IAAP,CAAY4kC,GAAZ,CCaG;ADdJ;;AAGA,QAAGvjC,YAAY0J,EAAE85B,UAAF,CAAaxjC,QAAb,CAAf;AACCA;ACcE;ADlCJ,ICEC;ADH8B,CAAhC;;AAwBAykC,sCAAsC/7B,OAAO+6B,SAAP,CAAiBiB,6BAAjB,CAAtC;AAEAh8B,OAAOk3B,OAAP,CAAe,+BAAf,EAAgD,UAACrH,OAAD;AAE/C,MAAAwM,WAAA,EAAAC,UAAA,EAAAC,KAAA,EAAArtC,IAAA,EAAAqpC,MAAA,EAAA3nC,KAAA,EAAA4nC,IAAA;;AAAA,OAAO,KAAKpd,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACgBC;;ADdFoB,SAAO,IAAP;AAEA5nC,UAAQ;AAACwS,WAAOysB;AAAR,GAAR;AAEAj/B,QAAMuzB,GAAN,GAAY,CAAC;AAACiW,iBAAa,KAAKhf;AAAnB,GAAD,EAA6B;AAACiZ,cAAU,KAAKjZ;AAAhB,GAA7B,CAAZ;AAEAlsB,SAAO,EAAP;;AACA6sC,sCAAoClM,OAApC,EAA6C2I,KAAKpd,MAAlD,EAA0DlsB,IAA1D;;AAEAotC,eAAa,EAAb;;AAEAt7B,IAAE8f,IAAF,CAAO5xB,IAAP,EAAa,UAACstC,QAAD;ACmBV,WDlBFF,WAAWrmC,IAAX,CAAgB;AAACsK,WAAKi8B,SAASj8B,GAAT,CAAaqD,IAAnB;AAAyBU,gBAAUk4B,SAASj8B,GAAT,CAAa+D,QAAhD;AAA0D2d,aAAOua,SAASva;AAA1E,KAAhB,CCkBE;ADnBH;;AAGAuW,OAAKI,KAAL,CAAW,gBAAX,EAA6B/I,OAA7B,EAAsC;AAACvkB,WAAOgxB;AAAR,GAAtC;;AAEAD,gBAAc,UAACxB,GAAD,EAAM/N,MAAN;AACb,QAAA2P,aAAA;AAAAA,oBAAgBz7B,EAAEqI,IAAF,CAAOizB,UAAP,EAAmB,UAAC57B,CAAD;AAClC,aAAOA,EAAEH,GAAF,KAASs6B,IAAIj3B,IAApB;AADe,MAAhB;;AAEA,QAAG64B,aAAH;AACC,UAAG3P,WAAU,OAAb;AACC2P,sBAAcxa,KAAd;AADD,aAEK,IAAG6K,WAAU,SAAb;AACJ2P,sBAAcxa,KAAd;AAJF;AAAA,WAKK,IAAG6K,WAAU,OAAb;AACJwP,iBAAWrmC,IAAX,CAAgB;AAACsK,aAAKs6B,IAAIj3B,IAAV;AAAgBU,kBAAUu2B,IAAIv2B,QAA9B;AAAwC2d,eAAO;AAA/C,OAAhB;AC+BE;;AACD,WD9BFuW,KAAKG,OAAL,CAAa,gBAAb,EAA+B9I,OAA/B,EAAwC;AAACvkB,aAAOgxB;AAAR,KAAxC,CC8BE;ADzCW,GAAd;;AAaAC,UAAQ,IAAR;AACAhE,WAASn4B,GAAG4hB,SAAH,CAAa3Y,IAAb,CAAkBzY,KAAlB,EAAyB;AAACkP,YAAQ;AAACS,WAAK,CAAN;AAAS65B,mBAAa,CAAtB;AAAyB/F,gBAAU,CAAnC;AAAsCzwB,YAAM,CAA5C;AAA+CU,gBAAU;AAAzD;AAAT,GAAzB,EAAgGo4B,OAAhG,CAAwG;AAChH9D,WAAO,UAACiC,GAAD;AACN,UAAG,CAAC0B,KAAJ;ACyCK,eDxCJF,YAAYxB,GAAZ,EAAiB,OAAjB,CCwCI;AACD;AD5C2G;AAIhHnlB,aAAS,UAACmlB,GAAD;AACR,UAAG,CAAC0B,KAAJ;AC2CK,eD1CJF,YAAYxB,GAAZ,EAAiB,SAAjB,CC0CI;AACD;ADjD2G;AAAA,GAAxG,CAAT;AAQA0B,UAAQ,KAAR;AAEA/D,OAAKpB,KAAL;AC4CC,SD3CDoB,KAAKK,MAAL,CAAY;AC4CT,WD3CFN,OAAOO,IAAP,EC2CE;AD5CH,IC2CC;ADzFF,G;;;;;;;;;;;;AE9GA94B,OAAOk3B,OAAP,CAAe,2BAAf,EAA4C,UAACrH,OAAD,EAAU2B,MAAV;AAC3C2F,QAAMtH,OAAN,EAAelhC,MAAf;AACAwoC,QAAM3F,MAAN,EAAc7iC,MAAd;;AAEA,OAAO,KAAKysB,MAAZ;AACC,WAAO,KAAKgc,KAAL,EAAP;ACDC;;ADGF,QAAOvH,WAAW2B,MAAlB;AACC,WAAO,KAAK4F,KAAL,EAAP;ACDC;;ADGF,SAAO9sB,QAAQqyB,aAAR,CAAsB,WAAtB,EAAmCtzB,IAAnC,CAAwC;AAAEjG,WAAOysB,OAAT;AAAkB,gBAAY,OAA9B;AAAuC,kBAAc2B,MAArD;AAA8Dx7B,UAAM;AAApE,GAAxC,CAAP;AAVD,G;;;;;;;;;;;;AEDA4mC,mBAAmB,EAAnB;AAKAA,iBAAiB,IAAjB,IAAwB,EAAxB;AAKAA,iBAAiB,OAAjB,IAA2B,EAA3B;AAEA58B,OAAO68B,OAAP,CAAe;AACd,MAAAC,gBAAA,EAAAC,gBAAA,EAAAC,YAAA,EAAAC,YAAA,EAAAC,EAAA,EAAAC,IAAA,EAAAxsC,IAAA,EAAAysC,OAAA,EAAAC,OAAA,EAAAC,YAAA,EAAA38B,GAAA,EAAA+K,IAAA;AAAAwxB,OAAKl4B,QAAQ,IAAR,CAAL;AACArU,SAAOqU,QAAQ,MAAR,CAAP;AACAm4B,SAAOn4B,QAAQ,MAAR,CAAP;;AACAs4B,iBAAe,UAACC,OAAD,EAAUC,SAAV;AACd,QAAAzZ,KAAA;AAAAA,YAAQmZ,GAAGO,WAAH,CAAeF,OAAf,CAAR;ACDE,WDEFxZ,MAAMtjB,OAAN,CAAc,UAACzK,IAAD,EAAO8B,KAAP;AACb,UAAA9I,GAAA,EAAA0uC,IAAA;AAAAA,aAAOR,GAAGS,QAAH,CAAYhtC,KAAK4D,IAAL,CAAUgpC,OAAV,EAAmBvnC,IAAnB,CAAZ,CAAP;;AACA,UAAG0nC,KAAKE,WAAL,EAAH;ACAK,eDEJN,aAAa3sC,KAAK4D,IAAL,CAAUgpC,OAAV,EAAmBvnC,IAAnB,CAAb,EAAuCwnC,SAAvC,CCFI;ADAL;AAICxuC,cAAM,EAAN;AACAA,YAAI2B,IAAJ,GAAW4sC,OAAX;AACAvuC,YAAIgH,IAAJ,GAAWA,IAAX;ACDI,eDEJwnC,UAAUvnC,IAAV,CAAejH,GAAf,CCFI;AACD;ADRL,MCFE;ADAY,GAAf;;AAcAguC,iBAAe,EAAf;AACAI,YAAA,CAAAz8B,MAAAX,OAAA2Q,QAAA,CAAAktB,iBAAA,YAAAl9B,IAA6Cy8B,OAA7C,GAA6C,MAA7C;;AACA,MAAGA,OAAH;AACCN,uBAAmBnsC,KAAKmtC,OAAL,CAAaV,OAAb,CAAnB;AACAx8B,YAAQC,GAAR,CAAY,kBAAZ,EAAgCi8B,gBAAhC;;AACA,QAAGI,GAAGa,UAAH,CAAcjB,gBAAd,CAAH;AACCQ,mBAAaR,gBAAb,EAA+BE,YAA/B;AACAA,mBAAav8B,OAAb,CAAqB,UAACu9B,IAAD;AACpB,YAAA9uC,IAAA,EAAAyE,CAAA;;AAAA;AACC,cAAGwpC,KAAK1uC,OAAL,CAAauvC,KAAKhoC,IAAlB,MAA2B,kBAA9B;AACC9G,mBAAOguC,GAAGe,YAAH,CAAgBttC,KAAK4D,IAAL,CAAUypC,KAAKrtC,IAAf,EAAqBqtC,KAAKhoC,IAA1B,CAAhB,EAAiD,MAAjD,CAAP;ACCM,mBDAN4mC,iBAAiB,OAAjB,EAA0B3mC,IAA1B,CAA+B4T,KAAKhV,KAAL,CAAW3F,IAAX,CAA/B,CCAM;ADHR;AAAA,iBAAA0Z,KAAA;AAIMjV,cAAAiV,KAAA;AACLhI,kBAAQgI,KAAR,CAAc,kBAAd,EAAkCjY,KAAK4D,IAAL,CAAUypC,KAAKrtC,IAAf,EAAqBqtC,KAAKhoC,IAA1B,CAAlC;ACGK,iBDFL4K,QAAQgI,KAAR,CAAcjV,EAAEs5B,KAAhB,CCEK;AACD;ADVN;AALF;ACkBE;;ADHFgQ,iBAAe,EAAf;AACAI,YAAA,CAAA3xB,OAAA1L,OAAA2Q,QAAA,CAAAktB,iBAAA,YAAAnyB,KAA6C2xB,OAA7C,GAA6C,MAA7C;;AACA,MAAGA,OAAH;AACCN,uBAAmBpsC,KAAKmtC,OAAL,CAAaT,OAAb,CAAnB;AACAz8B,YAAQC,GAAR,CAAY,kBAAZ,EAAgCk8B,gBAAhC;;AACA,QAAGG,GAAGa,UAAH,CAAchB,gBAAd,CAAH;AACCO,mBAAaP,gBAAb,EAA+BE,YAA/B;ACKG,aDJHA,aAAax8B,OAAb,CAAqB,UAACu9B,IAAD;AACpB,YAAA9uC,IAAA,EAAAyE,CAAA;;AAAA;AACC,cAAGwpC,KAAK1uC,OAAL,CAAauvC,KAAKhoC,IAAlB,MAA2B,kBAA9B;AACC9G,mBAAOguC,GAAGe,YAAH,CAAgBttC,KAAK4D,IAAL,CAAUypC,KAAKrtC,IAAf,EAAqBqtC,KAAKhoC,IAA1B,CAAhB,EAAiD,MAAjD,CAAP;ACMM,mBDLN4mC,iBAAiB,IAAjB,EAAuB3mC,IAAvB,CAA4B4T,KAAKhV,KAAL,CAAW3F,IAAX,CAA5B,CCKM;ADRR;AAAA,iBAAA0Z,KAAA;AAIMjV,cAAAiV,KAAA;AACLhI,kBAAQgI,KAAR,CAAc,kBAAd,EAAkCjY,KAAK4D,IAAL,CAAUypC,KAAKrtC,IAAf,EAAqBqtC,KAAKhoC,IAA1B,CAAlC;ACQK,iBDPL4K,QAAQgI,KAAR,CAAcjV,EAAEs5B,KAAhB,CCOK;AACD;ADfN,QCIG;ADTL;ACuBE;AD5DH,G;;;;;;;;;;;;;;;;;;;;;;;;AEZA;;;;;;;;;;GAWAjtB,OAAO68B,OAAP,CAAe;AACd,MAAAqB,OAAA,EAAAv9B,GAAA,EAAAw9B,IAAA,EAAAC,QAAA;;AAAA,OAAAz9B,MAAAX,OAAA2Q,QAAA,CAAA0tB,IAAA,YAAA19B,IAAyB29B,8BAAzB,GAAyB,MAAzB;AACCF,eAAWp5B,QAAQ,eAAR,CAAX;AAEAm5B,WAAOn+B,OAAO2Q,QAAP,CAAgB0tB,IAAhB,CAAqBC,8BAA5B;AACAJ,cAAU,IAAV;ACEE,WDDFE,SAASG,WAAT,CAAqBJ,IAArB,EAA2Bn+B,OAAOw+B,eAAP,CAAuB;AACjD,UAAA7qC,CAAA,EAAAkyB,GAAA;;AAAA;AACC,YAAG,CAACqY,OAAJ;AACC;ACGI;;ADFLA,kBAAU,KAAV;AACAt9B,gBAAQ69B,IAAR,CAAa,gCAAb;AAEA5Y,cAAM,IAAI3jB,IAAJ,EAAN;AAGA9B,WAAGs+B,wBAAH,CAA4BC,MAA5B,CAAmC;AAAEC,mBAAS,IAAX;AAAiBC,oBAAU;AAAEC,kBAAMjZ;AAAR;AAA3B,SAAnC,EAA+E;AAAEkZ,gBAAM;AAAEH,qBAAS;AAAX;AAAR,SAA/E,EAA6G;AAAEI,iBAAO;AAAT,SAA7G;AAEAp+B,gBAAQq+B,OAAR,CAAgB,gCAAhB;ACWI,eDVJf,UAAU,ICUN;ADtBL,eAAAt1B,KAAA;AAcMjV,YAAAiV,KAAA;AACLhI,gBAAQgI,KAAR,CAAc,6CAAd;AACAhI,gBAAQgI,KAAR,CAAcjV,EAAEs5B,KAAhB;ACWI,eDVJiR,UAAU,ICUN;AACD;AD7BsB,OAoBzB,UAACvqC,CAAD;AACDiN,cAAQC,GAAR,CAAY,mEAAZ;ACWG,aDVHD,QAAQC,GAAR,CAAYlN,EAAEs5B,KAAd,CCUG;ADhCuB,MAA3B,CCCE;AAiCD;ADxCH,G;;;;;;;;;;;;AEXA;;;;;;;;;;GAWAjtB,OAAO68B,OAAP,CAAe;AACd,MAAAqB,OAAA,EAAAv9B,GAAA,EAAAw9B,IAAA,EAAAC,QAAA;;AAAA,OAAAz9B,MAAAX,OAAA2Q,QAAA,CAAA0tB,IAAA,YAAA19B,IAAyBu+B,mBAAzB,GAAyB,MAAzB;AACCd,eAAWp5B,QAAQ,eAAR,CAAX;AAEAm5B,WAAOn+B,OAAO2Q,QAAP,CAAgB0tB,IAAhB,CAAqBa,mBAA5B;AACAhB,cAAU,IAAV;ACEE,WDDFE,SAASG,WAAT,CAAqBJ,IAArB,EAA2Bn+B,OAAOw+B,eAAP,CAAuB;AACjD,UAAA7qC,CAAA;;AAAA;AACC,YAAG,CAACuqC,OAAJ;AACC;ACGI;;ADFLA,kBAAU,KAAV;AACAt9B,gBAAQ69B,IAAR,CAAa,qBAAb;AAEAv+B,sBAAci/B,iBAAd;AAEAv+B,gBAAQq+B,OAAR,CAAgB,qBAAhB;ACEI,eDDJf,UAAU,ICCN;ADVL,eAAAt1B,KAAA;AAWMjV,YAAAiV,KAAA;AACLhI,gBAAQgI,KAAR,CAAc,kCAAd;AACAhI,gBAAQgI,KAAR,CAAcjV,EAAEs5B,KAAhB;ACEI,eDDJiR,UAAU,ICCN;AACD;ADjBsB,OAiBzB,UAACvqC,CAAD;AACDiN,cAAQC,GAAR,CAAY,wDAAZ;ACEG,aDDHD,QAAQC,GAAR,CAAYlN,EAAEs5B,KAAd,CCCG;ADpBuB,MAA3B,CCCE;AAqBD;AD5BH;AA2BAjtB,OAAOstB,OAAP,CACC;AAAA4R,uBAAqB,UAAC1R,MAAD;AACpBttB,kBAAci/B,iBAAd,CAAgC3R,MAAhC;AACA,WAAO,IAAP;AAFD;AAAA,CADD,E;;;;;;;;;;;;AEtCAxtB,OAAO68B,OAAP,CAAe;ACCb,SDADuC,cAAcC,yBAAd,GAA0C,IAAIC,QAAQC,KAAZ,CACzC;AAAAvpC,UAAM,2BAAN;AACAwpC,gBAAYp/B,GAAG4hB,SADf;AAEAyd,aAAS,CACR;AACCvwC,YAAM,KADP;AAECwwC,aAAO,qDAFR;AAGCC,iBAAW,KAHZ;AAICjvB,aAAO,KAJR;AAKCkvB,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAAgF,KAAA,EAAAl/B,GAAA;AAAAk/B,gBAAQ,mIAAmIhF,IAAIt6B,GAAvI,GAA6I,GAArJ;;AAEA,aAAAI,MAAAy+B,cAAAC,yBAAA,CAAAhvB,iBAAA,YAAA1P,IAA8DiS,QAA9D,CAAuEioB,IAAIt6B,GAA3E,IAAG,MAAH;AACCs/B,mBAAS,WAAT;ACCK;;ADCNA,iBAAS,GAAT;AACA,eAAOA,KAAP;AAZF;AAAA,KADQ,EAeR;AACC3wC,YAAM,MADP;AAECywC,iBAAW,KAFZ;AAGCjvB,aAAO,KAHR;AAICkvB,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAAl/B,QAAA,EAAA7N,IAAA;AAAAA,eAAO,EAAP;;AACA,YAAGkS,OAAO2J,QAAP,KAAoBtC,QAAQ0J,QAAR,MAAsB1J,QAAQ2kB,SAAR,EAA1C,CAAH;AACCl+B,iBAAO,EAAP;ACEK;;ADAN6N,mBAAW,KAAX;;AAEA,YAAGqE,OAAOC,QAAV;AACCtE,qBAAW,KAAKA,QAAhB;ACCK;;ADAN,YAAGA,QAAH;AACC7N,iBAAOkS,OAAOsH,WAAP,CAAmB,oBAAkBuzB,IAAIz3B,KAAtB,GAA4B,iBAA5B,GAAgDy3B,IAAIt6B,GAApD,GAA0D,gBAA7E,CAAP;AADD;AAGCzS,iBAAOuZ,QAAQC,WAAR,CAAoB,oBAAkBuzB,IAAIz3B,KAAtB,GAA4B,iBAA5B,GAAgDy3B,IAAIt6B,GAApD,GAA0D,gBAA9E,CAAP;ACEK;;ADDN,eAAO,iBAAes6B,IAAIt6B,GAAnB,GAAuB,0BAAvB,GAAiDzS,IAAjD,GAAsD,IAAtD,GAA6D+sC,IAAI7kC,IAAjE,GAAwE,MAA/E;AAjBF;AAAA,KAfQ,EAkCR;AACC9G,YAAM,gBADP;AAECwwC,aAAOrqC,EAAE,0BAAF,CAFR;AAGCsqC,iBAAW;AAHZ,KAlCQ,EAuCR;AACCzwC,YAAM,WADP;AAECwwC,aAAOrqC,EAAE,gBAAF,CAFR;AAGCsqC,iBAAW;AAHZ,KAvCQ,EA4CR;AACCzwC,YAAM,mBADP;AAECwwC,aAAOrqC,EAAE,gBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAA73B,KAAA,EAAA88B,iBAAA;;AAAA,YAAGjF,IAAInuB,KAAJ,KAAa,WAAhB;AACC1J,kBAAQ63B,IAAI5pB,cAAJ,IAAsB,UAA9B;ACEK;;ADAN6uB,4BAAoBjF,IAAIkF,iBAAJ,IAAyB,EAA7C;AAEA,eAAO,qCAC4B/8B,KAD5B,GACkC,KADlC,GACsC88B,iBADtC,GACwD,QAD/D;AATF;AAAA,KA5CQ,CAFT;AA6DAE,SAAK,IA7DL;AA8DAC,kBAAc,KA9Dd;AA+DAC,iBAAa,CAAC,OAAD,EAAU,gBAAV,EAA4B,OAA5B,EAAqC,UAArC,CA/Db;AAgEAC,gBAAY,EAhEZ;AAiEAC,UAAM,KAjEN;AAkEAC,eAAW,IAlEX;AAmEAC,gBACC;AAAAC,eAAS;AAAT,KApED;AAqEAC,eAAW,KArEX;AAsEAC,oBAAgB,UAAC1d,QAAD,EAAW3H,MAAX;AACf,UAAAslB,YAAA,EAAA3H,QAAA,EAAAztB,KAAA,EAAAyoB,aAAA,EAAApzB,GAAA,EAAA+K,IAAA,EAAAtI,KAAA,EAAAysB,OAAA;;AAAA,WAAOzU,MAAP;AACC,eAAO;AAAC7a,eAAK,CAAC;AAAP,SAAP;ACGG;;ADDJsvB,gBAAU9M,SAAS3f,KAAnB;;AACA,WAAOysB,OAAP;AACC,aAAA9M,YAAA,QAAApiB,MAAAoiB,SAAA4d,IAAA,YAAAhgC,IAAmBlT,MAAnB,GAAmB,MAAnB,GAAmB,MAAnB,IAA4B,CAA5B;AACCoiC,oBAAU9M,SAAS4d,IAAT,CAAc73B,WAAd,CAA0B,OAA1B,EAAmC,CAAnC,CAAV;AAFF;ACMI;;ADHJ,WAAO+mB,OAAP;AACC,eAAO;AAACtvB,eAAK,CAAC;AAAP,SAAP;ACOG;;ADNJ6C,cAAQhD,GAAG2yB,MAAH,CAAUzyB,OAAV,CAAkBuvB,OAAlB,CAAR;;AACA,UAAG,CAACzsB,KAAJ;AACC2f,iBAASrW,KAAT,GAAiB,MAAjB;ACQG;;ADPJ,UAAG,CAACtJ,MAAMw9B,MAAN,CAAahuB,QAAb,CAAsBwI,MAAtB,CAAJ;AAEC2d,mBAAW,EAAX;AACA2H,uBAAetgC,GAAG4yB,WAAH,CAAe1yB,OAAf,CAAuB;AACrC8C,iBAAOysB,OAD8B;AAErC,kBAAQzU;AAF6B,SAAvB,CAAf;;AAIA,YAAGslB,YAAH;AACC3M,0BAAgB3zB,GAAG2zB,aAAH,CAAiB1qB,IAAjB,CAAsB;AACrC9I,iBAAK;AACJ4iB,mBAAKud,aAAa3M;AADd;AADgC,WAAtB,EAIb3P,KAJa,EAAhB;AAKA9Y,kBAAQlL,GAAGkL,KAAH,CAASjC,IAAT,CAAc;AAAEjG,mBAAOysB;AAAT,WAAd,CAAR;AACAvkB,gBAAM7K,OAAN,CAAc,UAACogC,EAAD;AACb,gBAAGx0B,gBAAgB2nB,UAAhB,CAA2B6M,EAA3B,EAA+BH,YAA/B,EAA6C3M,aAA7C,KAA+D1nB,gBAAgB4nB,QAAhB,CAAyB4M,EAAzB,EAA6BH,YAA7B,EAA2C3M,aAA3C,CAAlE;ACUQ,qBDTPgF,SAAS9iC,IAAT,CAAc4qC,GAAGtgC,GAAjB,CCSO;AACD;ADZR;ACcI;;ADVL,aAAAwiB,YAAA,QAAArX,OAAAqX,SAAA4d,IAAA,YAAAj1B,KAAmBje,MAAnB,GAAmB,MAAnB,GAAmB,MAAnB,IAA4B,CAA5B;AACCs1B,mBAAS4d,IAAT,CAAc,CAAd,EAAiBxc,GAAjB,GAAuB,CAAC;AAAC7gB,uBAAW8X;AAAZ,WAAD,EAAsB;AAAC5X,uBAAW4X;AAAZ,WAAtB,EAA2C;AAACgf,yBAAahf;AAAd,WAA3C,EAAkE;AAACkZ,0BAAclZ;AAAf,WAAlE,EACrB;AAACiZ,sBAAUjZ;AAAX,WADqB,EACD;AAAExX,kBAAM;AAAEuf,mBAAK4V;AAAP;AAAR,WADC,CAAvB;AADD;AAIC/3B,YAAE8/B,MAAF,CAAS/d,QAAT,EAAmB;AAClBoB,iBAAK,CAAC;AAAC7gB,yBAAW8X;AAAZ,aAAD,EAAsB;AAAC5X,yBAAW4X;AAAZ,aAAtB,EAA2C;AAACgf,2BAAahf;AAAd,aAA3C,EAAkE;AAACkZ,4BAAclZ;AAAf,aAAlE,EACJ;AAACiZ,wBAAUjZ;AAAX,aADI,EACgB;AAAExX,oBAAM;AAAEuf,qBAAK4V;AAAP;AAAR,aADhB;AADa,WAAnB;AAtBF;ACoEI;;ADzCJ,aAAOhW,QAAP;AA9GD;AAAA,GADyC,CCAzC;ADDF,G;;;;;;;;;;;;AEAA,IAAAge,6BAAA,EAAAC,oCAAA,EAAAC,qCAAA,EAAAC,iBAAA,EAAAC,6BAAA,EAAAC,yBAAA,EAAAC,uBAAA,EAAAC,kBAAA;;AAAAj6B,QAAQk6B,IAAR,CAAa,iBAAb,IAAkC,IAAIC,WAAJ,EAAlC;;AAGAN,oBAAoB,UAACphC,MAAD;AACnB,MAAA2hC,UAAA;AAAAA,eAAa,IAAI1hC,KAAJ,EAAb;;ACGC,MAAID,UAAU,IAAd,EAAoB;ADDrBA,WAAQW,OAAR,CAAgB,UAACC,CAAD;AACf,UAAAC,GAAA;;AAAA,UAAGD,EAAEnO,IAAF,KAAU,OAAb;ACIM,eDHLqO,QAAQC,GAAR,CAAY,+BAAZ,CCGK;ADJN,aAEK,IAAGH,EAAEnO,IAAF,KAAU,SAAb;ACIC,eAAOmO,KAAK,IAAL,GAAY,CAACC,MAAMD,EAAEZ,MAAT,KAAoB,IAApB,GAA2Ba,IDHxCF,OCGwC,CDHhC,UAACK,EAAD;ACIZ,iBDHN2gC,WAAWxrC,IAAX,CAAgB6K,EAAhB,CCGM;ADJP,SCGmD,CAA3B,GDHxB,MCGY,GDHZ,MCGK;ADJD;ACQC,eDJL2gC,WAAWxrC,IAAX,CAAgByK,CAAhB,CCIK;AACD;ADZN;ACcE;;ADLF,SAAO+gC,UAAP;AAZmB,CAApB;;AAeAH,qBAAqB,cAArB;;AAGAF,4BAA4B,UAAC5P,MAAD,EAAS1xB,MAAT;AAC3B,MAAA2hC,UAAA,EAAAjrC,GAAA,EAAAe,OAAA;AAAAA,YAAU;AACTvB,UAAM,WADG;AAETwpC,gBAAYp/B,GAAG4hB,SAFN;AAGT0f,SAAK,kBAHI;AAITC,cAAU;ACON,aDNH3hC,OAAOwX,UAAP,CAAkBxR,SAAS47B,aAAT,CAAuBC,aAAzC,EAAwD,GAAxD,CCMG;ADXK;AAOTC,kBAAc,UAACnxB,QAAD;AACb,UAAAoxB,YAAA,EAAAC,OAAA,EAAAtC,KAAA;AAAAsC,gBAAU7sB,EAAE,mBAAF,CAAV;;AACA,UAAG6sB,QAAQv0C,MAAX;AACCu0C,gBAAQ,CAAR,EAAWC,OAAX,GAAqB,GAArB;ACQG;;ADPJ,UAAG,CAAC56B,QAAQ0J,QAAR,EAAD,IAAuB,CAAC1J,QAAQ66B,KAAR,EAA3B;AACCliC,eAAOwX,UAAP,CAAkBxR,SAAS47B,aAAT,CAAuBC,aAAzC,EAAwD,GAAxD;AACA1sB,UAAE,gBAAF,EAAoBuW,SAApB,CAA8B,CAA9B,EAAiC0L,KAAjC,CAAuC;ACSjC,iBDRLjiB,EAAE,gBAAF,EAAoBgtB,gBAApB,CAAqC,QAArC,CCQK;ADTN;AAFD;AAKChtB,UAAE,gBAAF,EAAoBuW,SAApB,CAA8B,CAA9B;ACUG;;ADRJgU,cAAQrqC,EAAE,kBAAF,CAAR;AACA0sC,qBAAepxB,SAASyxB,SAAT,CAAmB7e,MAAnB,GAA4Bla,IAA5B,CAAiC,yCAAjC,CAAf;ACUG,aDTH04B,aAAaM,IAAb,CAAkB,OAAlB,EAA2B3C,KAA3B,EAAkC7K,GAAlC,CAAsC,QAAtC,EAAgD,SAAhD,EAA2DyN,KAA3D,CAAiE;AAChE,YAAAC,MAAA,EAAA1C,KAAA;;AAAA,YAAG,CAAC1qB,EAAE,IAAF,EAAQ9L,IAAR,CAAa,OAAb,EAAsB5b,MAA1B;AACCoyC,kBAAQ1qB,EAAE,wGAAF,CAAR;;AACA,cAAG9N,QAAQ0J,QAAR,EAAH;AACC8uB,kBAAMhL,GAAN,CAAU;AACTnkB,qBAAM,MADG;AAET8xB,sBAAQ;AAFC,aAAV;AADD;AAMC3C,kBAAMhL,GAAN,CAAU;AACTnkB,qBAAM,MADG;AAET8xB,sBAAQ;AAFC,aAAV;ACcK;;ADVN3C,gBAAMwC,IAAN,CAAW,OAAX,EAAoB3C,KAApB,EAA2B2C,IAA3B,CAAgC,aAAhC,EAA+C3C,KAA/C;AACAvqB,YAAE,IAAF,EAAQ8B,KAAR,GAAgBP,MAAhB,CAAuBmpB,KAAvB;;AACA0C,mBAAS,UAACzqC,KAAD;AACR,gBAAA2qC,KAAA;;AAAA,gBAAG3qC,QAAQ,CAAX;AACC2qC,sBAAQtrC,KAAKurC,IAAL,CAAU/xB,SAASgyB,gBAAT,KAA8BhyB,SAASiyB,eAAjD,CAAR;;AACA,kBAAG9qC,QAAQ2qC,KAAX;AAEC3qC,wBAAQ2qC,KAAR;ACYO;;ADXR3qC;ACaO,qBDZP6Y,SAASyxB,SAAT,CAAmBS,SAAnB,GAA+BC,IAA/B,CAAoChrC,KAApC,EAA2CirC,IAA3C,CAAgD,MAAhD,CCYO;AACD;ADpBC,WAAT;;AAQAlD,gBAAMmD,IAAN,CAAW,UAACrvC,CAAD;AACV,gBAAAsvC,WAAA;AAAAA,0BAAc9tB,EAAE,IAAF,EAAQvD,GAAR,EAAd;AACA2wB,mBAAOU,WAAP;ACgBM,mBDfN9tB,EAAE,IAAF,EAAQoO,MAAR,GAAiBxT,IAAjB,CAAsB,KAAtB,CCeM;ADlBP;ACoBK,iBDhBL8vB,MAAMqD,OAAN,CAAc,UAACvvC,CAAD;AACb,gBAAAsvC,WAAA;;AAAA,gBAAGtvC,EAAEwvC,OAAF,CAAUv0C,QAAV,OAAwB,IAA3B;AACCq0C,4BAAc9tB,EAAE,IAAF,EAAQvD,GAAR,EAAd;ACkBO,qBDjBP2wB,OAAOU,WAAP,CCiBO;AACD;ADrBR,YCgBK;AAOD;ADlDN,QCSG;AD7BK;AAoDTG,gBAAY,UAACC,GAAD,EAAMn0C,IAAN,EAAYo0C,SAAZ;AACX,UAAGtjC,OAAO2J,QAAV;AACC,YAAGza,KAAKqR,GAAL,KAAYgjC,WAAWt4B,OAAX,GAAqB8lB,MAArB,CAA4Bxd,UAA3C;ACsBM,iBDrBL8vB,IAAIG,YAAJ,CAAiB,OAAjB,EAA0B,UAA1B,CCqBK;ADvBP;ACyBI;AD9EI;AAwDT/D,aAAS,CACR;AACCvwC,YAAM,KADP;AAECywC,iBAAW,KAFZ;AAGCC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAA4I,UAAA,EAAAC,OAAA,EAAA7/B,SAAA,EAAA8/B,yBAAA,EAAA9gC,QAAA,EAAA+gC,eAAA,EAAAC,cAAA,EAAAC,YAAA,EAAAC,iBAAA,EAAAC,aAAA,EAAArjC,GAAA,EAAA+K,IAAA,EAAAu4B,sBAAA,EAAAC,MAAA;AAAAL,yBAAiBz2B,OAAOytB,IAAIh4B,QAAX,EAAqBwK,MAArB,CAA4B,YAA5B,CAAjB;AAEAxK,mBAAWg4B,IAAIh4B,QAAf;;AACA,YAAGiR,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAInuB,KAAJ,KAAa,OAAjD;AACC7J,qBAAWg4B,IAAI54B,UAAJ,IAAkB44B,IAAIh4B,QAAjC;ACyBK;;ADvBN,YAAGiR,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,QAAtB,IAAkC8Y,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,SAA3D;AACC6H,qBAAWg4B,IAAIl3B,WAAJ,IAAmBk3B,IAAIl3B,WAAlC;ACyBK;;ADvBNigC,0BAAkBv8B,QAAQ88B,qBAAR,CAA8BthC,QAA9B,CAAlB;AACAgB,oBAAYg3B,IAAIh3B,SAAhB;AACA6/B,kBAAU,EAAV;AACAO,iCAAyB,EAAzB;;AAEA,YAAGpJ,IAAIa,KAAJ,IAAa,GAAA/6B,MAAAk6B,IAAAT,WAAA,YAAAz5B,IAAkBiS,QAAlB,CAA2B5S,OAAOob,MAAP,EAA3B,IAAC,MAAD,CAAb,IAA4DtH,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAArF;AACC0oC,oBAAU,8BAA8B16B,QAAQC,EAAR,CAAW,mBAAX,CAA9B,GAAgE,YAA1E;AACAg7B,mCAAyB,4BAA0BpgC,SAA1B,GAAoC,SAApC,GAA6Cg3B,IAAIkF,iBAAjD,GAAmE,gBAA5F;AAFD;AAIC,cAAGjsB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAIkF,iBAAxC;AACCkE,qCAAyB,4BAA0BpgC,SAA1B,GAAoC,SAApC,GAA6Cg3B,IAAIkF,iBAAjD,GAAmE,gBAA5F;AADD;AAGCkE,qCAAyB,4BAA0BpgC,SAA1B,GAAoC,QAA7D;AAPF;ACgCM;;ADvBN4/B,qBAAa,EAAb;;AACA,YAAG5I,IAAIW,eAAJ,IAAuB1nB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAhD;AACCyoC,uBAAa,8BAA8Bz6B,QAAQC,EAAR,CAAW,sCAAX,EAAmD;AAACmhB,sBAAUyQ,IAAIW;AAAf,WAAnD,CAA9B,GAAoH,WAAjI;AC2BK;;ADzBN0I,iBAAS,EAAT;;AAMA,YAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAIz4B,OAAJ,KAAe,KAAnD;AACC8hC,mBAAS,uCAAT;AADD,eAEK,IAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,SAAtB,IAAmC6/B,IAAI3I,SAAJ,KAAiB,IAAvD;AACJgS,mBAAS,4BAAT;ACsBK;;ADpBNJ,uBAAe,EAAf;AACAC,4BAAoB,EAApB;AACAC,wBAAA,CAAAt4B,OAAAmvB,IAAAv4B,MAAA,YAAAoJ,KAA4B04B,QAA5B,GAA4B,MAA5B;;AACA,gBAAOJ,aAAP;AAAA,eACM,IADN;AAEED,gCAAoB,QAApB;AADI;;AADN,eAGM,IAHN;AAIEA,gCAAoB,SAApB;AADI;;AAHN,eAKM,IALN;AAMEA,gCAAoB,OAApB;AANF;;AAOA,YAAGA,iBAAH;AACCJ,sCAA4B,mCAAiCI,iBAA7D;ACyBK;;ADvBN,eAAO,oCAC6BG,MAD7B,GACoC,oCADpC,GAEwBP,yBAFxB,GAEkD,IAFlD,GAEsD9I,IAAI7kC,IAF1D,GAEiE0tC,OAFjE,GAE2ED,UAF3E,GAEsF,WAFtF,GAGK5I,IAAIp3B,cAHT,GAGwB,gDAHxB,GAK2BwgC,sBAL3B,GAKkD,4CALlD,GAMsCJ,cANtC,GAMqD,IANrD,GAMyDD,eANzD,GAMyE,iBANhF;AAvDF;AAAA,KADQ,EAkER;AACC10C,YAAM,6BADP;AAECwwC,aAAOrqC,EAAE,uCAAF,CAFR;AAGCgvC,eAAS;AAHV,KAlEQ,EAuER;AACCn1C,YAAM,MADP;AAECwwC,aAAOrqC,EAAE,gBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAA4I,UAAA,EAAAC,OAAA,EAAAC,yBAAA,EAAAI,iBAAA,EAAAC,aAAA,EAAArjC,GAAA,EAAA+K,IAAA,EAAAu4B,sBAAA,EAAAC,MAAA;AAAAR,kBAAU,EAAV;AACAO,iCAAyB,EAAzB;;AAEA,YAAGpJ,IAAIa,KAAJ,IAAa,GAAA/6B,MAAAk6B,IAAAT,WAAA,YAAAz5B,IAAkBiS,QAAlB,CAA2B5S,OAAOob,MAAP,EAA3B,IAAC,MAAD,CAAb,IAA4DtH,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAArF;AACC0oC,oBAAU,8BAA8B16B,QAAQC,EAAR,CAAW,mBAAX,CAA9B,GAAgE,YAA1E;ACgBK;;ADdNw6B,qBAAa,EAAb;;AACA,YAAG5I,IAAIW,eAAP;AACCiI,uBAAa,8BAA8Bz6B,QAAQC,EAAR,CAAW,sCAAX,EAAmD;AAACmhB,sBAAUyQ,IAAIW;AAAf,WAAnD,CAA9B,GAAoH,WAAjI;ACkBK;;ADhBN0I,iBAAS,EAAT;;AAEA,YAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAIz4B,OAAJ,KAAe,KAAnD;AACC8hC,mBAAS,uCAAT;AADD,eAEK,IAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,SAAtB,IAAmC6/B,IAAI3I,SAAJ,KAAiB,IAAvD;AACJgS,mBAAS,4BAAT;ACiBK;;ADfNH,4BAAoB,EAApB;AACAC,wBAAA,CAAAt4B,OAAAmvB,IAAAv4B,MAAA,YAAAoJ,KAA4B04B,QAA5B,GAA4B,MAA5B;;AACA,gBAAOJ,aAAP;AAAA,eACM,IADN;AAEED,gCAAoB,QAApB;AADI;;AADN,eAGM,IAHN;AAIEA,gCAAoB,SAApB;AADI;;AAHN,eAKM,IALN;AAMEA,gCAAoB,OAApB;AANF;;AAOA,YAAGA,iBAAH;AACCJ,sCAA4B,mCAAiCI,iBAA7D;ACoBK;;ADnBN,eAAO,oCAC4BG,MAD5B,GACmC,oCADnC,GAEuBP,yBAFvB,GAEiD,IAFjD,GAEqD9I,IAAI7kC,IAFzD,GAEgE0tC,OAFhE,GAE0ED,UAF1E,GAEqF,QAF5F;AAhCF;AAoCCY,eAAS,KApCV;AAqCC1E,iBAAW;AArCZ,KAvEQ,EA8GR;AACCzwC,YAAM,gBADP;AAECwwC,aAAOrqC,EAAE,0BAAF,CAFR;AAGCgvC,eAAS,KAHV;AAIC1E,iBAAW;AAJZ,KA9GQ,EAoHR;AACCzwC,YAAM,aADP;AAECwwC,aAAOrqC,EAAE,uBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAGA,IAAIl3B,WAAP;AACC,iBAAOyJ,OAAOytB,IAAIl3B,WAAX,EAAwB0J,MAAxB,CAA+B,kBAA/B,CAAP;ACiBK;ADtBR;AAOCg3B,eAAS,KAPV;AAQC1E,iBAAW;AARZ,KApHQ,EA8HR;AACCzwC,YAAM,WADP;AAECwwC,aAAOrqC,EAAE,gBAAF,CAFR;AAGCgvC,eAAS,KAHV;AAIC1E,iBAAW;AAJZ,KA9HQ,EAoIR;AACCzwC,YAAM,mBADP;AAECwwC,aAAOrqC,EAAE,6BAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAAyJ,MAAA,EAAAthC,KAAA,EAAA88B,iBAAA;;AAAA,YAAGjF,IAAInuB,KAAJ,KAAa,WAAhB;AACC1J,kBAAQ63B,IAAI5pB,cAAJ,IAAsB,UAA9B;ACiBK;;ADfN6uB,4BAAoBjF,IAAIkF,iBAAJ,IAAyB,EAA7C;AAEAuE,iBAAS,EAAT;;AAEA,YAAGzJ,IAAIc,QAAJ,GAAe,CAAlB;AACC2I,mBAASt7B,QAAQC,EAAR,CAAW,QAAX,CAAT;ACeK;;ADbN,eAAO,qCAC2BjG,KAD3B,GACiC,KADjC,GACqC88B,iBADrC,GACyDwE,MADzD,GACgE,QADvE;AAdF;AAiBCD,eAAS,KAjBV;AAkBC1E,iBAAW;AAlBZ,KApIQ,EAwJR;AACCzwC,YAAM,UADP;AAECwwC,aAAOrqC,EAAE,oBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,eAAOztB,OAAOytB,IAAIh4B,QAAX,EAAqBwK,MAArB,CAA4B,kBAA5B,CAAP;AAJF;AAMCg3B,eAAS,KANV;AAOC1E,iBAAW;AAPZ,KAxJQ,EAiKR;AACCzwC,YAAM,YADP;AAECwwC,aAAOrqC,EAAE,sBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAGA,IAAI54B,UAAP;AACC,iBAAOmL,OAAOytB,IAAI54B,UAAX,EAAuBoL,MAAvB,CAA8B,kBAA9B,CAAP;ACYK;ADjBR;AAOCg3B,eAAS,KAPV;AAQC1E,iBAAW;AARZ,KAjKQ,EA2KR;AACCzwC,YAAM,gBADP;AAEC0wC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAGA,IAAIY,cAAP;AACC,iBAAOruB,OAAOytB,IAAIY,cAAX,EAA2BpuB,MAA3B,CAAkC,kBAAlC,CAAP;ACYK;ADhBR;AAMCg3B,eAAS,KANV;AAOC1E,iBAAW;AAPZ,KA3KQ,EAoLR;AACCzwC,YAAM,UADP;AAECm1C,eAAS;AAFV,KApLQ,EAwLR;AACCn1C,YAAM,UADP;AAECm1C,eAAS;AAFV,KAxLQ,EA4LR;AACCn1C,YAAM,aADP;AAEC0wC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAAl6B,GAAA;;AAAA,aAAAk6B,OAAA,QAAAl6B,MAAAk6B,IAAAv4B,MAAA,YAAA3B,IAAgB4jC,WAAhB,GAAgB,MAAhB,GAAgB,MAAhB,KAA+B1J,IAAIv4B,MAAJ,CAAWiiC,WAAX,KAA0B,MAAzD;AACC,cAAA1J,OAAA,OAAGA,IAAKx2B,WAAR,GAAQ,MAAR;AACC,mBAAOhP,EAAE,KAAF,CAAP;ACWM;;ADVP,iBAAOA,EAAE,IAAF,CAAP;ACYK;ADlBR;AAOCgvC,eAAS,KAPV;AAQC1E,iBAAW;AARZ,KA5LQ,CAxDA;AA+PTK,SAAQ;AAEP,UAAG34B,QAAQ0J,QAAR,EAAH;ACaK,eDZJ,ICYI;ADbL;ACeK,eDZJ,KCYI;AACD;ADlBG,OA/PC;AAqQTiM,WAAO,CAAC,CAAC,CAAD,EAAI,MAAJ,CAAD,CArQE;AAsQTkjB,iBAAa,CAAC,MAAD,EAAS,MAAT,EAAiB,aAAjB,EAAgC,OAAhC,EAAyC,OAAzC,EAAkD,WAAlD,EAA+D,cAA/D,EACZ,cADY,EACI,OADJ,EACa,UADb,EACyB,SADzB,EACoC,mBADpC,EACyD,QADzD,EACmE,UADnE,EAC+E,gBAD/E,EACiG,WADjG,EAC8G,WAD9G,EAC2H,iBAD3H,CAtQJ;AAwQTD,kBAAc,IAxQL;AAyQTuE,gBAAY,CAAC,EAAD,EAAI,EAAJ,EAAO,EAAP,EAAU,EAAV,EAAa,EAAb,EAAgB,GAAhB,CAzQH;AA0QTrE,gBAAY,EA1QH;AA2QTC,UAAM,KA3QG;AA4QTC,eAAW,IA5QF;AA6QTC,gBACC;AAAAC,eAAS;AAAT,KA9QQ;AA+QTC,eAAW,KA/QF;AAgRTC,oBAAgB,UAAC1d,QAAD,EAAW3H,MAAX;AACf,UAAAza,GAAA,EAAAyC,KAAA,EAAAqhC,UAAA;;AAAA,WAAOrpB,MAAP;AACC,eAAO;AAAC7a,eAAK,CAAC;AAAP,SAAP;ACkBG;;ADjBJ6C,cAAQ2f,SAAS3f,KAAjB;;AACA,WAAOA,KAAP;AACC,aAAA2f,YAAA,QAAApiB,MAAAoiB,SAAA4d,IAAA,YAAAhgC,IAAmBlT,MAAnB,GAAmB,MAAnB,GAAmB,MAAnB,IAA4B,CAA5B;AACC2V,kBAAQ2f,SAAS4d,IAAT,CAAc73B,WAAd,CAA0B,OAA1B,EAAmC,CAAnC,CAAR;AAFF;ACsBI;;ADnBJ,WAAO1F,KAAP;AACC,eAAO;AAAC7C,eAAK,CAAC;AAAP,SAAP;ACuBG;;ADtBJkkC,mBAAarkC,GAAG4yB,WAAH,CAAe1yB,OAAf,CAAuB;AAACoB,cAAM0Z,MAAP;AAAehY,eAAOA;AAAtB,OAAvB,EAAqD;AAACtD,gBAAQ;AAACS,eAAK;AAAN;AAAT,OAArD,CAAb;;AACA,WAAOkkC,UAAP;AACC,eAAO;AAAClkC,eAAK,CAAC;AAAP,SAAP;ACiCG;;ADhCJ,aAAOwiB,QAAP;AA5RQ;AA6RT2hB,gBAAY;AA7RH,GAAV;;AA0SA,MAAGlT,MAAH;AACCh7B,UAAM,iBAAiBg7B,MAAvB;AAEAj6B,YAAQvB,IAAR,GAAeQ,GAAf;AAEA4oC,kBAAcpd,SAAd,CAAwBliB,MAAxB,GAAiCA,MAAjC;AAEA2hC,iBAAaP,kBAAkB9B,cAAcpd,SAAd,CAAwBliB,MAA1C,CAAb;AAEA2hC,eAAWhhC,OAAX,CAAmB,UAACC,CAAD;AAClB,UAAGA,EAAEnO,IAAF,KAAU,OAAV,IAAqBmO,EAAEikC,eAA1B;ACoBK,eDnBJptC,QAAQkoC,OAAR,CAAgBxpC,IAAhB,CACC;AAAA/G,gBAAOwR,EAAE1K,IAAF,IAAU0K,EAAEmK,IAAnB;AACA60B,iBAAOrqC,EAAEqL,EAAE1K,IAAF,IAAU0K,EAAEmK,IAAd,CADP;AAEAw5B,mBAAS,KAFT;AAGA1E,qBAAW,KAHX;AAIAC,kBAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AAEP,gBAAAnsC,KAAA,EAAA4T,MAAA;AAAAA,qBAASu4B,IAAIv4B,MAAJ,IAAc,EAAvB;AAEA5T,oBAAQ4T,OAAO5B,EAAEmK,IAAT,CAAR;;AAEA,oBAAOnK,EAAEnO,IAAT;AAAA,mBACM,MADN;AAEE7D,iCAAA,OAAQA,MAAOsH,IAAf,GAAe,MAAf;AADI;;AADN,mBAGM,OAHN;AAIEtH,iCAAA,OAAQA,MAAOqa,QAAf,GAAe,MAAf;AADI;;AAHN,mBAKM,MALN;AAME,oBAAGra,KAAH;AACCA,0BAAQ0e,OAAO1e,KAAP,EAAc2e,MAAd,CAAqB,YAArB,CAAR;ACoBQ;;ADtBL;;AALN,mBAQM,UARN;AASE,oBAAG3e,KAAH;AACCA,0BAAQ0e,OAAO1e,KAAP,EAAc2e,MAAd,CAAqB,kBAArB,CAAR;ACsBQ;;ADxBL;;AARN,mBAWM,UAXN;AAYE,oBAAG3e,UAAS,IAAT,IAAiBA,UAAS,MAA7B;AACCA,0BAAQsa,QAAQC,EAAR,CAAW,yBAAX,CAAR;AADD;AAGCva,0BAAQsa,QAAQC,EAAR,CAAW,wBAAX,CAAR;ACwBQ;;AD5BL;;AAXN,mBAgBM,OAhBN;AAiBE,oBAAGva,KAAH;AACC,sBAAGsS,EAAEjS,OAAF,CAAUL,KAAV,CAAH;AACCA,4BAAQsS,EAAEuY,KAAF,CAAQ7qB,KAAR,EAAe,QAAf,EAAyBE,QAAzB,EAAR;AADD;AAGCF,4BAAQA,MAAM,QAAN,CAAR;AAJF;AC+BS;;ADhDX;;AAuBA,mBAAOA,KAAP;AAjCD;AAAA,SADD,CCmBI;AA6CD;ADlEL;ACoEC;;AD7BF,SAAO6I,OAAP;AA3V2B,CAA5B;;AA+VA4pC,gCAAgC,UAAC3P,MAAD,EAAS1xB,MAAT;AAC/B,MAAA2hC,UAAA,EAAAjrC,GAAA,EAAAe,OAAA;AAAAA,YAAU;AACTvB,UAAM,gBADG;AAETwpC,gBAAYp/B,GAAGe,cAFN;AAGTugC,SAAK,wBAHI;AAITC,cAAU;AC+BN,aD9BH3hC,OAAOwX,UAAP,CAAkBxR,SAAS47B,aAAT,CAAuBC,aAAzC,EAAwD,GAAxD,CC8BG;ADnCK;AAOTC,kBAAc,UAACnxB,QAAD;AACb,UAAAoxB,YAAA,EAAAC,OAAA,EAAAtC,KAAA;AAAAsC,gBAAU7sB,EAAE,mBAAF,CAAV;;AACA,UAAG6sB,QAAQv0C,MAAX;AACCu0C,gBAAQ,CAAR,EAAWC,OAAX,GAAqB,GAArB;ACgCG;;AD/BJ,UAAG,CAAC56B,QAAQ0J,QAAR,EAAD,IAAuB,CAAC1J,QAAQ66B,KAAR,EAA3B;AACCliC,eAAOwX,UAAP,CAAkBxR,SAAS47B,aAAT,CAAuBC,aAAzC,EAAwD,GAAxD;AACA1sB,UAAE,gBAAF,EAAoBuW,SAApB,CAA8B,CAA9B,EAAiC0L,KAAjC,CAAuC;ACiCjC,iBDhCLjiB,EAAE,gBAAF,EAAoBgtB,gBAApB,CAAqC,QAArC,CCgCK;ADjCN;AAFD;AAKChtB,UAAE,gBAAF,EAAoBuW,SAApB,CAA8B,CAA9B;ACkCG;;ADhCJgU,cAAQrqC,EAAE,kBAAF,CAAR;AACA0sC,qBAAepxB,SAASyxB,SAAT,CAAmB7e,MAAnB,GAA4Bla,IAA5B,CAAiC,yCAAjC,CAAf;ACkCG,aDjCH04B,aAAaM,IAAb,CAAkB,OAAlB,EAA2B3C,KAA3B,EAAkC7K,GAAlC,CAAsC,QAAtC,EAAgD,SAAhD,EAA2DyN,KAA3D,CAAiE;AAChE,YAAAC,MAAA,EAAA1C,KAAA;;AAAA,YAAG,CAAC1qB,EAAE,IAAF,EAAQ9L,IAAR,CAAa,OAAb,EAAsB5b,MAA1B;AACCoyC,kBAAQ1qB,EAAE,wGAAF,CAAR;;AACA,cAAG9N,QAAQ0J,QAAR,EAAH;AACC8uB,kBAAMhL,GAAN,CAAU;AACTnkB,qBAAM,MADG;AAET8xB,sBAAQ;AAFC,aAAV;AADD;AAMC3C,kBAAMhL,GAAN,CAAU;AACTnkB,qBAAM,MADG;AAET8xB,sBAAQ;AAFC,aAAV;ACsCK;;ADlCN3C,gBAAMwC,IAAN,CAAW,OAAX,EAAoB3C,KAApB,EAA2B2C,IAA3B,CAAgC,aAAhC,EAA+C3C,KAA/C;AACAvqB,YAAE,IAAF,EAAQ8B,KAAR,GAAgBP,MAAhB,CAAuBmpB,KAAvB;;AACA0C,mBAAS,UAACzqC,KAAD;AACR,gBAAA2qC,KAAA;;AAAA,gBAAG3qC,QAAQ,CAAX;AACC2qC,sBAAQtrC,KAAKurC,IAAL,CAAU/xB,SAASgyB,gBAAT,KAA8BhyB,SAASiyB,eAAjD,CAAR;;AACA,kBAAG9qC,QAAQ2qC,KAAX;AAEC3qC,wBAAQ2qC,KAAR;ACoCO;;ADnCR3qC;ACqCO,qBDpCP6Y,SAASyxB,SAAT,CAAmBS,SAAnB,GAA+BC,IAA/B,CAAoChrC,KAApC,EAA2CirC,IAA3C,CAAgD,MAAhD,CCoCO;AACD;AD5CC,WAAT;;AAQAlD,gBAAMmD,IAAN,CAAW,UAACrvC,CAAD;AACV,gBAAAsvC,WAAA;AAAAA,0BAAc9tB,EAAE,IAAF,EAAQvD,GAAR,EAAd;AACA2wB,mBAAOU,WAAP;ACwCM,mBDvCN9tB,EAAE,IAAF,EAAQoO,MAAR,GAAiBxT,IAAjB,CAAsB,KAAtB,CCuCM;AD1CP;AC4CK,iBDxCL8vB,MAAMqD,OAAN,CAAc,UAACvvC,CAAD;AACb,gBAAAsvC,WAAA;;AAAA,gBAAGtvC,EAAEwvC,OAAF,CAAUv0C,QAAV,OAAwB,IAA3B;AACCq0C,4BAAc9tB,EAAE,IAAF,EAAQvD,GAAR,EAAd;AC0CO,qBDzCP2wB,OAAOU,WAAP,CCyCO;AACD;AD7CR,YCwCK;AAOD;AD1EN,QCiCG;ADrDK;AAoDTG,gBAAY,UAACC,GAAD,EAAMn0C,IAAN,EAAYo0C,SAAZ;AACX,UAAGtjC,OAAO2J,QAAV;AACC,YAAGza,KAAKqS,QAAL,KAAiBgiC,WAAWt4B,OAAX,GAAqB8lB,MAArB,CAA4Bxd,UAAhD;AC8CM,iBD7CL8vB,IAAIG,YAAJ,CAAiB,OAAjB,EAA0B,UAA1B,CC6CK;AD/CP;ACiDI;ADtGI;AAwDT/D,aAAS,CACR;AACCvwC,YAAM,KADP;AAECywC,iBAAW,KAFZ;AAGCC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAA4I,UAAA,EAAAC,OAAA,EAAA7/B,SAAA,EAAA8/B,yBAAA,EAAA9gC,QAAA,EAAA+gC,eAAA,EAAAC,cAAA,EAAAC,YAAA,EAAAC,iBAAA,EAAAC,aAAA,EAAArjC,GAAA,EAAAsjC,sBAAA,EAAAC,MAAA;AAAAL,yBAAiBz2B,OAAOytB,IAAIh4B,QAAX,EAAqBwK,MAArB,CAA4B,YAA5B,CAAjB;AAEAxK,mBAAWg4B,IAAIh4B,QAAf;;AACA,YAAGiR,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAI52B,cAAJ,KAAsB,OAA1D;AACCpB,qBAAWg4B,IAAI54B,UAAJ,IAAkB44B,IAAIh4B,QAAjC;ACiDK;;AD/CN,YAAGiR,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,QAAzB;AACC6H,qBAAWg4B,IAAIl3B,WAAJ,IAAmBk3B,IAAIh4B,QAAlC;ACiDK;;AD/CN+gC,0BAAkBv8B,QAAQ88B,qBAAR,CAA8BthC,QAA9B,CAAlB;AACAgB,oBAAYg3B,IAAIh3B,SAAhB;AACA6/B,kBAAU,EAAV;AACAO,iCAAyB,EAAzB;;AAEA,YAAGpJ,IAAItoC,IAAJ,KAAY,IAAZ,IAAoBuhB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAA7C;AACC0oC,oBAAU,8BAA8B16B,QAAQC,EAAR,CAAW,mBAAX,CAA9B,GAAgE,YAA1E;AACAg7B,mCAAyB,4BAA0BpgC,SAA1B,GAAoC,SAApC,GAA6Cg3B,IAAI92B,SAAjD,GAA2D,gBAApF;AAFD;AAIC,cAAG82B,IAAI92B,SAAP;AACCkgC,qCAAyB,4BAA0BpgC,SAA1B,GAAoC,SAApC,GAA6Cg3B,IAAI92B,SAAjD,GAA2D,gBAApF;AADD;AAGCkgC,qCAAyB,4BAA0BpgC,SAA1B,GAAoC,QAA7D;AAPF;ACwDM;;AD/CN4/B,qBAAa,EAAb;;AACA,YAAG5I,IAAIW,eAAJ,IAAuB1nB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAhD;AACCyoC,uBAAa,8BAA8Bz6B,QAAQC,EAAR,CAAW,sCAAX,EAAmD;AAACmhB,sBAAUyQ,IAAIW;AAAf,WAAnD,CAA9B,GAAoH,WAAjI;ACmDK;;ADjDN0I,iBAAS,EAAT;;AAEA,YAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAIz4B,OAAJ,KAAe,KAAnD;AACC8hC,mBAAS,uCAAT;AADD,eAEK,IAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,SAAtB,IAAmC6/B,IAAI3I,SAAJ,KAAiB,IAAvD;AACJgS,mBAAS,4BAAT;ACkDK;;ADhDNJ,uBAAe,EAAf;AACAC,4BAAoB,EAApB;AACAC,wBAAA,CAAArjC,MAAAk6B,IAAAv4B,MAAA,YAAA3B,IAA4ByjC,QAA5B,GAA4B,MAA5B;;AACA,gBAAOJ,aAAP;AAAA,eACM,IADN;AAEED,gCAAoB,QAApB;AADI;;AADN,eAGM,IAHN;AAIEA,gCAAoB,SAApB;AADI;;AAHN,eAKM,IALN;AAMEA,gCAAoB,OAApB;AANF;;AAOA,YAAGA,iBAAH;AACCJ,sCAA4B,mCAAiCI,iBAA7D;ACqDK;;ADnDN,eAAO,oCAC6BG,MAD7B,GACoC,oCADpC,GAEwBP,yBAFxB,GAEkD,IAFlD,GAEsD9I,IAAIx3B,aAF1D,GAE0EqgC,OAF1E,GAEoFD,UAFpF,GAE+F,WAF/F,GAGK5I,IAAIp3B,cAHT,GAGwB,gDAHxB,GAK2BwgC,sBAL3B,GAKkD,4CALlD,GAMsCJ,cANtC,GAMqD,IANrD,GAMyDD,eANzD,GAMyE,iBANhF;AAnDF;AAAA,KADQ,EA8DR;AACC10C,YAAM,6BADP;AAECwwC,aAAOrqC,EAAE,uCAAF,CAFR;AAGCgvC,eAAS;AAHV,KA9DQ,EAmER;AACCn1C,YAAM,eADP;AAECwwC,aAAOrqC,EAAE,gBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAA4I,UAAA,EAAAC,OAAA,EAAAC,yBAAA,EAAAI,iBAAA,EAAAC,aAAA,EAAArjC,GAAA,EAAA+K,IAAA,EAAAu4B,sBAAA,EAAAC,MAAA;AAAAR,kBAAU,EAAV;AACAO,iCAAyB,EAAzB;;AAEA,YAAGpJ,IAAIa,KAAJ,IAAa,GAAA/6B,MAAAk6B,IAAAT,WAAA,YAAAz5B,IAAkBiS,QAAlB,CAA2B5S,OAAOob,MAAP,EAA3B,IAAC,MAAD,CAAb,IAA4DtH,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAArF;AACC0oC,oBAAU,8BAA8B16B,QAAQC,EAAR,CAAW,mBAAX,CAA9B,GAAgE,YAA1E;AC4CK;;AD1CNw6B,qBAAa,EAAb;;AACA,YAAG5I,IAAIW,eAAP;AACCiI,uBAAa,8BAA8Bz6B,QAAQC,EAAR,CAAW,sCAAX,EAAmD;AAACmhB,sBAAUyQ,IAAIW;AAAf,WAAnD,CAA9B,GAAoH,WAAjI;AC8CK;;AD5CN0I,iBAAS,EAAT;;AAEA,YAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAtB,IAAiC6/B,IAAIz4B,OAAJ,KAAe,KAAnD;AACC8hC,mBAAS,uCAAT;AADD,eAEK,IAAGpwB,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,SAAtB,IAAmC6/B,IAAI3I,SAAJ,KAAiB,IAAvD;AACJgS,mBAAS,4BAAT;AC6CK;;AD3CNH,4BAAoB,EAApB;AACAC,wBAAA,CAAAt4B,OAAAmvB,IAAAv4B,MAAA,YAAAoJ,KAA4B04B,QAA5B,GAA4B,MAA5B;;AACA,gBAAOJ,aAAP;AAAA,eACM,IADN;AAEED,gCAAoB,QAApB;AADI;;AADN,eAGM,IAHN;AAIEA,gCAAoB,SAApB;AADI;;AAHN,eAKM,IALN;AAMEA,gCAAoB,OAApB;AANF;;AAOA,YAAGA,iBAAH;AACCJ,sCAA4B,mCAAiCI,iBAA7D;ACgDK;;AD/CN,eAAO,oCAC4BG,MAD5B,GACmC,oCADnC,GAEuBP,yBAFvB,GAEiD,IAFjD,GAEqD9I,IAAIx3B,aAFzD,GAEyEqgC,OAFzE,GAEmFD,UAFnF,GAE8F,QAFrG;AAhCF;AAoCCY,eAAS,KApCV;AAqCC1E,iBAAW;AArCZ,KAnEQ,EA0GR;AACCzwC,YAAM,gBADP;AAECwwC,aAAOrqC,EAAE,0BAAF,CAFR;AAGCgvC,eAAS,KAHV;AAIC1E,iBAAW;AAJZ,KA1GQ,EAgHR;AACCzwC,YAAM,aADP;AAECwwC,aAAOrqC,EAAE,uBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAGA,IAAIl3B,WAAP;AACC,iBAAOyJ,OAAOytB,IAAIl3B,WAAX,EAAwB0J,MAAxB,CAA+B,kBAA/B,CAAP;AC6CK;ADlDR;AAOCg3B,eAAS,KAPV;AAQC1E,iBAAW;AARZ,KAhHQ,EA0HR;AACCzwC,YAAM,WADP;AAECwwC,aAAOrqC,EAAE,gBAAF,CAFR;AAGCgvC,eAAS,KAHV;AAIC1E,iBAAW;AAJZ,KA1HQ,EAgIR;AACCzwC,YAAM,WADP;AAECwwC,aAAOrqC,EAAE,6BAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAAyJ,MAAA,EAAAthC,KAAA,EAAA88B,iBAAA;;AAAA,YAAGjF,IAAI52B,cAAJ,KAAsB,WAAzB;AACCjB,kBAAQ63B,IAAI73B,KAAJ,IAAa,UAArB;AC6CK;;AD3CN88B,4BAAoBjF,IAAI92B,SAAJ,IAAiB,EAArC;AAEAugC,iBAAS,EAAT;;AAEA,YAAGzJ,IAAIc,QAAJ,GAAe,CAAlB;AACC2I,mBAASt7B,QAAQC,EAAR,CAAW,QAAX,CAAT;AC2CK;;ADzCN,eAAO,qCAC2BjG,KAD3B,GACiC,KADjC,GACqC88B,iBADrC,GACyDwE,MADzD,GACgE,QADvE;AAdF;AAiBCD,eAAS,KAjBV;AAkBC1E,iBAAW;AAlBZ,KAhIQ,EAoJR;AACCzwC,YAAM,UADP;AAECwwC,aAAOrqC,EAAE,oBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,eAAOztB,OAAOytB,IAAIh4B,QAAX,EAAqBwK,MAArB,CAA4B,kBAA5B,CAAP;AAJF;AAMCg3B,eAAS,KANV;AAOC1E,iBAAW;AAPZ,KApJQ,EA6JR;AACCzwC,YAAM,YADP;AAECwwC,aAAOrqC,EAAE,sBAAF,CAFR;AAGCuqC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAGA,IAAI54B,UAAP;AACC,iBAAOmL,OAAOytB,IAAI54B,UAAX,EAAuBoL,MAAvB,CAA8B,kBAA9B,CAAP;ACwCK;AD7CR;AAOCg3B,eAAS,KAPV;AAQC1E,iBAAW;AARZ,KA7JQ,EAuKR;AACCzwC,YAAM,aADP;AAEC0wC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAGA,IAAI33B,WAAP;AACC,iBAAOkK,OAAOytB,IAAI33B,WAAX,EAAwBmK,MAAxB,CAA+B,kBAA/B,CAAP;ACwCK;AD5CR;AAMCg3B,eAAS,KANV;AAOC1E,iBAAW;AAPZ,KAvKQ,EAgLR;AACCzwC,YAAM,UADP;AAECm1C,eAAS;AAFV,KAhLQ,EAoLR;AACCn1C,YAAM,UADP;AAECm1C,eAAS;AAFV,KApLQ,EAwLR;AACCn1C,YAAM,aADP;AAEC0wC,cAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AACP,YAAAl6B,GAAA;;AAAA,aAAAk6B,OAAA,QAAAl6B,MAAAk6B,IAAAv4B,MAAA,YAAA3B,IAAgB4jC,WAAhB,GAAgB,MAAhB,GAAgB,MAAhB,KAA+B1J,IAAIv4B,MAAJ,CAAWiiC,WAAX,KAA0B,MAAzD;AACC,cAAA1J,OAAA,OAAGA,IAAKx2B,WAAR,GAAQ,MAAR;AACC,mBAAOhP,EAAE,KAAF,CAAP;ACuCM;;ADtCP,iBAAOA,EAAE,IAAF,CAAP;ACwCK;AD9CR;AAOCgvC,eAAS,KAPV;AAQC1E,iBAAW;AARZ,KAxLQ,CAxDA;AA2PTK,SAAQ;AAEP,UAAG34B,QAAQ0J,QAAR,EAAH;ACyCK,eDxCJ,ICwCI;ADzCL;AC2CK,eDxCJ,KCwCI;AACD;AD9CG,OA3PC;AAiQTiM,WAAO,CAAC,CAAC,CAAD,EAAI,MAAJ,CAAD,CAjQE;AAkQTkjB,iBAAa,CAAC,UAAD,EAAa,MAAb,EAAqB,MAArB,EAA6B,aAA7B,EAA4C,gBAA5C,EAA8D,OAA9D,EAAuE,WAAvE,EAAoF,cAApF,EACZ,cADY,EACI,MADJ,EACY,SADZ,EACuB,WADvB,EACoC,QADpC,EAC8C,UAD9C,EAC0D,gBAD1D,EAC4E,WAD5E,EACyF,WADzF,EACsG,iBADtG,CAlQJ;AAoQTD,kBAAc,IApQL;AAqQTuE,gBAAY,CAAC,EAAD,EAAI,EAAJ,EAAO,EAAP,EAAU,EAAV,EAAa,EAAb,EAAgB,GAAhB,CArQH;AAsQTrE,gBAAY,EAtQH;AAuQTC,UAAM,KAvQG;AAwQTC,eAAW,IAxQF;AAyQTC,gBACC;AAAAC,eAAS;AAAT,KA1QQ;AA2QTC,eAAW,KA3QF;AA4QTC,oBAAgB,UAAC1d,QAAD,EAAW3H,MAAX;AACf,UAAAza,GAAA,EAAAyC,KAAA,EAAAqhC,UAAA;;AAAA,WAAOrpB,MAAP;AACC,eAAO;AAAC7a,eAAK,CAAC;AAAP,SAAP;AC8CG;;AD7CJ6C,cAAQ2f,SAAS3f,KAAjB;;AACA,WAAOA,KAAP;AACC,aAAA2f,YAAA,QAAApiB,MAAAoiB,SAAA4d,IAAA,YAAAhgC,IAAmBlT,MAAnB,GAAmB,MAAnB,GAAmB,MAAnB,IAA4B,CAA5B;AACC2V,kBAAQ2f,SAAS4d,IAAT,CAAc73B,WAAd,CAA0B,OAA1B,EAAmC,CAAnC,CAAR;AAFF;ACkDI;;AD/CJ,WAAO1F,KAAP;AACC,eAAO;AAAC7C,eAAK,CAAC;AAAP,SAAP;ACmDG;;ADlDJkkC,mBAAarkC,GAAG4yB,WAAH,CAAe1yB,OAAf,CAAuB;AAACoB,cAAM0Z,MAAP;AAAehY,eAAOA;AAAtB,OAAvB,EAAqD;AAACtD,gBAAQ;AAACS,eAAK;AAAN;AAAT,OAArD,CAAb;;AACA,WAAOkkC,UAAP;AACC,eAAO;AAAClkC,eAAK,CAAC;AAAP,SAAP;AC6DG;;AD5DJ,aAAOwiB,QAAP;AAxRQ;AAyRT2hB,gBAAY;AAzRH,GAAV;;AA6RA,MAAGlT,MAAH;AACCh7B,UAAM,iBAAiBg7B,MAAvB;AAEAj6B,YAAQvB,IAAR,GAAeQ,GAAf;AAEA4oC,kBAAcj+B,cAAd,CAA6BrB,MAA7B,GAAsCA,MAAtC;AAEA2hC,iBAAaP,kBAAkB9B,cAAcj+B,cAAd,CAA6BrB,MAA/C,CAAb;AAEA2hC,eAAWhhC,OAAX,CAAmB,UAACC,CAAD;AAClB,UAAGA,EAAEnO,IAAF,KAAU,OAAV,IAAqBmO,EAAEikC,eAA1B;ACyDK,eDxDJptC,QAAQkoC,OAAR,CAAgBxpC,IAAhB,CACC;AAAA/G,gBAAOwR,EAAE1K,IAAF,IAAU0K,EAAEmK,IAAnB;AACA60B,iBAAOrqC,EAAEqL,EAAE1K,IAAF,IAAU0K,EAAEmK,IAAd,CADP;AAEAw5B,mBAAS,KAFT;AAGA1E,qBAAW,KAHX;AAIAC,kBAAQ,UAAChuB,GAAD,EAAMrf,IAAN,EAAYsoC,GAAZ;AAEP,gBAAAnsC,KAAA,EAAA4T,MAAA;AAAAA,qBAASu4B,IAAIv4B,MAAJ,IAAc,EAAvB;AAEA5T,oBAAQ4T,OAAO5B,EAAEmK,IAAT,CAAR;;AAEA,oBAAOnK,EAAEnO,IAAT;AAAA,mBACM,MADN;AAEE7D,iCAAA,OAAQA,MAAOsH,IAAf,GAAe,MAAf;AADI;;AADN,mBAGM,OAHN;AAIEtH,iCAAA,OAAQA,MAAOqa,QAAf,GAAe,MAAf;AADI;;AAHN,mBAKM,MALN;AAME,oBAAGra,KAAH;AACCA,0BAAQ0e,OAAO1e,KAAP,EAAc2e,MAAd,CAAqB,YAArB,CAAR;ACyDQ;;AD3DL;;AALN,mBAQM,UARN;AASE,oBAAG3e,KAAH;AACCA,0BAAQ0e,OAAO1e,KAAP,EAAc2e,MAAd,CAAqB,kBAArB,CAAR;AC2DQ;;AD7DL;;AARN,mBAWM,UAXN;AAYE,oBAAG3e,UAAS,IAAT,IAAiBA,UAAS,MAA7B;AACCA,0BAAQsa,QAAQC,EAAR,CAAW,yBAAX,CAAR;AADD;AAGCva,0BAAQsa,QAAQC,EAAR,CAAW,wBAAX,CAAR;AC6DQ;;ADjEL;;AAXN,mBAgBM,OAhBN;AAiBE,oBAAGva,KAAH;AACC,sBAAGsS,EAAEjS,OAAF,CAAUL,KAAV,CAAH;AACCA,4BAAQsS,EAAEuY,KAAF,CAAQ7qB,KAAR,EAAe,QAAf,EAAyBE,QAAzB,EAAR;AADD;AAGCF,4BAAQA,MAAM,QAAN,CAAR;AAJF;ACoES;;ADrFX;;AAuBA,mBAAOA,KAAP;AAjCD;AAAA,SADD,CCwDI;AA6CD;ADvGL;ACyGC;;ADlEF,SAAO6I,OAAP;AA9U+B,CAAhC;;AAiVAyI,OAAO68B,OAAP,CAAe;AACduC,gBAAcpd,SAAd,GAA0B,IAAIsd,QAAQC,KAAZ,CAAkB6B,2BAAlB,CAA1B;AACAhC,gBAAcj+B,cAAd,GAA+B,IAAIm+B,QAAQC,KAAZ,CAAkB4B,+BAAlB,CAA/B;AACA/B,gBAAcwF,eAAd,GAAgC,IAAItF,QAAQC,KAAZ,CAAkBwB,8BAA8B,OAA9B,CAAlB,CAAhC;ACoEC,SDnED3B,cAAcyF,gBAAd,GAAiC,IAAIvF,QAAQC,KAAZ,CAAkBwB,8BAA8B,QAA9B,CAAlB,CCmEhC;ADvEF;;AAOAA,gCAAgC,UAAC5sB,GAAD,EAAMqd,MAAN,EAAc1xB,MAAd;AAC/B,MAAAtJ,GAAA,EAAAe,OAAA;AAAAf,QAAM,iBAAiB2d,GAAjB,GAAuBqd,MAA7B;;AACA,MAAGrd,QAAO,OAAV;AACC5c,cAAUypC,qCAAqCxP,MAArC,EAA6C1xB,MAA7C,CAAV;AADD,SAEK,IAAGqU,QAAO,QAAV;AACJ5c,cAAU0pC,sCAAsCzP,MAAtC,EAA8C1xB,MAA9C,CAAV;AADI;AAGJvI,cAAU6pC,0BAA0B5P,MAA1B,EAAkC1xB,MAAlC,CAAV;;AACA,QAAG,CAAC0xB,MAAJ;AACCj6B,cAAQvB,IAAR,GAAe,iBAAf;AALG;AC2EH;;ADrEF,MAAGw7B,MAAH;AACCj6B,YAAQvB,IAAR,GAAeQ,GAAf;ACuEC;;ADtEF,SAAOe,OAAP;AAZ+B,CAAhC;;AAcAypC,uCAAuC,UAACxP,MAAD,EAAS1xB,MAAT;AACtC,MAAAvI,OAAA;AAAAA,YAAU4pC,8BAA8B3P,MAA9B,EAAsC1xB,MAAtC,CAAV;;AAEA,MAAG,CAAC0xB,MAAJ;AACCj6B,YAAQvB,IAAR,GAAe,iBAAf;ACyEC;;ADvEFuB,UAAQylB,KAAR,GAAgB,CAAC,CAAC,CAAD,EAAI,MAAJ,CAAD,CAAhB;;AAEAzlB,UAAQutC,OAAR,GAAkB,UAAC/hB,QAAD,EAAWhzB,IAAX;AACjB6Q,YAAQC,GAAR,CAAY,kBAAZ,EAA+B9Q,IAA/B;AACA,WAAOA,IAAP;AAFiB,GAAlB;;AAIA,SAAOwH,OAAP;AAZsC,CAAvC;;AAcA0pC,wCAAwC,UAACzP,MAAD,EAAS1xB,MAAT;AACvC,MAAAvI,OAAA;AAAAA,YAAU4pC,8BAA8B3P,MAA9B,EAAsC1xB,MAAtC,CAAV;;AAEA,MAAG,CAAC0xB,MAAJ;AACCj6B,YAAQvB,IAAR,GAAe,kBAAf;ACyEC;;ADvEFuB,UAAQylB,KAAR,GAAgB,CAAC,CAAC,CAAD,EAAI,CAAC,CAAL,CAAD,CAAhB;;AAEAzlB,UAAQutC,OAAR,GAAkB,UAAC/hB,QAAD,EAAWhzB,IAAX;AACjB6Q,YAAQC,GAAR,CAAY,mBAAZ,EAAgC9Q,IAAhC;AAQA,WAAOA,IAAP;AATiB,GAAlB;;AAWA,SAAOwH,OAAP;AAnBuC,CAAxC;;AAqBA,IAAGyI,OAAO2J,QAAV;AACCy1B,gBAAc2F,aAAd,GAA8B,IAAIC,WAAJ,EAA9B;ACkEA;;ADhEDhlC,OAAO68B,OAAP,CAAe;ACmEb,SDlEDtR,QAAQtQ,OAAR,CAAgB,UAAClnB,CAAD;AACf,QAAGiM,OAAO2J,QAAP,IAAmB,CAACtC,QAAQ0J,QAAR,EAAvB;AACC,UAAG+C,QAAQ9Y,GAAR,CAAY,QAAZ,KAAyB8Y,QAAQ9Y,GAAR,CAAY,KAAZ,MAAsB,OAAlD;ACmEK,eDlEJgF,OAAOnR,IAAP,CAAY,yBAAZ,EAAuCilB,QAAQ9Y,GAAR,CAAY,KAAZ,CAAvC,EAA2D8Y,QAAQ9Y,GAAR,CAAY,QAAZ,CAA3D,EAAkF,UAAC4N,KAAD,EAAQxQ,MAAR;AACjFipC,kCAAwBvtB,QAAQ9Y,GAAR,CAAY,KAAZ,CAAxB,EAA4C8Y,QAAQ9Y,GAAR,CAAY,QAAZ,CAA5C,EAAmE5C,MAAnE;ACmEK,iBDlEL4N,SAAS47B,aAAT,CAAuBqD,YAAvB,ECkEK;ADpEN,UCkEI;ADpEN;ACyEG;AD1EJ,ICkEC;ADnEF;;AASA5D,0BAA0B,UAACltB,GAAD,EAAMqd,MAAN,EAAc1xB,MAAd;AACzB,MAAA8D,IAAA,EAAApN,GAAA,EAAAmK,GAAA,EAAA+K,IAAA,EAAAwQ,IAAA;;AAAA,MAAG,CAACpc,MAAJ;AACC8D,WAAOxD,GAAGkL,KAAH,CAAShL,OAAT,CAAiB;AAACC,WAAKixB;AAAN,KAAjB,EAAgC;AAAC1xB,cAAQ;AAACJ,cAAM;AAAP;AAAT,KAAhC,CAAP;AACAI,aAAA,CAAAa,MAAAP,GAAAC,KAAA,CAAAC,OAAA;AC8EIC,WAAKqD,QAAQ,IAAR,GAAeA,KAAKlE,IAApB,GAA2B,KAAK;AD9EzC,OC+EK;AACDI,cAAQ;AACN,0BAAkB;AADZ;AADP,KD/EL,MCmFS,IDnFT,GCmFgB,CAAC4L,OAAO/K,IAAIsK,OAAZ,KAAwB,IAAxB,GAA+BS,KDnF+C5L,MCmF9E,GDnF8E,MAA9F,GAA8F,MAA9F;ACoFC;;ADlFFA,WAASohC,kBAAkBphC,MAAlB,CAAT;;AAEA,OAAAA,UAAA,QAAAoc,OAAApc,OAAAyY,cAAA,qCAAA2D,KAAoDzuB,MAApD,GAAoD,MAApD,GAAoD,MAApD,IAA6D,CAA7D;AACC+I,UAAM,iBAAiB2d,GAAjB,GAAuBqd,MAA7B;;AACA,QAAGxxB,OAAO2J,QAAV;AACCy1B,oBAAc2F,aAAd,CAA4BrqB,GAA5B,CAAgC,IAAI4kB,QAAQC,KAAZ,CAAkBwB,8BAA8B5sB,GAA9B,EAAmCqd,MAAnC,EAA2C1xB,MAA3C,CAAlB,CAAhC;AADD;AAGC,UAAIw/B,QAAQC,KAAZ,CAAkBwB,8BAA8B5sB,GAA9B,EAAmCqd,MAAnC,EAA2C1xB,MAA3C,CAAlB;ACmFE;;AACD,WDnFFc,QAAQC,GAAR,CAAY,oBAAZ,EAAkCrK,GAAlC,CCmFE;AACD;ADjGuB,CAA1B;;AAeA,IAAGwJ,OAAOC,QAAV;AACCD,SAAOstB,OAAP,CACC;AAAA+T,6BAAyB,UAACltB,GAAD,EAAMqd,MAAN;AACxB,UAAA1xB,MAAA,EAAA8D,IAAA,EAAAjD,GAAA,EAAA+K,IAAA;AAAA21B,8BAAwBltB,GAAxB,EAA6Bqd,MAA7B;AAEA5tB,aAAOxD,GAAGkL,KAAH,CAAShL,OAAT,CAAiB;AAACC,aAAKixB;AAAN,OAAjB,EAAgC;AAAC1xB,gBAAQ;AAACJ,gBAAM;AAAP;AAAT,OAAhC,CAAP;AACAI,eAAA,CAAAa,MAAAP,GAAAC,KAAA,CAAAC,OAAA;AC4FKC,aAAKqD,QAAQ,IAAR,GAAeA,KAAKlE,IAApB,GAA2B,KAAK;AD5F1C,SC6FM;AACDI,gBAAQ;AACN,4BAAkB;AADZ;AADP,OD7FN,MCiGU,IDjGV,GCiGiB,CAAC4L,OAAO/K,IAAIsK,OAAZ,KAAwB,IAAxB,GAA+BS,KDjG8C5L,MCiG7E,GDjG6E,MAA9F,GAA8F,MAA9F;AACA,aAAOA,MAAP;AALD;AAAA,GADD;AC0GA,C","file":"/packages/steedos_workflow.js","sourcesContent":["import { checkNpmVersions } from 'meteor/tmeasday:check-npm-versions';\ncheckNpmVersions({\n\t\"node-schedule\": \"^1.3.1\",\n\t\"xml2js\": \"^0.4.19\",\n}, 'steedos:workflow');","/*!\n * URI.js - Mutating URLs\n *\n * Version: 1.17.0\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/\n *\n * Licensed under\n * MIT License http://www.opensource.org/licenses/mit-license\n * GPL v3 http://opensource.org/licenses/GPL-3.0\n *\n */\n(function (root, factory) {\n\t'use strict';\n\t// https://github.com/umdjs/umd/blob/master/returnExports.js\n\t// if (typeof exports === 'object') {\n\t// // Node\n\t// module.exports = factory(require('./punycode'), require('./IPv6'), require('./SecondLevelDomains'));\n\t// } else\n\tif (typeof define === 'function' && define.amd) {\n\t\t// AMD. Register as an anonymous module.\n\t\tdefine(['./punycode', './IPv6', './SecondLevelDomains'], factory);\n\t} else {\n\t\t// Browser globals (root is window)\n\t\troot.URI = factory(root.punycode, root.IPv6, root.SecondLevelDomains, root);\n\t}\n}(this, function (punycode, IPv6, SLD, root) {\n\t'use strict';\n\t/*global location, escape, unescape */\n\t// FIXME: v2.0.0 renamce non-camelCase properties to uppercase\n\t/*jshint camelcase: false */\n\n\t// save current URI variable, if any\n\tvar _URI = root && root.URI;\n\n\tfunction URI(url, base) {\n\t\tvar _urlSupplied = arguments.length >= 1;\n\t\tvar _baseSupplied = arguments.length >= 2;\n\n\t\t// Allow instantiation without the 'new' keyword\n\t\tif (!(this instanceof URI)) {\n\t\t\tif (_urlSupplied) {\n\t\t\t\tif (_baseSupplied) {\n\t\t\t\t\treturn new URI(url, base);\n\t\t\t\t}\n\n\t\t\t\treturn new URI(url);\n\t\t\t}\n\n\t\t\treturn new URI();\n\t\t}\n\n\t\tif (url === undefined) {\n\t\t\tif (_urlSupplied) {\n\t\t\t\tthrow new TypeError('undefined is not a valid argument for URI');\n\t\t\t}\n\n\t\t\tif (typeof location !== 'undefined') {\n\t\t\t\turl = location.href + '';\n\t\t\t} else {\n\t\t\t\turl = '';\n\t\t\t}\n\t\t}\n\n\t\tthis.href(url);\n\n\t\t// resolve to base according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#constructor\n\t\tif (base !== undefined) {\n\t\t\treturn this.absoluteTo(base);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tURI.version = '1.17.0';\n\n\tvar p = URI.prototype;\n\tvar hasOwn = Object.prototype.hasOwnProperty;\n\n\tfunction escapeRegEx(string) {\n\t\t// https://github.com/medialize/URI.js/commit/85ac21783c11f8ccab06106dba9735a31a86924d#commitcomment-821963\n\t\treturn string.replace(/([.*+?^=!:${}()|[\\]\\/\\\\])/g, '\\\\$1');\n\t}\n\n\tfunction getType(value) {\n\t\t// IE8 doesn't return [Object Undefined] but [Object Object] for undefined value\n\t\tif (value === undefined) {\n\t\t\treturn 'Undefined';\n\t\t}\n\n\t\treturn String(Object.prototype.toString.call(value)).slice(8, -1);\n\t}\n\n\tfunction isArray(obj) {\n\t\treturn getType(obj) === 'Array';\n\t}\n\n\tfunction filterArrayValues(data, value) {\n\t\tvar lookup = {};\n\t\tvar i, length;\n\n\t\tif (getType(value) === 'RegExp') {\n\t\t\tlookup = null;\n\t\t} else if (isArray(value)) {\n\t\t\tfor (i = 0, length = value.length; i < length; i++) {\n\t\t\t\tlookup[value[i]] = true;\n\t\t\t}\n\t\t} else {\n\t\t\tlookup[value] = true;\n\t\t}\n\n\t\tfor (i = 0, length = data.length; i < length; i++) {\n\t\t\t/*jshint laxbreak: true */\n\t\t\tvar _match = lookup && lookup[data[i]] !== undefined\n\t\t\t\t|| !lookup && value.test(data[i]);\n\t\t\t/*jshint laxbreak: false */\n\t\t\tif (_match) {\n\t\t\t\tdata.splice(i, 1);\n\t\t\t\tlength--;\n\t\t\t\ti--;\n\t\t\t}\n\t\t}\n\n\t\treturn data;\n\t}\n\n\tfunction arrayContains(list, value) {\n\t\tvar i, length;\n\n\t\t// value may be string, number, array, regexp\n\t\tif (isArray(value)) {\n\t\t\t// Note: this can be optimized to O(n) (instead of current O(m * n))\n\t\t\tfor (i = 0, length = value.length; i < length; i++) {\n\t\t\t\tif (!arrayContains(list, value[i])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t}\n\n\t\tvar _type = getType(value);\n\t\tfor (i = 0, length = list.length; i < length; i++) {\n\t\t\tif (_type === 'RegExp') {\n\t\t\t\tif (typeof list[i] === 'string' && list[i].match(value)) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else if (list[i] === value) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n\n\tfunction arraysEqual(one, two) {\n\t\tif (!isArray(one) || !isArray(two)) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// arrays can't be equal if they have different amount of content\n\t\tif (one.length !== two.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tone.sort();\n\t\ttwo.sort();\n\n\t\tfor (var i = 0, l = one.length; i < l; i++) {\n\t\t\tif (one[i] !== two[i]) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tfunction trimSlashes(text) {\n\t\tvar trim_expression = /^\\/+|\\/+$/g;\n\t\treturn text.replace(trim_expression, '');\n\t}\n\n\tURI._parts = function() {\n\t\treturn {\n\t\t\tprotocol: null,\n\t\t\tusername: null,\n\t\t\tpassword: null,\n\t\t\thostname: null,\n\t\t\turn: null,\n\t\t\tport: null,\n\t\t\tpath: null,\n\t\t\tquery: null,\n\t\t\tfragment: null,\n\t\t\t// state\n\t\t\tduplicateQueryParameters: URI.duplicateQueryParameters,\n\t\t\tescapeQuerySpace: URI.escapeQuerySpace\n\t\t};\n\t};\n\t// state: allow duplicate query parameters (a=1&a=1)\n\tURI.duplicateQueryParameters = false;\n\t// state: replaces + with %20 (space in query strings)\n\tURI.escapeQuerySpace = true;\n\t// static properties\n\tURI.protocol_expression = /^[a-z][a-z0-9.+-]*$/i;\n\tURI.idn_expression = /[^a-z0-9\\.-]/i;\n\tURI.punycode_expression = /(xn--)/i;\n\t// well, 333.444.555.666 matches, but it sure ain't no IPv4 - do we care?\n\tURI.ip4_expression = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\n\t// credits to Rich Brown\n\t// source: http://forums.intermapper.com/viewtopic.php?p=1096#1096\n\t// specification: http://www.ietf.org/rfc/rfc4291.txt\n\tURI.ip6_expression = /^\\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\s*$/;\n\t// expression used is \"gruber revised\" (@gruber v2) determined to be the\n\t// best solution in a regex-golf we did a couple of ages ago at\n\t// * http://mathiasbynens.be/demo/url-regex\n\t// * http://rodneyrehm.de/t/url-regex.html\n\tURI.find_uri_expression = /\\b((?:[a-z][\\w-]+:(?:\\/{1,3}|[a-z0-9%])|www\\d{0,3}[.]|[a-z0-9.\\-]+[.][a-z]{2,4}\\/)(?:[^\\s()<>]+|\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\))+(?:\\(([^\\s()<>]+|(\\([^\\s()<>]+\\)))*\\)|[^\\s`!()\\[\\]{};:'\".,<>?«»“”‘’]))/ig;\n\tURI.findUri = {\n\t\t// valid \"scheme://\" or \"www.\"\n\t\tstart: /\\b(?:([a-z][a-z0-9.+-]*:\\/\\/)|www\\.)/gi,\n\t\t// everything up to the next whitespace\n\t\tend: /[\\s\\r\\n]|$/,\n\t\t// trim trailing punctuation captured by end RegExp\n\t\ttrim: /[`!()\\[\\]{};:'\".,<>?«»“”„‘’]+$/\n\t};\n\t// http://www.iana.org/assignments/uri-schemes.html\n\t// http://en.wikipedia.org/wiki/List_of_TCP_and_UDP_port_numbers#Well-known_ports\n\tURI.defaultPorts = {\n\t\thttp: '80',\n\t\thttps: '443',\n\t\tftp: '21',\n\t\tgopher: '70',\n\t\tws: '80',\n\t\twss: '443'\n\t};\n\t// allowed hostname characters according to RFC 3986\n\t// ALPHA DIGIT \"-\" \".\" \"_\" \"~\" \"!\" \"$\" \"&\" \"'\" \"(\" \")\" \"*\" \"+\" \",\" \";\" \"=\" %encoded\n\t// I've never seen a (non-IDN) hostname other than: ALPHA DIGIT . -\n\tURI.invalid_hostname_characters = /[^a-zA-Z0-9\\.-]/;\n\t// map DOM Elements to their URI attribute\n\tURI.domAttributes = {\n\t\t'a': 'href',\n\t\t'blockquote': 'cite',\n\t\t'link': 'href',\n\t\t'base': 'href',\n\t\t'script': 'src',\n\t\t'form': 'action',\n\t\t'img': 'src',\n\t\t'area': 'href',\n\t\t'iframe': 'src',\n\t\t'embed': 'src',\n\t\t'source': 'src',\n\t\t'track': 'src',\n\t\t'input': 'src', // but only if type=\"image\"\n\t\t'audio': 'src',\n\t\t'video': 'src'\n\t};\n\tURI.getDomAttribute = function(node) {\n\t\tif (!node || !node.nodeName) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\tvar nodeName = node.nodeName.toLowerCase();\n\t\t// should only expose src for type=\"image\"\n\t\tif (nodeName === 'input' && node.type !== 'image') {\n\t\t\treturn undefined;\n\t\t}\n\n\t\treturn URI.domAttributes[nodeName];\n\t};\n\n\tfunction escapeForDumbFirefox36(value) {\n\t\t// https://github.com/medialize/URI.js/issues/91\n\t\treturn escape(value);\n\t}\n\n\t// encoding / decoding according to RFC3986\n\tfunction strictEncodeURIComponent(string) {\n\t\t// see https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent\n\t\treturn encodeURIComponent(string)\n\t\t\t.replace(/[!'()*]/g, escapeForDumbFirefox36)\n\t\t\t.replace(/\\*/g, '%2A');\n\t}\n\tURI.encode = strictEncodeURIComponent;\n\tURI.decode = decodeURIComponent;\n\tURI.iso8859 = function() {\n\t\tURI.encode = escape;\n\t\tURI.decode = unescape;\n\t};\n\tURI.unicode = function() {\n\t\tURI.encode = strictEncodeURIComponent;\n\t\tURI.decode = decodeURIComponent;\n\t};\n\tURI.characters = {\n\t\tpathname: {\n\t\t\tencode: {\n\t\t\t\t// RFC3986 2.1: For consistency, URI producers and normalizers should\n\t\t\t\t// use uppercase hexadecimal digits for all percent-encodings.\n\t\t\t\texpression: /%(24|26|2B|2C|3B|3D|3A|40)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t// -._~!'()*\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%26': '&',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '=',\n\t\t\t\t\t'%3A': ':',\n\t\t\t\t\t'%40': '@'\n\t\t\t\t}\n\t\t\t},\n\t\t\tdecode: {\n\t\t\t\texpression: /[\\/\\?#]/g,\n\t\t\t\tmap: {\n\t\t\t\t\t'/': '%2F',\n\t\t\t\t\t'?': '%3F',\n\t\t\t\t\t'#': '%23'\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\treserved: {\n\t\t\tencode: {\n\t\t\t\t// RFC3986 2.1: For consistency, URI producers and normalizers should\n\t\t\t\t// use uppercase hexadecimal digits for all percent-encodings.\n\t\t\t\texpression: /%(21|23|24|26|27|28|29|2A|2B|2C|2F|3A|3B|3D|3F|40|5B|5D)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t// gen-delims\n\t\t\t\t\t'%3A': ':',\n\t\t\t\t\t'%2F': '/',\n\t\t\t\t\t'%3F': '?',\n\t\t\t\t\t'%23': '#',\n\t\t\t\t\t'%5B': '[',\n\t\t\t\t\t'%5D': ']',\n\t\t\t\t\t'%40': '@',\n\t\t\t\t\t// sub-delims\n\t\t\t\t\t'%21': '!',\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%26': '&',\n\t\t\t\t\t'%27': '\\'',\n\t\t\t\t\t'%28': '(',\n\t\t\t\t\t'%29': ')',\n\t\t\t\t\t'%2A': '*',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '='\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\turnpath: {\n\t\t\t// The characters under `encode` are the characters called out by RFC 2141 as being acceptable\n\t\t\t// for usage in a URN. RFC2141 also calls out \"-\", \".\", and \"_\" as acceptable characters, but\n\t\t\t// these aren't encoded by encodeURIComponent, so we don't have to call them out here. Also\n\t\t\t// note that the colon character is not featured in the encoding map; this is because URI.js\n\t\t\t// gives the colons in URNs semantic meaning as the delimiters of path segements, and so it\n\t\t\t// should not appear unencoded in a segment itself.\n\t\t\t// See also the note above about RFC3986 and capitalalized hex digits.\n\t\t\tencode: {\n\t\t\t\texpression: /%(21|24|27|28|29|2A|2B|2C|3B|3D|40)/ig,\n\t\t\t\tmap: {\n\t\t\t\t\t'%21': '!',\n\t\t\t\t\t'%24': '$',\n\t\t\t\t\t'%27': '\\'',\n\t\t\t\t\t'%28': '(',\n\t\t\t\t\t'%29': ')',\n\t\t\t\t\t'%2A': '*',\n\t\t\t\t\t'%2B': '+',\n\t\t\t\t\t'%2C': ',',\n\t\t\t\t\t'%3B': ';',\n\t\t\t\t\t'%3D': '=',\n\t\t\t\t\t'%40': '@'\n\t\t\t\t}\n\t\t\t},\n\t\t\t// These characters are the characters called out by RFC2141 as \"reserved\" characters that\n\t\t\t// should never appear in a URN, plus the colon character (see note above).\n\t\t\tdecode: {\n\t\t\t\texpression: /[\\/\\?#:]/g,\n\t\t\t\tmap: {\n\t\t\t\t\t'/': '%2F',\n\t\t\t\t\t'?': '%3F',\n\t\t\t\t\t'#': '%23',\n\t\t\t\t\t':': '%3A'\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\tURI.encodeQuery = function(string, escapeQuerySpace) {\n\t\tvar escaped = URI.encode(string + '');\n\t\tif (escapeQuerySpace === undefined) {\n\t\t\tescapeQuerySpace = URI.escapeQuerySpace;\n\t\t}\n\n\t\treturn escapeQuerySpace ? escaped.replace(/%20/g, '+') : escaped;\n\t};\n\tURI.decodeQuery = function(string, escapeQuerySpace) {\n\t\tstring += '';\n\t\tif (escapeQuerySpace === undefined) {\n\t\t\tescapeQuerySpace = URI.escapeQuerySpace;\n\t\t}\n\n\t\ttry {\n\t\t\treturn URI.decode(escapeQuerySpace ? string.replace(/\\+/g, '%20') : string);\n\t\t} catch(e) {\n\t\t\t// we're not going to mess with weird encodings,\n\t\t\t// give up and return the undecoded original string\n\t\t\t// see https://github.com/medialize/URI.js/issues/87\n\t\t\t// see https://github.com/medialize/URI.js/issues/92\n\t\t\treturn string;\n\t\t}\n\t};\n\t// generate encode/decode path functions\n\tvar _parts = {'encode':'encode', 'decode':'decode'};\n\tvar _part;\n\tvar generateAccessor = function(_group, _part) {\n\t\treturn function(string) {\n\t\t\ttry {\n\t\t\t\treturn URI[_part](string + '').replace(URI.characters[_group][_part].expression, function(c) {\n\t\t\t\t\treturn URI.characters[_group][_part].map[c];\n\t\t\t\t});\n\t\t\t} catch (e) {\n\t\t\t\t// we're not going to mess with weird encodings,\n\t\t\t\t// give up and return the undecoded original string\n\t\t\t\t// see https://github.com/medialize/URI.js/issues/87\n\t\t\t\t// see https://github.com/medialize/URI.js/issues/92\n\t\t\t\treturn string;\n\t\t\t}\n\t\t};\n\t};\n\n\tfor (_part in _parts) {\n\t\tURI[_part + 'PathSegment'] = generateAccessor('pathname', _parts[_part]);\n\t\tURI[_part + 'UrnPathSegment'] = generateAccessor('urnpath', _parts[_part]);\n\t}\n\n\tvar generateSegmentedPathFunction = function(_sep, _codingFuncName, _innerCodingFuncName) {\n\t\treturn function(string) {\n\t\t\t// Why pass in names of functions, rather than the function objects themselves? The\n\t\t\t// definitions of some functions (but in particular, URI.decode) will occasionally change due\n\t\t\t// to URI.js having ISO8859 and Unicode modes. Passing in the name and getting it will ensure\n\t\t\t// that the functions we use here are \"fresh\".\n\t\t\tvar actualCodingFunc;\n\t\t\tif (!_innerCodingFuncName) {\n\t\t\t\tactualCodingFunc = URI[_codingFuncName];\n\t\t\t} else {\n\t\t\t\tactualCodingFunc = function(string) {\n\t\t\t\t\treturn URI[_codingFuncName](URI[_innerCodingFuncName](string));\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tvar segments = (string + '').split(_sep);\n\n\t\t\tfor (var i = 0, length = segments.length; i < length; i++) {\n\t\t\t\tsegments[i] = actualCodingFunc(segments[i]);\n\t\t\t}\n\n\t\t\treturn segments.join(_sep);\n\t\t};\n\t};\n\n\t// This takes place outside the above loop because we don't want, e.g., encodeUrnPath functions.\n\tURI.decodePath = generateSegmentedPathFunction('/', 'decodePathSegment');\n\tURI.decodeUrnPath = generateSegmentedPathFunction(':', 'decodeUrnPathSegment');\n\tURI.recodePath = generateSegmentedPathFunction('/', 'encodePathSegment', 'decode');\n\tURI.recodeUrnPath = generateSegmentedPathFunction(':', 'encodeUrnPathSegment', 'decode');\n\n\tURI.encodeReserved = generateAccessor('reserved', 'encode');\n\n\tURI.parse = function(string, parts) {\n\t\tvar pos;\n\t\tif (!parts) {\n\t\t\tparts = {};\n\t\t}\n\t\t// [protocol\"://\"[username[\":\"password]\"@\"]hostname[\":\"port]\"/\"?][path][\"?\"querystring][\"#\"fragment]\n\n\t\t// extract fragment\n\t\tpos = string.indexOf('#');\n\t\tif (pos > -1) {\n\t\t\t// escaping?\n\t\t\tparts.fragment = string.substring(pos + 1) || null;\n\t\t\tstring = string.substring(0, pos);\n\t\t}\n\n\t\t// extract query\n\t\tpos = string.indexOf('?');\n\t\tif (pos > -1) {\n\t\t\t// escaping?\n\t\t\tparts.query = string.substring(pos + 1) || null;\n\t\t\tstring = string.substring(0, pos);\n\t\t}\n\n\t\t// extract protocol\n\t\tif (string.substring(0, 2) === '//') {\n\t\t\t// relative-scheme\n\t\t\tparts.protocol = null;\n\t\t\tstring = string.substring(2);\n\t\t\t// extract \"user:pass@host:port\"\n\t\t\tstring = URI.parseAuthority(string, parts);\n\t\t} else {\n\t\t\tpos = string.indexOf(':');\n\t\t\tif (pos > -1) {\n\t\t\t\tparts.protocol = string.substring(0, pos) || null;\n\t\t\t\tif (parts.protocol && !parts.protocol.match(URI.protocol_expression)) {\n\t\t\t\t\t// : may be within the path\n\t\t\t\t\tparts.protocol = undefined;\n\t\t\t\t} else if (string.substring(pos + 1, pos + 3) === '//') {\n\t\t\t\t\tstring = string.substring(pos + 3);\n\n\t\t\t\t\t// extract \"user:pass@host:port\"\n\t\t\t\t\tstring = URI.parseAuthority(string, parts);\n\t\t\t\t} else {\n\t\t\t\t\tstring = string.substring(pos + 1);\n\t\t\t\t\tparts.urn = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// what's left must be the path\n\t\tparts.path = string;\n\n\t\t// and we're done\n\t\treturn parts;\n\t};\n\tURI.parseHost = function(string, parts) {\n\t\t// Copy chrome, IE, opera backslash-handling behavior.\n\t\t// Back slashes before the query string get converted to forward slashes\n\t\t// See: https://github.com/joyent/node/blob/386fd24f49b0e9d1a8a076592a404168faeecc34/lib/url.js#L115-L124\n\t\t// See: https://code.google.com/p/chromium/issues/detail?id=25916\n\t\t// https://github.com/medialize/URI.js/pull/233\n\t\tstring = string.replace(/\\\\/g, '/');\n\n\t\t// extract host:port\n\t\tvar pos = string.indexOf('/');\n\t\tvar bracketPos;\n\t\tvar t;\n\n\t\tif (pos === -1) {\n\t\t\tpos = string.length;\n\t\t}\n\n\t\tif (string.charAt(0) === '[') {\n\t\t\t// IPv6 host - http://tools.ietf.org/html/draft-ietf-6man-text-addr-representation-04#section-6\n\t\t\t// I claim most client software breaks on IPv6 anyways. To simplify things, URI only accepts\n\t\t\t// IPv6+port in the format [2001:db8::1]:80 (for the time being)\n\t\t\tbracketPos = string.indexOf(']');\n\t\t\tparts.hostname = string.substring(1, bracketPos) || null;\n\t\t\tparts.port = string.substring(bracketPos + 2, pos) || null;\n\t\t\tif (parts.port === '/') {\n\t\t\t\tparts.port = null;\n\t\t\t}\n\t\t} else {\n\t\t\tvar firstColon = string.indexOf(':');\n\t\t\tvar firstSlash = string.indexOf('/');\n\t\t\tvar nextColon = string.indexOf(':', firstColon + 1);\n\t\t\tif (nextColon !== -1 && (firstSlash === -1 || nextColon < firstSlash)) {\n\t\t\t\t// IPv6 host contains multiple colons - but no port\n\t\t\t\t// this notation is actually not allowed by RFC 3986, but we're a liberal parser\n\t\t\t\tparts.hostname = string.substring(0, pos) || null;\n\t\t\t\tparts.port = null;\n\t\t\t} else {\n\t\t\t\tt = string.substring(0, pos).split(':');\n\t\t\t\tparts.hostname = t[0] || null;\n\t\t\t\tparts.port = t[1] || null;\n\t\t\t}\n\t\t}\n\n\t\tif (parts.hostname && string.substring(pos).charAt(0) !== '/') {\n\t\t\tpos++;\n\t\t\tstring = '/' + string;\n\t\t}\n\n\t\treturn string.substring(pos) || '/';\n\t};\n\tURI.parseAuthority = function(string, parts) {\n\t\tstring = URI.parseUserinfo(string, parts);\n\t\treturn URI.parseHost(string, parts);\n\t};\n\tURI.parseUserinfo = function(string, parts) {\n\t\t// extract username:password\n\t\tvar firstSlash = string.indexOf('/');\n\t\tvar pos = string.lastIndexOf('@', firstSlash > -1 ? firstSlash : string.length - 1);\n\t\tvar t;\n\n\t\t// authority@ must come before /path\n\t\tif (pos > -1 && (firstSlash === -1 || pos < firstSlash)) {\n\t\t\tt = string.substring(0, pos).split(':');\n\t\t\tparts.username = t[0] ? URI.decode(t[0]) : null;\n\t\t\tt.shift();\n\t\t\tparts.password = t[0] ? URI.decode(t.join(':')) : null;\n\t\t\tstring = string.substring(pos + 1);\n\t\t} else {\n\t\t\tparts.username = null;\n\t\t\tparts.password = null;\n\t\t}\n\n\t\treturn string;\n\t};\n\tURI.parseQuery = function(string, escapeQuerySpace) {\n\t\tif (!string) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// throw out the funky business - \"?\"[name\"=\"value\"&\"]+\n\t\tstring = string.replace(/&+/g, '&').replace(/^\\?*&*|&+$/g, '');\n\n\t\tif (!string) {\n\t\t\treturn {};\n\t\t}\n\n\t\tvar items = {};\n\t\tvar splits = string.split('&');\n\t\tvar length = splits.length;\n\t\tvar v, name, value;\n\n\t\tfor (var i = 0; i < length; i++) {\n\t\t\tv = splits[i].split('=');\n\t\t\tname = URI.decodeQuery(v.shift(), escapeQuerySpace);\n\t\t\t// no \"=\" is null according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#collect-url-parameters\n\t\t\tvalue = v.length ? URI.decodeQuery(v.join('='), escapeQuerySpace) : null;\n\n\t\t\tif (hasOwn.call(items, name)) {\n\t\t\t\tif (typeof items[name] === 'string' || items[name] === null) {\n\t\t\t\t\titems[name] = [items[name]];\n\t\t\t\t}\n\n\t\t\t\titems[name].push(value);\n\t\t\t} else {\n\t\t\t\titems[name] = value;\n\t\t\t}\n\t\t}\n\n\t\treturn items;\n\t};\n\n\tURI.build = function(parts) {\n\t\tvar t = '';\n\n\t\tif (parts.protocol) {\n\t\t\tt += parts.protocol + ':';\n\t\t}\n\n\t\tif (!parts.urn && (t || parts.hostname)) {\n\t\t\tt += '//';\n\t\t}\n\n\t\tt += (URI.buildAuthority(parts) || '');\n\n\t\tif (typeof parts.path === 'string') {\n\t\t\tif (parts.path.charAt(0) !== '/' && typeof parts.hostname === 'string') {\n\t\t\t\tt += '/';\n\t\t\t}\n\n\t\t\tt += parts.path;\n\t\t}\n\n\t\tif (typeof parts.query === 'string' && parts.query) {\n\t\t\tt += '?' + parts.query;\n\t\t}\n\n\t\tif (typeof parts.fragment === 'string' && parts.fragment) {\n\t\t\tt += '#' + parts.fragment;\n\t\t}\n\t\treturn t;\n\t};\n\tURI.buildHost = function(parts) {\n\t\tvar t = '';\n\n\t\tif (!parts.hostname) {\n\t\t\treturn '';\n\t\t} else if (URI.ip6_expression.test(parts.hostname)) {\n\t\t\tt += '[' + parts.hostname + ']';\n\t\t} else {\n\t\t\tt += parts.hostname;\n\t\t}\n\n\t\tif (parts.port) {\n\t\t\tt += ':' + parts.port;\n\t\t}\n\n\t\treturn t;\n\t};\n\tURI.buildAuthority = function(parts) {\n\t\treturn URI.buildUserinfo(parts) + URI.buildHost(parts);\n\t};\n\tURI.buildUserinfo = function(parts) {\n\t\tvar t = '';\n\n\t\tif (parts.username) {\n\t\t\tt += URI.encode(parts.username);\n\n\t\t\tif (parts.password) {\n\t\t\t\tt += ':' + URI.encode(parts.password);\n\t\t\t}\n\n\t\t\tt += '@';\n\t\t}\n\n\t\treturn t;\n\t};\n\tURI.buildQuery = function(data, duplicateQueryParameters, escapeQuerySpace) {\n\t\t// according to http://tools.ietf.org/html/rfc3986 or http://labs.apache.org/webarch/uri/rfc/rfc3986.html\n\t\t// being »-._~!$&'()*+,;=:@/?« %HEX and alnum are allowed\n\t\t// the RFC explicitly states ?/foo being a valid use case, no mention of parameter syntax!\n\t\t// URI.js treats the query string as being application/x-www-form-urlencoded\n\t\t// see http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type\n\n\t\tvar t = '';\n\t\tvar unique, key, i, length;\n\t\tfor (key in data) {\n\t\t\tif (hasOwn.call(data, key) && key) {\n\t\t\t\tif (isArray(data[key])) {\n\t\t\t\t\tunique = {};\n\t\t\t\t\tfor (i = 0, length = data[key].length; i < length; i++) {\n\t\t\t\t\t\tif (data[key][i] !== undefined && unique[data[key][i] + ''] === undefined) {\n\t\t\t\t\t\t\tt += '&' + URI.buildQueryParameter(key, data[key][i], escapeQuerySpace);\n\t\t\t\t\t\t\tif (duplicateQueryParameters !== true) {\n\t\t\t\t\t\t\t\tunique[data[key][i] + ''] = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (data[key] !== undefined) {\n\t\t\t\t\tt += '&' + URI.buildQueryParameter(key, data[key], escapeQuerySpace);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn t.substring(1);\n\t};\n\tURI.buildQueryParameter = function(name, value, escapeQuerySpace) {\n\t\t// http://www.w3.org/TR/REC-html40/interact/forms.html#form-content-type -- application/x-www-form-urlencoded\n\t\t// don't append \"=\" for null values, according to http://dvcs.w3.org/hg/url/raw-file/tip/Overview.html#url-parameter-serialization\n\t\treturn URI.encodeQuery(name, escapeQuerySpace) + (value !== null ? '=' + URI.encodeQuery(value, escapeQuerySpace) : '');\n\t};\n\n\tURI.addQuery = function(data, name, value) {\n\t\tif (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tURI.addQuery(data, key, name[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'string') {\n\t\t\tif (data[name] === undefined) {\n\t\t\t\tdata[name] = value;\n\t\t\t\treturn;\n\t\t\t} else if (typeof data[name] === 'string') {\n\t\t\t\tdata[name] = [data[name]];\n\t\t\t}\n\n\t\t\tif (!isArray(value)) {\n\t\t\t\tvalue = [value];\n\t\t\t}\n\n\t\t\tdata[name] = (data[name] || []).concat(value);\n\t\t} else {\n\t\t\tthrow new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n\t\t}\n\t};\n\tURI.removeQuery = function(data, name, value) {\n\t\tvar i, length, key;\n\n\t\tif (isArray(name)) {\n\t\t\tfor (i = 0, length = name.length; i < length; i++) {\n\t\t\t\tdata[name[i]] = undefined;\n\t\t\t}\n\t\t} else if (getType(name) === 'RegExp') {\n\t\t\tfor (key in data) {\n\t\t\t\tif (name.test(key)) {\n\t\t\t\t\tdata[key] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'object') {\n\t\t\tfor (key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tURI.removeQuery(data, key, name[key]);\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (typeof name === 'string') {\n\t\t\tif (value !== undefined) {\n\t\t\t\tif (getType(value) === 'RegExp') {\n\t\t\t\t\tif (!isArray(data[name]) && value.test(data[name])) {\n\t\t\t\t\t\tdata[name] = undefined;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tdata[name] = filterArrayValues(data[name], value);\n\t\t\t\t\t}\n\t\t\t\t} else if (data[name] === String(value) && (!isArray(value) || value.length === 1)) {\n\t\t\t\t\tdata[name] = undefined;\n\t\t\t\t} else if (isArray(data[name])) {\n\t\t\t\t\tdata[name] = filterArrayValues(data[name], value);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tdata[name] = undefined;\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('URI.removeQuery() accepts an object, string, RegExp as the first parameter');\n\t\t}\n\t};\n\tURI.hasQuery = function(data, name, value, withinArray) {\n\t\tif (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tif (!URI.hasQuery(data, key, name[key])) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn true;\n\t\t} else if (typeof name !== 'string') {\n\t\t\tthrow new TypeError('URI.hasQuery() accepts an object, string as the name parameter');\n\t\t}\n\n\t\tswitch (getType(value)) {\n\t\t\tcase 'Undefined':\n\t\t\t\t// true if exists (but may be empty)\n\t\t\t\treturn name in data; // data[name] !== undefined;\n\n\t\t\tcase 'Boolean':\n\t\t\t\t// true if exists and non-empty\n\t\t\t\tvar _booly = Boolean(isArray(data[name]) ? data[name].length : data[name]);\n\t\t\t\treturn value === _booly;\n\n\t\t\tcase 'Function':\n\t\t\t\t// allow complex comparison\n\t\t\t\treturn !!value(data[name], name, data);\n\n\t\t\tcase 'Array':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tvar op = withinArray ? arrayContains : arraysEqual;\n\t\t\t\treturn op(data[name], value);\n\n\t\t\tcase 'RegExp':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn Boolean(data[name] && data[name].match(value));\n\t\t\t\t}\n\n\t\t\t\tif (!withinArray) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\treturn arrayContains(data[name], value);\n\n\t\t\tcase 'Number':\n\t\t\t\tvalue = String(value);\n\t\t\t/* falls through */\n\t\t\tcase 'String':\n\t\t\t\tif (!isArray(data[name])) {\n\t\t\t\t\treturn data[name] === value;\n\t\t\t\t}\n\n\t\t\t\tif (!withinArray) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\treturn arrayContains(data[name], value);\n\n\t\t\tdefault:\n\t\t\t\tthrow new TypeError('URI.hasQuery() accepts undefined, boolean, string, number, RegExp, Function as the value parameter');\n\t\t}\n\t};\n\n\n\tURI.commonPath = function(one, two) {\n\t\tvar length = Math.min(one.length, two.length);\n\t\tvar pos;\n\n\t\t// find first non-matching character\n\t\tfor (pos = 0; pos < length; pos++) {\n\t\t\tif (one.charAt(pos) !== two.charAt(pos)) {\n\t\t\t\tpos--;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\tif (pos < 1) {\n\t\t\treturn one.charAt(0) === two.charAt(0) && one.charAt(0) === '/' ? '/' : '';\n\t\t}\n\n\t\t// revert to last /\n\t\tif (one.charAt(pos) !== '/' || two.charAt(pos) !== '/') {\n\t\t\tpos = one.substring(0, pos).lastIndexOf('/');\n\t\t}\n\n\t\treturn one.substring(0, pos + 1);\n\t};\n\n\tURI.withinString = function(string, callback, options) {\n\t\toptions || (options = {});\n\t\tvar _start = options.start || URI.findUri.start;\n\t\tvar _end = options.end || URI.findUri.end;\n\t\tvar _trim = options.trim || URI.findUri.trim;\n\t\tvar _attributeOpen = /[a-z0-9-]=[\"']?$/i;\n\n\t\t_start.lastIndex = 0;\n\t\twhile (true) {\n\t\t\tvar match = _start.exec(string);\n\t\t\tif (!match) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tvar start = match.index;\n\t\t\tif (options.ignoreHtml) {\n\t\t\t\t// attribut(e=[\"']?$)\n\t\t\t\tvar attributeOpen = string.slice(Math.max(start - 3, 0), start);\n\t\t\t\tif (attributeOpen && _attributeOpen.test(attributeOpen)) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar end = start + string.slice(start).search(_end);\n\t\t\tvar slice = string.slice(start, end).replace(_trim, '');\n\t\t\tif (options.ignore && options.ignore.test(slice)) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tend = start + slice.length;\n\t\t\tvar result = callback(slice, start, end, string);\n\t\t\tstring = string.slice(0, start) + result + string.slice(end);\n\t\t\t_start.lastIndex = start + result.length;\n\t\t}\n\n\t\t_start.lastIndex = 0;\n\t\treturn string;\n\t};\n\n\tURI.ensureValidHostname = function(v) {\n\t\t// Theoretically URIs allow percent-encoding in Hostnames (according to RFC 3986)\n\t\t// they are not part of DNS and therefore ignored by URI.js\n\n\t\tif (v.match(URI.invalid_hostname_characters)) {\n\t\t\t// test punycode\n\t\t\tif (!punycode) {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-] and Punycode.js is not available');\n\t\t\t}\n\n\t\t\tif (punycode.toASCII(v).match(URI.invalid_hostname_characters)) {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\t\t}\n\t};\n\n\t// noConflict\n\tURI.noConflict = function(removeAll) {\n\t\tif (removeAll) {\n\t\t\tvar unconflicted = {\n\t\t\t\tURI: this.noConflict()\n\t\t\t};\n\n\t\t\tif (root.URITemplate && typeof root.URITemplate.noConflict === 'function') {\n\t\t\t\tunconflicted.URITemplate = root.URITemplate.noConflict();\n\t\t\t}\n\n\t\t\tif (root.IPv6 && typeof root.IPv6.noConflict === 'function') {\n\t\t\t\tunconflicted.IPv6 = root.IPv6.noConflict();\n\t\t\t}\n\n\t\t\tif (root.SecondLevelDomains && typeof root.SecondLevelDomains.noConflict === 'function') {\n\t\t\t\tunconflicted.SecondLevelDomains = root.SecondLevelDomains.noConflict();\n\t\t\t}\n\n\t\t\treturn unconflicted;\n\t\t} else if (root.URI === this) {\n\t\t\troot.URI = _URI;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\tp.build = function(deferBuild) {\n\t\tif (deferBuild === true) {\n\t\t\tthis._deferred_build = true;\n\t\t} else if (deferBuild === undefined || this._deferred_build) {\n\t\t\tthis._string = URI.build(this._parts);\n\t\t\tthis._deferred_build = false;\n\t\t}\n\n\t\treturn this;\n\t};\n\n\tp.clone = function() {\n\t\treturn new URI(this);\n\t};\n\n\tp.valueOf = p.toString = function() {\n\t\treturn this.build(false)._string;\n\t};\n\n\n\tfunction generateSimpleAccessor(_part){\n\t\treturn function(v, build) {\n\t\t\tif (v === undefined) {\n\t\t\t\treturn this._parts[_part] || '';\n\t\t\t} else {\n\t\t\t\tthis._parts[_part] = v || null;\n\t\t\t\tthis.build(!build);\n\t\t\t\treturn this;\n\t\t\t}\n\t\t};\n\t}\n\n\tfunction generatePrefixAccessor(_part, _key){\n\t\treturn function(v, build) {\n\t\t\tif (v === undefined) {\n\t\t\t\treturn this._parts[_part] || '';\n\t\t\t} else {\n\t\t\t\tif (v !== null) {\n\t\t\t\t\tv = v + '';\n\t\t\t\t\tif (v.charAt(0) === _key) {\n\t\t\t\t\t\tv = v.substring(1);\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tthis._parts[_part] = v;\n\t\t\t\tthis.build(!build);\n\t\t\t\treturn this;\n\t\t\t}\n\t\t};\n\t}\n\n\tp.protocol = generateSimpleAccessor('protocol');\n\tp.username = generateSimpleAccessor('username');\n\tp.password = generateSimpleAccessor('password');\n\tp.hostname = generateSimpleAccessor('hostname');\n\tp.port = generateSimpleAccessor('port');\n\tp.query = generatePrefixAccessor('query', '?');\n\tp.fragment = generatePrefixAccessor('fragment', '#');\n\n\tp.search = function(v, build) {\n\t\tvar t = this.query(v, build);\n\t\treturn typeof t === 'string' && t.length ? ('?' + t) : t;\n\t};\n\tp.hash = function(v, build) {\n\t\tvar t = this.fragment(v, build);\n\t\treturn typeof t === 'string' && t.length ? ('#' + t) : t;\n\t};\n\n\tp.pathname = function(v, build) {\n\t\tif (v === undefined || v === true) {\n\t\t\tvar res = this._parts.path || (this._parts.hostname ? '/' : '');\n\t\t\treturn v ? (this._parts.urn ? URI.decodeUrnPath : URI.decodePath)(res) : res;\n\t\t} else {\n\t\t\tif (this._parts.urn) {\n\t\t\t\tthis._parts.path = v ? URI.recodeUrnPath(v) : '';\n\t\t\t} else {\n\t\t\t\tthis._parts.path = v ? URI.recodePath(v) : '/';\n\t\t\t}\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.path = p.pathname;\n\tp.href = function(href, build) {\n\t\tvar key;\n\n\t\tif (href === undefined) {\n\t\t\treturn this.toString();\n\t\t}\n\n\t\tthis._string = '';\n\t\tthis._parts = URI._parts();\n\n\t\tvar _URI = href instanceof URI;\n\t\tvar _object = typeof href === 'object' && (href.hostname || href.path || href.pathname);\n\t\tif (href.nodeName) {\n\t\t\tvar attribute = URI.getDomAttribute(href);\n\t\t\thref = href[attribute] || '';\n\t\t\t_object = false;\n\t\t}\n\n\t\t// window.location is reported to be an object, but it's not the sort\n\t\t// of object we're looking for:\n\t\t// * location.protocol ends with a colon\n\t\t// * location.query != object.search\n\t\t// * location.hash != object.fragment\n\t\t// simply serializing the unknown object should do the trick\n\t\t// (for location, not for everything...)\n\t\tif (!_URI && _object && href.pathname !== undefined) {\n\t\t\thref = href.toString();\n\t\t}\n\n\t\tif (typeof href === 'string' || href instanceof String) {\n\t\t\tthis._parts = URI.parse(String(href), this._parts);\n\t\t} else if (_URI || _object) {\n\t\t\tvar src = _URI ? href._parts : href;\n\t\t\tfor (key in src) {\n\t\t\t\tif (hasOwn.call(this._parts, key)) {\n\t\t\t\t\tthis._parts[key] = src[key];\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('invalid input');\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\n\t// identification accessors\n\tp.is = function(what) {\n\t\tvar ip = false;\n\t\tvar ip4 = false;\n\t\tvar ip6 = false;\n\t\tvar name = false;\n\t\tvar sld = false;\n\t\tvar idn = false;\n\t\tvar punycode = false;\n\t\tvar relative = !this._parts.urn;\n\n\t\tif (this._parts.hostname) {\n\t\t\trelative = false;\n\t\t\tip4 = URI.ip4_expression.test(this._parts.hostname);\n\t\t\tip6 = URI.ip6_expression.test(this._parts.hostname);\n\t\t\tip = ip4 || ip6;\n\t\t\tname = !ip;\n\t\t\tsld = name && SLD && SLD.has(this._parts.hostname);\n\t\t\tidn = name && URI.idn_expression.test(this._parts.hostname);\n\t\t\tpunycode = name && URI.punycode_expression.test(this._parts.hostname);\n\t\t}\n\n\t\tswitch (what.toLowerCase()) {\n\t\t\tcase 'relative':\n\t\t\t\treturn relative;\n\n\t\t\tcase 'absolute':\n\t\t\t\treturn !relative;\n\n\t\t\t// hostname identification\n\t\t\tcase 'domain':\n\t\t\tcase 'name':\n\t\t\t\treturn name;\n\n\t\t\tcase 'sld':\n\t\t\t\treturn sld;\n\n\t\t\tcase 'ip':\n\t\t\t\treturn ip;\n\n\t\t\tcase 'ip4':\n\t\t\tcase 'ipv4':\n\t\t\tcase 'inet4':\n\t\t\t\treturn ip4;\n\n\t\t\tcase 'ip6':\n\t\t\tcase 'ipv6':\n\t\t\tcase 'inet6':\n\t\t\t\treturn ip6;\n\n\t\t\tcase 'idn':\n\t\t\t\treturn idn;\n\n\t\t\tcase 'url':\n\t\t\t\treturn !this._parts.urn;\n\n\t\t\tcase 'urn':\n\t\t\t\treturn !!this._parts.urn;\n\n\t\t\tcase 'punycode':\n\t\t\t\treturn punycode;\n\t\t}\n\n\t\treturn null;\n\t};\n\n\t// component specific input validation\n\tvar _protocol = p.protocol;\n\tvar _port = p.port;\n\tvar _hostname = p.hostname;\n\n\tp.protocol = function(v, build) {\n\t\tif (v !== undefined) {\n\t\t\tif (v) {\n\t\t\t\t// accept trailing ://\n\t\t\t\tv = v.replace(/:(\\/\\/)?$/, '');\n\n\t\t\t\tif (!v.match(URI.protocol_expression)) {\n\t\t\t\t\tthrow new TypeError('Protocol \"' + v + '\" contains characters other than [A-Z0-9.+-] or doesn\\'t start with [A-Z]');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn _protocol.call(this, v, build);\n\t};\n\tp.scheme = p.protocol;\n\tp.port = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v !== undefined) {\n\t\t\tif (v === 0) {\n\t\t\t\tv = null;\n\t\t\t}\n\n\t\t\tif (v) {\n\t\t\t\tv += '';\n\t\t\t\tif (v.charAt(0) === ':') {\n\t\t\t\t\tv = v.substring(1);\n\t\t\t\t}\n\n\t\t\t\tif (v.match(/[^0-9]/)) {\n\t\t\t\t\tthrow new TypeError('Port \"' + v + '\" contains characters other than [0-9]');\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn _port.call(this, v, build);\n\t};\n\tp.hostname = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v !== undefined) {\n\t\t\tvar x = {};\n\t\t\tvar res = URI.parseHost(v, x);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tv = x.hostname;\n\t\t}\n\t\treturn _hostname.call(this, v, build);\n\t};\n\n\t// compound accessors\n\tp.origin = function(v, build) {\n\t\tvar parts;\n\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tvar protocol = this.protocol();\n\t\t\tvar authority = this.authority();\n\t\t\tif (!authority) return '';\n\t\t\treturn (protocol ? protocol + '://' : '') + this.authority();\n\t\t} else {\n\t\t\tvar origin = URI(v);\n\t\t\tthis\n\t\t\t\t.protocol(origin.protocol())\n\t\t\t\t.authority(origin.authority())\n\t\t\t\t.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.host = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\treturn this._parts.hostname ? URI.buildHost(this._parts) : '';\n\t\t} else {\n\t\t\tvar res = URI.parseHost(v, this._parts);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.authority = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\treturn this._parts.hostname ? URI.buildAuthority(this._parts) : '';\n\t\t} else {\n\t\t\tvar res = URI.parseAuthority(v, this._parts);\n\t\t\tif (res !== '/') {\n\t\t\t\tthrow new TypeError('Hostname \"' + v + '\" contains characters other than [A-Z0-9.-]');\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.userinfo = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.username) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar t = URI.buildUserinfo(this._parts);\n\t\t\treturn t.substring(0, t.length -1);\n\t\t} else {\n\t\t\tif (v[v.length-1] !== '@') {\n\t\t\t\tv += '@';\n\t\t\t}\n\n\t\t\tURI.parseUserinfo(v, this._parts);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.resource = function(v, build) {\n\t\tvar parts;\n\n\t\tif (v === undefined) {\n\t\t\treturn this.path() + this.search() + this.hash();\n\t\t}\n\n\t\tparts = URI.parse(v);\n\t\tthis._parts.path = parts.path;\n\t\tthis._parts.query = parts.query;\n\t\tthis._parts.fragment = parts.fragment;\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\n\t// fraction accessors\n\tp.subdomain = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\t// convenience, return \"www\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// grab domain and add another segment\n\t\t\tvar end = this._parts.hostname.length - this.domain().length - 1;\n\t\t\treturn this._parts.hostname.substring(0, end) || '';\n\t\t} else {\n\t\t\tvar e = this._parts.hostname.length - this.domain().length;\n\t\t\tvar sub = this._parts.hostname.substring(0, e);\n\t\t\tvar replace = new RegExp('^' + escapeRegEx(sub));\n\n\t\t\tif (v && v.charAt(v.length - 1) !== '.') {\n\t\t\t\tv += '.';\n\t\t\t}\n\n\t\t\tif (v) {\n\t\t\t\tURI.ensureValidHostname(v);\n\t\t\t}\n\n\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.domain = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (typeof v === 'boolean') {\n\t\t\tbuild = v;\n\t\t\tv = undefined;\n\t\t}\n\n\t\t// convenience, return \"example.org\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// if hostname consists of 1 or 2 segments, it must be the domain\n\t\t\tvar t = this._parts.hostname.match(/\\./g);\n\t\t\tif (t && t.length < 2) {\n\t\t\t\treturn this._parts.hostname;\n\t\t\t}\n\n\t\t\t// grab tld and add another segment\n\t\t\tvar end = this._parts.hostname.length - this.tld(build).length - 1;\n\t\t\tend = this._parts.hostname.lastIndexOf('.', end -1) + 1;\n\t\t\treturn this._parts.hostname.substring(end) || '';\n\t\t} else {\n\t\t\tif (!v) {\n\t\t\t\tthrow new TypeError('cannot set domain empty');\n\t\t\t}\n\n\t\t\tURI.ensureValidHostname(v);\n\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\tthis._parts.hostname = v;\n\t\t\t} else {\n\t\t\t\tvar replace = new RegExp(escapeRegEx(this.domain()) + '$');\n\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.tld = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (typeof v === 'boolean') {\n\t\t\tbuild = v;\n\t\t\tv = undefined;\n\t\t}\n\n\t\t// return \"org\" from \"www.example.org\"\n\t\tif (v === undefined) {\n\t\t\tif (!this._parts.hostname || this.is('IP')) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar pos = this._parts.hostname.lastIndexOf('.');\n\t\t\tvar tld = this._parts.hostname.substring(pos + 1);\n\n\t\t\tif (build !== true && SLD && SLD.list[tld.toLowerCase()]) {\n\t\t\t\treturn SLD.get(this._parts.hostname) || tld;\n\t\t\t}\n\n\t\t\treturn tld;\n\t\t} else {\n\t\t\tvar replace;\n\n\t\t\tif (!v) {\n\t\t\t\tthrow new TypeError('cannot set TLD empty');\n\t\t\t} else if (v.match(/[^a-zA-Z0-9-]/)) {\n\t\t\t\tif (SLD && SLD.is(v)) {\n\t\t\t\t\treplace = new RegExp(escapeRegEx(this.tld()) + '$');\n\t\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t\t} else {\n\t\t\t\t\tthrow new TypeError('TLD \"' + v + '\" contains characters other than [A-Z0-9]');\n\t\t\t\t}\n\t\t\t} else if (!this._parts.hostname || this.is('IP')) {\n\t\t\t\tthrow new ReferenceError('cannot set TLD on non-domain host');\n\t\t\t} else {\n\t\t\t\treplace = new RegExp(escapeRegEx(this.tld()) + '$');\n\t\t\t\tthis._parts.hostname = this._parts.hostname.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.directory = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path && !this._parts.hostname) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tif (this._parts.path === '/') {\n\t\t\t\treturn '/';\n\t\t\t}\n\n\t\t\tvar end = this._parts.path.length - this.filename().length - 1;\n\t\t\tvar res = this._parts.path.substring(0, end) || (this._parts.hostname ? '/' : '');\n\n\t\t\treturn v ? URI.decodePath(res) : res;\n\n\t\t} else {\n\t\t\tvar e = this._parts.path.length - this.filename().length;\n\t\t\tvar directory = this._parts.path.substring(0, e);\n\t\t\tvar replace = new RegExp('^' + escapeRegEx(directory));\n\n\t\t\t// fully qualifier directories begin with a slash\n\t\t\tif (!this.is('relative')) {\n\t\t\t\tif (!v) {\n\t\t\t\t\tv = '/';\n\t\t\t\t}\n\n\t\t\t\tif (v.charAt(0) !== '/') {\n\t\t\t\t\tv = '/' + v;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// directories always end with a slash\n\t\t\tif (v && v.charAt(v.length - 1) !== '/') {\n\t\t\t\tv += '/';\n\t\t\t}\n\n\t\t\tv = URI.recodePath(v);\n\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.filename = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path || this._parts.path === '/') {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar pos = this._parts.path.lastIndexOf('/');\n\t\t\tvar res = this._parts.path.substring(pos+1);\n\n\t\t\treturn v ? URI.decodePathSegment(res) : res;\n\t\t} else {\n\t\t\tvar mutatedDirectory = false;\n\n\t\t\tif (v.charAt(0) === '/') {\n\t\t\t\tv = v.substring(1);\n\t\t\t}\n\n\t\t\tif (v.match(/\\.?\\//)) {\n\t\t\t\tmutatedDirectory = true;\n\t\t\t}\n\n\t\t\tvar replace = new RegExp(escapeRegEx(this.filename()) + '$');\n\t\t\tv = URI.recodePath(v);\n\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\n\t\t\tif (mutatedDirectory) {\n\t\t\t\tthis.normalizePath(build);\n\t\t\t} else {\n\t\t\t\tthis.build(!build);\n\t\t\t}\n\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.suffix = function(v, build) {\n\t\tif (this._parts.urn) {\n\t\t\treturn v === undefined ? '' : this;\n\t\t}\n\n\t\tif (v === undefined || v === true) {\n\t\t\tif (!this._parts.path || this._parts.path === '/') {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\tvar filename = this.filename();\n\t\t\tvar pos = filename.lastIndexOf('.');\n\t\t\tvar s, res;\n\n\t\t\tif (pos === -1) {\n\t\t\t\treturn '';\n\t\t\t}\n\n\t\t\t// suffix may only contain alnum characters (yup, I made this up.)\n\t\t\ts = filename.substring(pos+1);\n\t\t\tres = (/^[a-z0-9%]+$/i).test(s) ? s : '';\n\t\t\treturn v ? URI.decodePathSegment(res) : res;\n\t\t} else {\n\t\t\tif (v.charAt(0) === '.') {\n\t\t\t\tv = v.substring(1);\n\t\t\t}\n\n\t\t\tvar suffix = this.suffix();\n\t\t\tvar replace;\n\n\t\t\tif (!suffix) {\n\t\t\t\tif (!v) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t\tthis._parts.path += '.' + URI.recodePath(v);\n\t\t\t} else if (!v) {\n\t\t\t\treplace = new RegExp(escapeRegEx('.' + suffix) + '$');\n\t\t\t} else {\n\t\t\t\treplace = new RegExp(escapeRegEx(suffix) + '$');\n\t\t\t}\n\n\t\t\tif (replace) {\n\t\t\t\tv = URI.recodePath(v);\n\t\t\t\tthis._parts.path = this._parts.path.replace(replace, v);\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\t};\n\tp.segment = function(segment, v, build) {\n\t\tvar separator = this._parts.urn ? ':' : '/';\n\t\tvar path = this.path();\n\t\tvar absolute = path.substring(0, 1) === '/';\n\t\tvar segments = path.split(separator);\n\n\t\tif (segment !== undefined && typeof segment !== 'number') {\n\t\t\tbuild = v;\n\t\t\tv = segment;\n\t\t\tsegment = undefined;\n\t\t}\n\n\t\tif (segment !== undefined && typeof segment !== 'number') {\n\t\t\tthrow new Error('Bad segment \"' + segment + '\", must be 0-based integer');\n\t\t}\n\n\t\tif (absolute) {\n\t\t\tsegments.shift();\n\t\t}\n\n\t\tif (segment < 0) {\n\t\t\t// allow negative indexes to address from the end\n\t\t\tsegment = Math.max(segments.length + segment, 0);\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\t/*jshint laxbreak: true */\n\t\t\treturn segment === undefined\n\t\t\t\t? segments\n\t\t\t\t: segments[segment];\n\t\t\t/*jshint laxbreak: false */\n\t\t} else if (segment === null || segments[segment] === undefined) {\n\t\t\tif (isArray(v)) {\n\t\t\t\tsegments = [];\n\t\t\t\t// collapse empty elements within array\n\t\t\t\tfor (var i=0, l=v.length; i < l; i++) {\n\t\t\t\t\tif (!v[i].length && (!segments.length || !segments[segments.length -1].length)) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (segments.length && !segments[segments.length -1].length) {\n\t\t\t\t\t\tsegments.pop();\n\t\t\t\t\t}\n\n\t\t\t\t\tsegments.push(trimSlashes(v[i]));\n\t\t\t\t}\n\t\t\t} else if (v || typeof v === 'string') {\n\t\t\t\tv = trimSlashes(v);\n\t\t\t\tif (segments[segments.length -1] === '') {\n\t\t\t\t\t// empty trailing elements have to be overwritten\n\t\t\t\t\t// to prevent results such as /foo//bar\n\t\t\t\t\tsegments[segments.length -1] = v;\n\t\t\t\t} else {\n\t\t\t\t\tsegments.push(v);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tif (v) {\n\t\t\t\tsegments[segment] = trimSlashes(v);\n\t\t\t} else {\n\t\t\t\tsegments.splice(segment, 1);\n\t\t\t}\n\t\t}\n\n\t\tif (absolute) {\n\t\t\tsegments.unshift('');\n\t\t}\n\n\t\treturn this.path(segments.join(separator), build);\n\t};\n\tp.segmentCoded = function(segment, v, build) {\n\t\tvar segments, i, l;\n\n\t\tif (typeof segment !== 'number') {\n\t\t\tbuild = v;\n\t\t\tv = segment;\n\t\t\tsegment = undefined;\n\t\t}\n\n\t\tif (v === undefined) {\n\t\t\tsegments = this.segment(segment, v, build);\n\t\t\tif (!isArray(segments)) {\n\t\t\t\tsegments = segments !== undefined ? URI.decode(segments) : undefined;\n\t\t\t} else {\n\t\t\t\tfor (i = 0, l = segments.length; i < l; i++) {\n\t\t\t\t\tsegments[i] = URI.decode(segments[i]);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn segments;\n\t\t}\n\n\t\tif (!isArray(v)) {\n\t\t\tv = (typeof v === 'string' || v instanceof String) ? URI.encode(v) : v;\n\t\t} else {\n\t\t\tfor (i = 0, l = v.length; i < l; i++) {\n\t\t\t\tv[i] = URI.encode(v[i]);\n\t\t\t}\n\t\t}\n\n\t\treturn this.segment(segment, v, build);\n\t};\n\n\t// mutating query string\n\tvar q = p.query;\n\tp.query = function(v, build) {\n\t\tif (v === true) {\n\t\t\treturn URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\t} else if (typeof v === 'function') {\n\t\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\t\tvar result = v.call(this, data);\n\t\t\tthis._parts.query = URI.buildQuery(result || data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t} else if (v !== undefined && typeof v !== 'string') {\n\t\t\tthis._parts.query = URI.buildQuery(v, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t} else {\n\t\t\treturn q.call(this, v, build);\n\t\t}\n\t};\n\tp.setQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\n\t\tif (typeof name === 'string' || name instanceof String) {\n\t\t\tdata[name] = value !== undefined ? value : null;\n\t\t} else if (typeof name === 'object') {\n\t\t\tfor (var key in name) {\n\t\t\t\tif (hasOwn.call(name, key)) {\n\t\t\t\t\tdata[key] = name[key];\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new TypeError('URI.addQuery() accepts an object, string as the name parameter');\n\t\t}\n\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.addQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\tURI.addQuery(data, name, value === undefined ? null : value);\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.removeQuery = function(name, value, build) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\tURI.removeQuery(data, name, value);\n\t\tthis._parts.query = URI.buildQuery(data, this._parts.duplicateQueryParameters, this._parts.escapeQuerySpace);\n\t\tif (typeof name !== 'string') {\n\t\t\tbuild = value;\n\t\t}\n\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.hasQuery = function(name, value, withinArray) {\n\t\tvar data = URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace);\n\t\treturn URI.hasQuery(data, name, value, withinArray);\n\t};\n\tp.setSearch = p.setQuery;\n\tp.addSearch = p.addQuery;\n\tp.removeSearch = p.removeQuery;\n\tp.hasSearch = p.hasQuery;\n\n\t// sanitizing URLs\n\tp.normalize = function() {\n\t\tif (this._parts.urn) {\n\t\t\treturn this\n\t\t\t\t.normalizeProtocol(false)\n\t\t\t\t.normalizePath(false)\n\t\t\t\t.normalizeQuery(false)\n\t\t\t\t.normalizeFragment(false)\n\t\t\t\t.build();\n\t\t}\n\n\t\treturn this\n\t\t\t.normalizeProtocol(false)\n\t\t\t.normalizeHostname(false)\n\t\t\t.normalizePort(false)\n\t\t\t.normalizePath(false)\n\t\t\t.normalizeQuery(false)\n\t\t\t.normalizeFragment(false)\n\t\t\t.build();\n\t};\n\tp.normalizeProtocol = function(build) {\n\t\tif (typeof this._parts.protocol === 'string') {\n\t\t\tthis._parts.protocol = this._parts.protocol.toLowerCase();\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeHostname = function(build) {\n\t\tif (this._parts.hostname) {\n\t\t\tif (this.is('IDN') && punycode) {\n\t\t\t\tthis._parts.hostname = punycode.toASCII(this._parts.hostname);\n\t\t\t} else if (this.is('IPv6') && IPv6) {\n\t\t\t\tthis._parts.hostname = IPv6.best(this._parts.hostname);\n\t\t\t}\n\n\t\t\tthis._parts.hostname = this._parts.hostname.toLowerCase();\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizePort = function(build) {\n\t\t// remove port of it's the protocol's default\n\t\tif (typeof this._parts.protocol === 'string' && this._parts.port === URI.defaultPorts[this._parts.protocol]) {\n\t\t\tthis._parts.port = null;\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizePath = function(build) {\n\t\tvar _path = this._parts.path;\n\t\tif (!_path) {\n\t\t\treturn this;\n\t\t}\n\n\t\tif (this._parts.urn) {\n\t\t\tthis._parts.path = URI.recodeUrnPath(this._parts.path);\n\t\t\tthis.build(!build);\n\t\t\treturn this;\n\t\t}\n\n\t\tif (this._parts.path === '/') {\n\t\t\treturn this;\n\t\t}\n\n\t\tvar _was_relative;\n\t\tvar _leadingParents = '';\n\t\tvar _parent, _pos;\n\n\t\t// handle relative paths\n\t\tif (_path.charAt(0) !== '/') {\n\t\t\t_was_relative = true;\n\t\t\t_path = '/' + _path;\n\t\t}\n\n\t\t// handle relative files (as opposed to directories)\n\t\tif (_path.slice(-3) === '/..' || _path.slice(-2) === '/.') {\n\t\t\t_path += '/';\n\t\t}\n\n\t\t// resolve simples\n\t\t_path = _path\n\t\t\t.replace(/(\\/(\\.\\/)+)|(\\/\\.$)/g, '/')\n\t\t\t.replace(/\\/{2,}/g, '/');\n\n\t\t// remember leading parents\n\t\tif (_was_relative) {\n\t\t\t_leadingParents = _path.substring(1).match(/^(\\.\\.\\/)+/) || '';\n\t\t\tif (_leadingParents) {\n\t\t\t\t_leadingParents = _leadingParents[0];\n\t\t\t}\n\t\t}\n\n\t\t// resolve parents\n\t\twhile (true) {\n\t\t\t_parent = _path.indexOf('/..');\n\t\t\tif (_parent === -1) {\n\t\t\t\t// no more ../ to resolve\n\t\t\t\tbreak;\n\t\t\t} else if (_parent === 0) {\n\t\t\t\t// top level cannot be relative, skip it\n\t\t\t\t_path = _path.substring(3);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t_pos = _path.substring(0, _parent).lastIndexOf('/');\n\t\t\tif (_pos === -1) {\n\t\t\t\t_pos = _parent;\n\t\t\t}\n\t\t\t_path = _path.substring(0, _pos) + _path.substring(_parent + 3);\n\t\t}\n\n\t\t// revert to relative\n\t\tif (_was_relative && this.is('relative')) {\n\t\t\t_path = _leadingParents + _path.substring(1);\n\t\t}\n\n\t\t_path = URI.recodePath(_path);\n\t\tthis._parts.path = _path;\n\t\tthis.build(!build);\n\t\treturn this;\n\t};\n\tp.normalizePathname = p.normalizePath;\n\tp.normalizeQuery = function(build) {\n\t\tif (typeof this._parts.query === 'string') {\n\t\t\tif (!this._parts.query.length) {\n\t\t\t\tthis._parts.query = null;\n\t\t\t} else {\n\t\t\t\tthis.query(URI.parseQuery(this._parts.query, this._parts.escapeQuerySpace));\n\t\t\t}\n\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeFragment = function(build) {\n\t\tif (!this._parts.fragment) {\n\t\t\tthis._parts.fragment = null;\n\t\t\tthis.build(!build);\n\t\t}\n\n\t\treturn this;\n\t};\n\tp.normalizeSearch = p.normalizeQuery;\n\tp.normalizeHash = p.normalizeFragment;\n\n\tp.iso8859 = function() {\n\t\t// expect unicode input, iso8859 output\n\t\tvar e = URI.encode;\n\t\tvar d = URI.decode;\n\n\t\tURI.encode = escape;\n\t\tURI.decode = decodeURIComponent;\n\t\ttry {\n\t\t\tthis.normalize();\n\t\t} finally {\n\t\t\tURI.encode = e;\n\t\t\tURI.decode = d;\n\t\t}\n\t\treturn this;\n\t};\n\n\tp.unicode = function() {\n\t\t// expect iso8859 input, unicode output\n\t\tvar e = URI.encode;\n\t\tvar d = URI.decode;\n\n\t\tURI.encode = strictEncodeURIComponent;\n\t\tURI.decode = unescape;\n\t\ttry {\n\t\t\tthis.normalize();\n\t\t} finally {\n\t\t\tURI.encode = e;\n\t\t\tURI.decode = d;\n\t\t}\n\t\treturn this;\n\t};\n\n\tp.readable = function() {\n\t\tvar uri = this.clone();\n\t\t// removing username, password, because they shouldn't be displayed according to RFC 3986\n\t\turi.username('').password('').normalize();\n\t\tvar t = '';\n\t\tif (uri._parts.protocol) {\n\t\t\tt += uri._parts.protocol + '://';\n\t\t}\n\n\t\tif (uri._parts.hostname) {\n\t\t\tif (uri.is('punycode') && punycode) {\n\t\t\t\tt += punycode.toUnicode(uri._parts.hostname);\n\t\t\t\tif (uri._parts.port) {\n\t\t\t\t\tt += ':' + uri._parts.port;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tt += uri.host();\n\t\t\t}\n\t\t}\n\n\t\tif (uri._parts.hostname && uri._parts.path && uri._parts.path.charAt(0) !== '/') {\n\t\t\tt += '/';\n\t\t}\n\n\t\tt += uri.path(true);\n\t\tif (uri._parts.query) {\n\t\t\tvar q = '';\n\t\t\tfor (var i = 0, qp = uri._parts.query.split('&'), l = qp.length; i < l; i++) {\n\t\t\t\tvar kv = (qp[i] || '').split('=');\n\t\t\t\tq += '&' + URI.decodeQuery(kv[0], this._parts.escapeQuerySpace)\n\t\t\t\t\t.replace(/&/g, '%26');\n\n\t\t\t\tif (kv[1] !== undefined) {\n\t\t\t\t\tq += '=' + URI.decodeQuery(kv[1], this._parts.escapeQuerySpace)\n\t\t\t\t\t\t.replace(/&/g, '%26');\n\t\t\t\t}\n\t\t\t}\n\t\t\tt += '?' + q.substring(1);\n\t\t}\n\n\t\tt += URI.decodeQuery(uri.hash(), true);\n\t\treturn t;\n\t};\n\n\t// resolving relative and absolute URLs\n\tp.absoluteTo = function(base) {\n\t\tvar resolved = this.clone();\n\t\tvar properties = ['protocol', 'username', 'password', 'hostname', 'port'];\n\t\tvar basedir, i, p;\n\n\t\tif (this._parts.urn) {\n\t\t\tthrow new Error('URNs do not have any generally defined hierarchical components');\n\t\t}\n\n\t\tif (!(base instanceof URI)) {\n\t\t\tbase = new URI(base);\n\t\t}\n\n\t\tif (!resolved._parts.protocol) {\n\t\t\tresolved._parts.protocol = base._parts.protocol;\n\t\t}\n\n\t\tif (this._parts.hostname) {\n\t\t\treturn resolved;\n\t\t}\n\n\t\tfor (i = 0; (p = properties[i]); i++) {\n\t\t\tresolved._parts[p] = base._parts[p];\n\t\t}\n\n\t\tif (!resolved._parts.path) {\n\t\t\tresolved._parts.path = base._parts.path;\n\t\t\tif (!resolved._parts.query) {\n\t\t\t\tresolved._parts.query = base._parts.query;\n\t\t\t}\n\t\t} else if (resolved._parts.path.substring(-2) === '..') {\n\t\t\tresolved._parts.path += '/';\n\t\t}\n\n\t\tif (resolved.path().charAt(0) !== '/') {\n\t\t\tbasedir = base.directory();\n\t\t\tbasedir = basedir ? basedir : base.path().indexOf('/') === 0 ? '/' : '';\n\t\t\tresolved._parts.path = (basedir ? (basedir + '/') : '') + resolved._parts.path;\n\t\t\tresolved.normalizePath();\n\t\t}\n\n\t\tresolved.build();\n\t\treturn resolved;\n\t};\n\tp.relativeTo = function(base) {\n\t\tvar relative = this.clone().normalize();\n\t\tvar relativeParts, baseParts, common, relativePath, basePath;\n\n\t\tif (relative._parts.urn) {\n\t\t\tthrow new Error('URNs do not have any generally defined hierarchical components');\n\t\t}\n\n\t\tbase = new URI(base).normalize();\n\t\trelativeParts = relative._parts;\n\t\tbaseParts = base._parts;\n\t\trelativePath = relative.path();\n\t\tbasePath = base.path();\n\n\t\tif (relativePath.charAt(0) !== '/') {\n\t\t\tthrow new Error('URI is already relative');\n\t\t}\n\n\t\tif (basePath.charAt(0) !== '/') {\n\t\t\tthrow new Error('Cannot calculate a URI relative to another relative URI');\n\t\t}\n\n\t\tif (relativeParts.protocol === baseParts.protocol) {\n\t\t\trelativeParts.protocol = null;\n\t\t}\n\n\t\tif (relativeParts.username !== baseParts.username || relativeParts.password !== baseParts.password) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativeParts.protocol !== null || relativeParts.username !== null || relativeParts.password !== null) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativeParts.hostname === baseParts.hostname && relativeParts.port === baseParts.port) {\n\t\t\trelativeParts.hostname = null;\n\t\t\trelativeParts.port = null;\n\t\t} else {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tif (relativePath === basePath) {\n\t\t\trelativeParts.path = '';\n\t\t\treturn relative.build();\n\t\t}\n\n\t\t// determine common sub path\n\t\tcommon = URI.commonPath(relativePath, basePath);\n\n\t\t// If the paths have nothing in common, return a relative URL with the absolute path.\n\t\tif (!common) {\n\t\t\treturn relative.build();\n\t\t}\n\n\t\tvar parents = baseParts.path\n\t\t\t.substring(common.length)\n\t\t\t.replace(/[^\\/]*$/, '')\n\t\t\t.replace(/.*?\\//g, '../');\n\n\t\trelativeParts.path = (parents + relativeParts.path.substring(common.length)) || './';\n\n\t\treturn relative.build();\n\t};\n\n\t// comparing URIs\n\tp.equals = function(uri) {\n\t\tvar one = this.clone();\n\t\tvar two = new URI(uri);\n\t\tvar one_map = {};\n\t\tvar two_map = {};\n\t\tvar checked = {};\n\t\tvar one_query, two_query, key;\n\n\t\tone.normalize();\n\t\ttwo.normalize();\n\n\t\t// exact match\n\t\tif (one.toString() === two.toString()) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// extract query string\n\t\tone_query = one.query();\n\t\ttwo_query = two.query();\n\t\tone.query('');\n\t\ttwo.query('');\n\n\t\t// definitely not equal if not even non-query parts match\n\t\tif (one.toString() !== two.toString()) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// query parameters have the same length, even if they're permuted\n\t\tif (one_query.length !== two_query.length) {\n\t\t\treturn false;\n\t\t}\n\n\t\tone_map = URI.parseQuery(one_query, this._parts.escapeQuerySpace);\n\t\ttwo_map = URI.parseQuery(two_query, this._parts.escapeQuerySpace);\n\n\t\tfor (key in one_map) {\n\t\t\tif (hasOwn.call(one_map, key)) {\n\t\t\t\tif (!isArray(one_map[key])) {\n\t\t\t\t\tif (one_map[key] !== two_map[key]) {\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t} else if (!arraysEqual(one_map[key], two_map[key])) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\n\t\t\t\tchecked[key] = true;\n\t\t\t}\n\t\t}\n\n\t\tfor (key in two_map) {\n\t\t\tif (hasOwn.call(two_map, key)) {\n\t\t\t\tif (!checked[key]) {\n\t\t\t\t\t// two contains a parameter not present in one\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t};\n\n\t// state\n\tp.duplicateQueryParameters = function(v) {\n\t\tthis._parts.duplicateQueryParameters = !!v;\n\t\treturn this;\n\t};\n\n\tp.escapeQuerySpace = function(v) {\n\t\tthis._parts.escapeQuerySpace = !!v;\n\t\treturn this;\n\t};\n\n\treturn URI;\n}));","Workflow = {}\n\n@ImageSign = {};\n\n@TracesHandler = {};\n\n@TracesTemplate = {};\n\n@InstanceformTemplate = {};\n\n@InstanceAttachmentTemplate = {};\n\n@InstanceSignText = {}\n\n@RelatedInstances = {}\n\n@RelatedRecords = {}\n\n@InstanceMacro = {context: {}}\n\n@TracesManager = {};\n\nInstanceSignText.isOpinionField_from_string = (field_formula)->\n\treturn (field_formula?.indexOf(\"{traces.\") > -1 || field_formula?.indexOf(\"{signature.traces.\") > -1 || field_formula?.indexOf(\"{yijianlan:\") > -1 || field_formula?.indexOf(\"{\\\"yijianlan\\\":\") > -1 || field_formula?.indexOf(\"{'yijianlan':\") > -1)\n\nInstanceSignText.includesOpinionField = (form, form_version)->\n\tfield_formulas = new Array();\n\n\t_form_version = {}\n\n\tif Meteor.isServer\n\t\t_form_version = uuflowManager.getFormVersion(db.forms.findOne({_id: form}), form_version)\n\telse\n\t\t_form_version = db.form_versions.findOne({_id: form_version, form: form})\n\n\tfields = _form_version?.fields || []\n\n\tfields.forEach (f)->\n\t\tif f.type == 'table'\n\t\t\tconsole.log 'ignore opinion field in table'\n\t\telse if f.type == 'section'\n\t\t\tf?.fields?.forEach (f1)->\n\t\t\t\tfield_formulas.push f1.formula\n\t\telse\n\t\t\tfield_formulas.push f.formula\n\n\t_.some field_formulas, (field_formula)->\n\t\treturn InstanceformTemplate.helpers.isOpinionField_from_string(field_formula)\n\n"," \n\nWorkflow = {};\n\nthis.ImageSign = {};\n\nthis.TracesHandler = {};\n\nthis.TracesTemplate = {};\n\nthis.InstanceformTemplate = {};\n\nthis.InstanceAttachmentTemplate = {};\n\nthis.InstanceSignText = {};\n\nthis.RelatedInstances = {};\n\nthis.RelatedRecords = {};\n\nthis.InstanceMacro = {\n context: {}\n};\n\nthis.TracesManager = {};\n\nInstanceSignText.isOpinionField_from_string = function(field_formula) {\n return (field_formula != null ? field_formula.indexOf(\"{traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{signature.traces.\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{yijianlan:\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{\\\"yijianlan\\\":\") : void 0) > -1 || (field_formula != null ? field_formula.indexOf(\"{'yijianlan':\") : void 0) > -1;\n};\n\nInstanceSignText.includesOpinionField = function(form, form_version) {\n var _form_version, field_formulas, fields;\n field_formulas = new Array();\n _form_version = {};\n if (Meteor.isServer) {\n _form_version = uuflowManager.getFormVersion(db.forms.findOne({\n _id: form\n }), form_version);\n } else {\n _form_version = db.form_versions.findOne({\n _id: form_version,\n form: form\n });\n }\n fields = (_form_version != null ? _form_version.fields : void 0) || [];\n fields.forEach(function(f) {\n var ref;\n if (f.type === 'table') {\n return console.log('ignore opinion field in table');\n } else if (f.type === 'section') {\n return f != null ? (ref = f.fields) != null ? ref.forEach(function(f1) {\n return field_formulas.push(f1.formula);\n }) : void 0 : void 0;\n } else {\n return field_formulas.push(f.formula);\n }\n });\n return _.some(field_formulas, function(field_formula) {\n return InstanceformTemplate.helpers.isOpinionField_from_string(field_formula);\n });\n};\n","db.instance_tasks = new Meteor.Collection('instance_tasks')\n\ndb.instance_tasks._simpleSchema = new SimpleSchema\n instance:\n type: String\n trace:\n type: String\n is_finished:\n type: String\n user:\n type: String\n user_name:\n type: String\n handler:\n type: String\n handler_name:\n type: String\n handler_organization:\n type: String\n handler_organization_name:\n type: String\n handler_organization_fullname:\n type: String\n start_date:\n type: Date\n due_date:\n type: Date\n is_read:\n type: Boolean\n is_error:\n type: Boolean\n values:\n type: Object\n deadline:\n type: Date\n remind_date:\n type: Date\n reminded_count:\n type: Number\n read_date:\n type: Date\n description:\n type: String\n modified:\n type: Date\n modified_by:\n type: String\n sign_show:\n type: Boolean\n judge:\n type: String\n next_steps:\n type: Array\n \"next_steps.$\":\n type: Object\n \"next_steps.$.step\":\n type: String\n \"next_steps.$.users\":\n type: [String]\n finish_date:\n type: Date\n cost_time:\n type: Number\n space:\n type: String\n instance_name:\n type: String\n submitter:\n type: String\n submitter_name:\n type: String\n applicant:\n type: String\n applicant_name:\n type: String\n applicant_organization_name:\n type: String\n submit_date:\n type: Date\n flow:\n type: String\n flow_name:\n type: String\n form:\n type: String\n step:\n type: String\n step_name:\n type: String\n category_name:\n type: String\n instance_state:\n type: String\n distribute_from_instance:\n type: String\n forward_from_instance:\n type: String\n keywords:\n type: String\n is_archived:\n type: Boolean\n category:\n type: String\n","db.auth_tokens = new Meteor.Collection('auth_tokens')","marked = require(\"marked\")\n\nInstanceReadOnlyTemplate = {};\n\n\nInstanceReadOnlyTemplate.instance_attachment = \"\"\"\n\t\n\t\t\n\t\t\t{{this.name}}\n\t\t\n\t\n\"\"\"\n\nInstanceReadOnlyTemplate.afSelectUserRead = \"\"\"\n\t
{{value}}
\n\"\"\"\n\n\nInstanceReadOnlyTemplate.afFormGroupRead = \"\"\"\n\t
\n\t\t{{#with getField this.name}}\n\t\t\t{{#if equals type 'section'}}\n\t\t\t\t\t
\n\t\t\t\t\t\t\n\t\t\t\t\t\t

{{{description}}}

\n\t\t\t\t\t
\n\t\t\t{{else}}\n\t\t\t\t{{#if equals type 'table'}}\n\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t{{{description}}}\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if showLabel}}\n\t\t\t\t\t\t\n\t\t\t\t\t{{/if}}\n\t\t\t\t\t{{#if isTextarea this}}\n\t\t\t\t\t\t

{{{getValue code}}}

\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t
{{{getValue code}}}
\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/if}}\n\t\t{{/with}}\n\t
\n\"\"\"\n\nInstanceReadOnlyTemplate.afFormGroup = \"\"\"\n\n\t{{#with getField this.name}}\n\t\t\t{{#if equals type 'section'}}\n\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t\n\t\t\t\t\t\t

{{{description}}}

\n\t\t\t\t\t
\n \t\t\t\t
\n\t\t\t{{else}}\n\t\t\t\t{{#if equals type 'table'}}\n\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t{{{description}}}\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if equals type 'input'}}\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t{{#if is_textarea}}\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t{{#unless is_textarea}}\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t{{/unless}}\n\t\t\t\t\t\t
\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t{{#if equals type 'number'}}\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t{{#if equals type 'date'}}\n\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t{{#if equals type 'dateTime'}}\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t{{#if equals type 'password'}}\n\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t{{#if equals type 'select'}}\n\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'radio'}}\n\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n \t\t\t\t\t\t\t\t\t\t\t\t\n \t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n \t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'multiSelect'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'url'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'email'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'checkbox'}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
{{{getValue code}}}
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t\t{{/if}}\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/if}}\n\t\t{{/with}}\n\"\"\"\n\nInstanceReadOnlyTemplate.create = (tempalteName, steedosData) ->\n\ttemplate = InstanceReadOnlyTemplate[tempalteName]\n\n\ttemplateCompiled = SpacebarsCompiler.compile(template, {isBody: true});\n\n\ttemplateRenderFunction = eval(templateCompiled);\n\n\tTemplate[tempalteName] = new Blaze.Template(tempalteName, templateRenderFunction);\n\tTemplate[tempalteName].steedosData = steedosData\n\tTemplate[tempalteName].helpers InstanceformTemplate.helpers\n\nInstanceReadOnlyTemplate.createInstanceSignText = (steedosData)->\n\tinstanceSignTextHtml = _getViewHtml('client/views/instance/instance_sign_text.html')\n\n\tinstanceSignTextCompiled = SpacebarsCompiler.compile(instanceSignTextHtml, {isBody: true});\n\n\tinstanceSignTextRenderFunction = eval(instanceSignTextCompiled);\n\n\tTemplate.instanceSignText = new Blaze.Template(\"instanceSignText\", instanceSignTextRenderFunction);\n\tTemplate.instanceSignText.steedosData = steedosData\n\tTemplate.instanceSignText.helpers InstanceSignText.helpers\n\nInstanceReadOnlyTemplate.createImageSign = (steedosData) ->\n\timageSignHtml = _getViewHtml('client/views/instance/image_sign.html')\n\timageSignCompiled = SpacebarsCompiler.compile(imageSignHtml, {isBody: true});\n\timageSignRenderFunction = eval(imageSignCompiled);\n\tTemplate.imageSign = new Blaze.Template(\"imageSign\", imageSignRenderFunction);\n\tTemplate.imageSign.steedosData = steedosData\n\tTemplate.imageSign.helpers ImageSign.helpers\n\nInstanceReadOnlyTemplate.createTracesHanlder = (steedosData) ->\n\ttracesHanlderHtml = _getViewHtml('client/views/instance/traces_handler.html')\n\ttracesHanlderCompiled = SpacebarsCompiler.compile(tracesHanlderHtml, {isBody: true});\n\ttracesHanlderRenderFunction = eval(tracesHanlderCompiled);\n\tTemplate.instance_traces_handler = new Blaze.Template(\"instance_traces_handler\", tracesHanlderRenderFunction);\n\tTemplate.instance_traces_handler.steedosData = steedosData\n\tTemplate.instance_traces_handler.helpers TracesHandler.helpers\n\n\nInstanceReadOnlyTemplate.init = (steedosData) ->\n\tInstanceReadOnlyTemplate.create(\"afSelectUserRead\", steedosData);\n\n\tif Meteor.isServer\n\t\tInstanceReadOnlyTemplate.create(\"afFormGroup\", steedosData);\n\n\tInstanceReadOnlyTemplate.create(\"afFormGroupRead\", steedosData);\n\tif Meteor.isServer\n\t\tInstanceReadOnlyTemplate.create(\"instance_attachment\", {absolute: steedosData.absolute});\n\t\tInstanceReadOnlyTemplate.createImageSign(steedosData)\n\t\tInstanceReadOnlyTemplate.createTracesHanlder(steedosData);\n\t\tInstanceReadOnlyTemplate.createInstanceSignText(steedosData)\n\ngetLinkText = (item, label, detail_url)->\n\tif detail_url\n\t\tdetail_url = detail_url.replace(\"{_id}\", item._id)\n\t\tif !/^http(s?):\\/\\//.test(detail_url)\n\t\t\tdetail_url = Steedos.absoluteUrl(detail_url)\n\t\treturn ''+label+'';\n\telse\n\t\treturn label\n\nInstanceReadOnlyTemplate.getValue = (value, field, locale, utcOffset) ->\n\tif !value && value != false\n\t\treturn ''\n\tif [\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1\n\t\tfieldOptions = field.options.split(\"\\n\").map (n)->\n\t\t\titemSplits = n.split(\":\")\n\t\t\treturn {\n\t\t\t\tlabel: itemSplits[0],\n\t\t\t\tvalue: itemSplits[1] || n\n\t\t\t}\n\tswitch field.type\n\t\twhen 'email'\n\t\t\tvalue = if value then '' + value + '' else ''\n\t\twhen 'url'\n\t\t\tif value\n\t\t\t\tif value.indexOf(\"http\") == 0\n\t\t\t\t\ttry\n\t\t\t\t\t\tvalue = \"\" + value + \"\";\n\t\t\t\t\tcatch e\n\t\t\t\t\t\tvalue = \"\" + value + \"\";\n\n\t\t\t\telse\n\t\t\t\t\tvalue = \"\" + value + \"\";\n\t\t\telse\n\t\t\t\tvalue = ''\n\t\twhen 'group'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = value?.getProperty(\"fullname\").toString()\n\t\t\telse\n\t\t\t\tvalue = value?.fullname\n\t\twhen 'user'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = value?.getProperty(\"name\").toString()\n\t\t\telse\n\t\t\t\tvalue = value?.name\n\t\twhen 'password'\n\t\t\tvalue = '******'\n\t\twhen 'checkbox'\n\t\t\tif value && value != 'false'\n\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_yes\", {}, locale)\n\t\t\telse\n\t\t\t\tvalue = TAPi18n.__(\"form_field_checkbox_no\", {}, locale)\n\t\twhen 'dateTime'\n\t\t\tif value && value.length == 16\n\t\t\t\tt = value.split(\"T\")\n\t\t\t\tt0 = t[0].split(\"-\");\n\t\t\t\tt1 = t[1].split(\":\");\n\n\t\t\t\tyear = t0[0];\n\t\t\t\tmonth = t0[1];\n\t\t\t\tdate = t0[2];\n\t\t\t\thours = t1[0];\n\t\t\t\tseconds = t1[1];\n\n\t\t\t\tvalue = new Date(year, month - 1, date, hours, seconds)\n\t\t\telse\n\t\t\t\tvalue = new Date(value)\n\n\t\t\tvalue = InstanceReadOnlyTemplate.formatDate(value, utcOffset);\n\t\twhen 'time'\n\t\t\tif value && value.length == 16\n\t\t\t\tt = value.split(\"T\")\n\t\t\t\tt0 = t[0].split(\"-\");\n\t\t\t\tt1 = t[1].split(\":\");\n\n\t\t\t\tyear = t0[0];\n\t\t\t\tmonth = t0[1];\n\t\t\t\tdate = t0[2];\n\t\t\t\thours = t1[0];\n\t\t\t\tseconds = t1[1];\n\n\t\t\t\tvalue = new Date(year, month - 1, date, hours, seconds)\n\t\t\telse\n\t\t\t\tvalue = new Date(value)\n\n\t\t\tvalue = InstanceReadOnlyTemplate.formatTime(value);\n\t\twhen 'input'\n\t\t\tif field.is_textarea\n\t\t\t\tvalue = value\n\t\twhen 'select'\n\t\t\tselectedOption = fieldOptions.find((item) -> return item.value == value)\n\t\t\tif selectedOption\n\t\t\t\tvalue = selectedOption.label\n\t\twhen 'radio'\n\t\t\tselectedOption = fieldOptions.find((item) -> return item.value == value)\n\t\t\tif selectedOption\n\t\t\t\tvalue = selectedOption.label\n\t\twhen 'multiSelect'\n\t\t\tsplitedValues = value.split(\",\")\n\t\t\tselectedOptions = fieldOptions.filter((item) -> return splitedValues.indexOf(item.value) > -1)\n\t\t\tif selectedOptions.length\n\t\t\t\tvalue = selectedOptions.map((item) -> return item.label).join(\",\")\n\t\twhen 'number'\n\t\t\tif value or value == 0\n\t\t\t\tif field.is_percent\n\t\t\t\t\tvalue = Steedos.numberToPercentString value, field.digits\n\t\t\t\telse\n\t\t\t\t\tvalue = Steedos.numberToString value, field.digits\n\t\twhen 'odata'\n\t\t\tdetail_url = field.detail_url\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = _.map value, (item)->\n\t\t\t\t\treturn getLinkText(item, item['@label'], detail_url)\n\t\t\telse\n\t\t\t\tvalue = getLinkText(value, value['@label'], detail_url)\n\t\twhen 'image'\n\t\t\tif field.is_multiselect\n\t\t\t\tvalue = _.map value, (item)->\n\t\t\t\t\treturn '
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
'\n\t\t\t\tvalue = value.join(\"\");\n\t\t\telse\n\t\t\t\tvalue = '
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
'\n\t\twhen 'file'\n\t\t\tif value\n\t\t\t\tif !field.is_multiselect\n\t\t\t\t\tvalue = [value]\n\t\t\t\tif Meteor.isClient\n\t\t\t\t\tres = Steedos.authRequest('/api/v1/cfs_files_filerecord?filters=[[\"_id\",\"in\", '+JSON.stringify(value)+']]&fields=[\"_id\",\"original\"]', {async:false})\n\t\t\t\t\trecords = res.data.items\n\t\t\t\telse if Meteor.isServer\n\t\t\t\t\trecords = Steedos.objectFind(\"cfs_files_filerecord\", { filters: [[\"_id\", 'in', value]], fields: [\"_id\", \"original\"] });\n\n\t\t\t\tvalue = _.map records, (item)->\n\t\t\t\t\tfileName = item.original.name;\n\t\t\t\t\tfileUrl = Steedos.absoluteUrl('/api/files/files/'+item._id);\n\t\t\t\t\tfilePreviewHtml = '';\n\t\t\t\t\tif [\".pdf\", \".jpg\", \".jpeg\", \".png\", \".gif\"].indexOf(fileName.slice(-4)) > -1\n\t\t\t\t\t\tfilePreviewHtml = \" 预览\"\n\t\t\t\t\treturn \"
#{fileName} #{filePreviewHtml ? filePreviewHtml : ''}
\"\n\n\t\t\t\tvalue = value.join(\"\");\n\t\twhen 'lookup'\n\t\t\tif value\n\t\t\t\tif !field.is_multiselect\n\t\t\t\t\tvalue = [value]\n\t\t\t\tif Meteor.isClient\n\t\t\t\t\tuiSchema = Creator.getObject(field.reference_to)\n\t\t\t\t\tnameField = uiSchema?.NAME_FIELD_KEY || 'name'\n\t\t\t\t\tres = Steedos.authRequest('/api/v1/'+field.reference_to+'?filters=[[\"'+(field.reference_to_field || '_id')+'\",\"in\", '+JSON.stringify(value)+']]&fields=[\"_id\",\"'+nameField+'\"]', {async:false})\n\t\t\t\t\trecords = res.data.items\n\t\t\t\telse if Meteor.isServer\n\t\t\t\t\tnameField = Steedos.getObjectNameFieldKey(field.reference_to);\n\t\t\t\t\trecords = Steedos.objectFind(field.reference_to, { filters: [[(field.reference_to_field || '_id'), 'in', value]], fields: [\"_id\", nameField] });\n\t\t\t\tvalue = _.map records, (item)->\n\t\t\t\t\treturn \"#{item[nameField]}\"\n\n\t\t\t\tvalue = value.join(\" , \");\t\n\t\twhen 'html'\n\t\t\tvalue = if value then \"
#{value}
\" else ''\n\n\treturn value;\n\nInstanceReadOnlyTemplate.getLabel = (fields, code) ->\n\tfield = fields.findPropertyByPK(\"code\", code)\n\tif field\n\t\tif field.name\n\t\t\treturn field.name\n\t\telse\n\t\t\treturn field.code\n\n\nInstanceReadOnlyTemplate.getInstanceFormVersion = (instance)->\n\tform = db.forms.findOne(instance.form);\n\n\tform_version = {}\n\n\tform_fields = [];\n\n\tif form.current._id == instance.form_version\n\t\tform_version = form.current\n\telse\n\t\tform_version = _.where(form.historys, {_id: instance.form_version})[0]\n\n\tform_version.fields.forEach (field)->\n\t\tif field.type == 'section'\n\t\t\tform_fields.push(field);\n\t\t\tif field.fields\n\t\t\t\tfield.fields.forEach (f) ->\n\t\t\t\t\tform_fields.push(f);\n\t\telse if field.type == 'table'\n\t\t\tfield['sfields'] = field['fields']\n\t\t\tdelete field['fields']\n\t\t\tform_fields.push(field);\n\t\telse\n\t\t\tform_fields.push(field);\n\n\tform_version.fields = form_fields;\n\n\treturn form_version;\n\nInstanceReadOnlyTemplate.getFlowVersion = (instance)->\n\tflow = db.flows.findOne(instance.flow);\n\tflow_version = {}\n\tif flow.current._id == instance.flow_version\n\t\tflow_version = flow.current\n\telse\n\t\tflow_version = _.where(flow.historys, {_id: instance.flow_version})[0]\n\n\treturn flow_version;\n\n\n_getViewHtml = (path) ->\n\tviewHtml = Assets.getText(path)\n\n\tif viewHtml\n\t\tviewHtml = viewHtml.replace(//i,\"\").replace(/<\\/template>/i,\"\")\n\n\treturn viewHtml;\n\n_getLocale = (user)->\n\tif user?.locale?.toLocaleLowerCase() == 'zh-cn'\n\t\tlocale = \"zh-CN\"\n\telse if user?.locale?.toLocaleLowerCase() == 'en-us'\n\t\tlocale = \"en\"\n\telse\n\t\tlocale = \"zh-CN\"\n\treturn locale\n\n\n_getRequiredFields = (fields, rev)->\n\tif !rev\n\t\trev = [];\n\n\tfields.forEach (field)->\n\t\tif field.type == 'section'\n\t\t\t_getRequiredFields(field.fields, rev)\n\t\telse if field.type == 'table'\n\n\t\telse\n\t\t\tif field.is_required\n\t\t\t\trev.push field.code\n\treturn rev;\n\n_getStartStepEditableFields = (fields, steps)->\n\tstartStep = steps.findPropertyByPK(\"step_type\",\"start\")\n\n\teditableCode = []\n\n\t_.keys(startStep.permissions).forEach (key)->\n\t\tif startStep.permissions[key] == 'editable'\n\t\t\teditableCode.push key\n\n\treturn editableCode\n\n_getStartStepRequiredFields = (fields, steps)->\n\trequiredFields = _getRequiredFields(fields)\n\n\teditableCode = _getStartStepEditableFields(fields, steps)\n\n\treturn _.intersection(requiredFields, editableCode)\n\n_getTemplateData = (user, space, instance, options)->\n\tif Meteor.isServer\n\t\tform_version = InstanceReadOnlyTemplate.getInstanceFormVersion(instance)\n\telse\n\t\tform_version = WorkflowManager.getInstanceFormVersion(instance)\n\n\tlocale = _getLocale(user)\n\n\tsteedosData = {}\n\n\tif Meteor.isClient\n\t\tsteedosData = _.clone(WorkflowManager_format.getAutoformSchemaValues())\n\t\tsteedosData.insname = instance.name\n\t\tsteedosData.ins_state = instance.state\n\t\tsteedosData.ins_final_decision = instance.ins_final_decision\n\t\tsteedosData.ins_code = instance.code\n\t\tsteedosData.ins_is_archived = instance.is_archived\n\t\tsteedosData.ins_is_deleted = instance.ins_is_deleted\n\t\tsteedosData.applicant_name = instance.applicant_name\n\t\tsteedosData.applicantContext = instance.applicant_name\n\n\tsteedosData.instance = instance\n\tsteedosData.form_version = form_version\n\tsteedosData.locale = locale\n\tsteedosData.utcOffset = user.utcOffset\n\tsteedosData.space = instance.space\n\tsteedosData.sessionUserId = user._id\n\n\tif Meteor.isServer\n\t\tif options?.editable\n\t\t\tform = db.forms.findOne({_id: instance.form})\n\n\t\t\tflow = db.flows.findOne({_id: instance.flow})\n\n\t\t\tsteedosData.startStepEditableFields = _getStartStepEditableFields(form.current.fields, flow.current.steps);\n\n\treturn steedosData;\n\nInstanceReadOnlyTemplate.formatDate = (date, utcOffset)->\n\tif Meteor.isServer\n\t\tpassing = false;\n\telse\n\t\tpassing = true;\n\n\tif !utcOffset && utcOffset !=0\n\t\tutcOffset = 8\n\n\treturn moment(date).utcOffset(utcOffset, passing).format(\"YYYY-MM-DD HH:mm\");\n\nInstanceReadOnlyTemplate.formatTime = (date)->\n\tutcOffset = 0\n\treturn moment(date).utcOffset(utcOffset).format(\"HH:mm\");\n\nInstanceReadOnlyTemplate.getInstanceView = (user, space, instance, options)->\n\n\tsteedosData = _getTemplateData(user, space, instance, options)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\tinstanceTemplate = TemplateManager.getTemplate(instance, options?.templateName);\n\n\tinstanceTemplate = instanceTemplate.replace(/afSelectUser/g,\"afSelectUserRead\")\n\n\tif !options?.editable\n\t\tinstanceTemplate = instanceTemplate.replace(/afFormGroup/g,\"afFormGroupRead\")\n\n\tinstanceCompiled = SpacebarsCompiler.compile(instanceTemplate, {isBody: true});\n\n\tinstanceRenderFunction = eval(instanceCompiled);\n\n\tTemplate.instance_readonly_view = new Blaze.Template(\"instance_readonly_view\", instanceRenderFunction);\n\n\tTemplate.instance_readonly_view.steedosData = steedosData\n\n\tTemplate.instance_readonly_view.helpers InstanceformTemplate.helpers\n\n\tInstanceReadOnlyTemplate.init(steedosData);\n\n\tbody = Blaze.toHTMLWithData(Template.instance_readonly_view, steedosData)\n\n\treturn \"\"\"\n\t\t
\n\t\t\t#{body}\n\t\t
\n\t\"\"\"\n\nInstanceReadOnlyTemplate.getTracesView = (user, space, instance, options)->\n\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tform = db.forms.findOne(instance.form);\n\tif form.instance_style == \"table\" || options?.templateName == \"table\"\n\t\ttracesHtml = _getViewHtml('client/views/instance/traces_table.html')\n\telse\n\t\ttracesHtml = _getViewHtml('client/views/instance/traces.html')\n\n\ttraceCompiled = SpacebarsCompiler.compile(tracesHtml, {isBody: true});\n\n\ttraceRenderFunction = eval(traceCompiled);\n\n\tTemplate.trace_readonly_view = new Blaze.Template(\"trace_readonly_view\", traceRenderFunction);\n\n\tTemplate.trace_readonly_view.steedosData = steedosData\n\n\tTemplate.trace_readonly_view.helpers TracesTemplate.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.trace_readonly_view, instance.traces)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getAttachmentView = (user, space, instance)->\n\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tattachmentHtml = _getViewHtml('client/views/instance/instance_attachments.html')\n\n\tattachmentCompiled = SpacebarsCompiler.compile(attachmentHtml, {isBody: true});\n\n\tattachmentRenderFunction = eval(attachmentCompiled);\n\n\tTemplate.attachments_readonly_view = new Blaze.Template(\"attachments_readonly_view\", attachmentRenderFunction);\n\n\tTemplate.attachments_readonly_view.steedosData = steedosData\n\n\tTemplate.attachments_readonly_view.helpers InstanceAttachmentTemplate.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.attachments_readonly_view)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getRelatedInstancesView = (user, space, instance, options)->\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\trelatedInstancesHtml = _getViewHtml('client/views/instance/related_instances.html')\n\n\trelatedInstancesCompiled = SpacebarsCompiler.compile(relatedInstancesHtml, {isBody: true});\n\n\trelatedInstancesRenderFunction = eval(relatedInstancesCompiled);\n\n\tTemplate.related_instances_view = new Blaze.Template(\"related_instances_view\", relatedInstancesRenderFunction);\n\n\tTemplate.related_instances_view.steedosData = steedosData\n\n\tTemplate.related_instances_view.helpers RelatedInstances.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.related_instances_view, steedosData)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getRelatedRecordsView = (user, space, instance, options)->\n\tsteedosData = _getTemplateData(user, space, instance)\n\n\tsteedosData.absolute = false;\n\n\tif options?.absolute\n\t\tsteedosData.absolute = true;\n\n\trelatedRecordsHtml = _getViewHtml('client/views/instance/related_records.html')\n\n\trelatedRecordsCompiled = SpacebarsCompiler.compile(relatedRecordsHtml, {isBody: true});\n\n\trelatedRecordsRenderFunction = eval(relatedRecordsCompiled);\n\n\tTemplate.related_records_view = new Blaze.Template(\"related_records_view\", relatedRecordsRenderFunction);\n\n\tTemplate.related_records_view.steedosData = steedosData\n\n\tTemplate.related_records_view.helpers RelatedRecords.helpers\n\n\tbody = Blaze.toHTMLWithData(Template.related_records_view, steedosData)\n\n\treturn body;\n\nInstanceReadOnlyTemplate.getOnLoadScript = (instance)->\n\tform_version = WorkflowManager.getFormVersion(instance.form, instance.form_version)\n\n\tform_script = form_version.form_script;\n\n\tif form_script && form_script.replace(/\\n/g,\"\").replace(/\\s/g,\"\").length > 0\n\t\tform_script = \"CoreForm = {};CoreForm.instanceform = {};\" + form_script\n\t\tform_script += \";if(CoreForm.form_OnLoad){window.onload = CoreForm.form_OnLoad();}\"\n\telse\n\t\tform_script = \"\"\n\n\n\nInstanceReadOnlyTemplate.getInstanceHtml = (user, space, instance, options)->\n\n\tbody = InstanceReadOnlyTemplate.getInstanceView(user, space, instance, options);\n\n\tonLoadScript = InstanceReadOnlyTemplate.getOnLoadScript(instance);\n\n\tcreatorService = Meteor.settings.public.webservices?.creator?.url\n\tins_record_ids = instance.record_ids\n\tlocale = _getLocale(user);\n\topenFileScript = \"\"\"\n\t\t\tif(window.isNode && isNode()){\n\t\t\t\tattachs = document.getElementsByClassName(\"ins_attach_href\");\n\t\t\t\tfor(var i = 0; i < attachs.length; i++){\n\t\t\t\t\tattach = attachs[i];\n\t\t\t\t\tattach.addEventListener(\"click\", function(e){\n\t\t\t\t\t\tif(isImage(this.dataset.type) || isHtml(this.dataset.type)){\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\topenWindow(\"/api/files/instances/\" + this.dataset.id);\n\t\t\t\t\t\t}else if(nw_core.canOpenFile(this.dataset.name)){\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\tnw_core.openFile(this.href, this.dataset.name)\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tvar flow = \"#{instance.flow}\";\n\t\t\tvar space = \"#{instance.space}\";\n\n\t\t\tfunction getCookie(name){\n\t\t\t\tlet pattern = RegExp(name + \"=.[^;]*\")\n\t\t\t\tlet matched = document.cookie.match(pattern)\n\t\t\t\tif(matched){\n\t\t\t\t\tlet cookie = matched[0].split('=')\n\t\t\t\t\treturn cookie[1]\n\t\t\t\t}\n\t\t\t\treturn ''\n\t\t\t}\n\n\t\t\tvar records = document.getElementsByClassName(\"ins-related-records\");\n\t\t\tfor(var i = 0; i < records.length; i++){\n\t\t\t\t\tvar record = records[i];\n\t\t\t\t\trecord.addEventListener(\"click\", function(e){\n\t\t\t\t\t\tvar creatorService = \"#{creatorService}\"\n\t\t\t\t\t\tvar ins_record_ids = #{JSON.stringify(ins_record_ids)}\n\t\t\t\t\t\tif(creatorService && ins_record_ids && ins_record_ids.length > 0){\n\t\t\t\t\t\t\tvar objcetName = ins_record_ids[0].o\n\t\t\t\t\t\t\tvar id = ins_record_ids[0].ids[0]\n\t\t\t\t\t\t\tvar uobj = {};\n\t\t\t\t\t\t\tuobj[\"X-User-Id\"] = getCookie(\"X-User-Id\");\n\t\t\t\t\t\t\tuobj[\"X-Auth-Token\"] = getCookie(\"X-Auth-Token\");\n\t\t\t\t\t\t\tredirectUrl = creatorService + \"app/-/\" + objcetName + \"/view/\" + id + \"?\" + $.param(uobj);\n\t\t\t\t\t\t\topenWindow(redirectUrl);\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\"\"\";\n\n\n\tif !Steedos.isMobile()\n\t\tform = db.forms.findOne(instance.form);\n\t\tif form?.instance_style == 'table'\n\t\t\tinstance_style = \"instance-table\"\n\n\tif options?.templateName == 'table'\n\t\tinstance_style = \"instance-table\"\n\n\tif options?.instance_style\n\t\tinstance_style = options.instance_style\n\n\tif !options || options.showTrace == true\n\t\ttrace = InstanceReadOnlyTemplate.getTracesView(user, space, instance)\n\telse\n\t\ttrace = \"\"\n\n\tinstanceBoxStyle = \"\";\n\n\tif instance && instance.final_decision\n\t\tif instance.final_decision == \"approved\"\n\t\t\tinstanceBoxStyle = \"box-success\"\n\t\telse if (instance.final_decision == \"rejected\")\n\t\t\tinstanceBoxStyle = \"box-danger\"\n\tif !options || options.showAttachments == true\n\t\tattachment = InstanceReadOnlyTemplate.getAttachmentView(user, space, instance)\n\t\trelated_instances = InstanceReadOnlyTemplate.getRelatedInstancesView(user, space, instance, options)\n\t\trelated_records = InstanceReadOnlyTemplate.getRelatedRecordsView(user, space, instance, options)\n\telse\n\t\tattachment = \"\"\n\t\trelated_instances = \"\"\n\t\trelated_records = \"\"\n\n\n\twidth = \"960px\"\n\t#\t如果给table的parent设置width，则会导致阿里云邮箱显示table 异常\n\tif options?.width\n\t\twidth = \"\"\n\n\tcssHref = Meteor.absoluteUrl(\"steedos-css\")\n\t\n\tjqHref = Meteor.absoluteUrl(\"website/libs/jquery.min.js\")\n\n\tallCssLink = \"\"\"\"\"\"\n\n\ttraceCheck = \"\"\n\tif !_.isEmpty(trace)\n\t\ttraceCheck = \"checked\"\n\tif options?.tagger == 'email' || options?.editable\n\t\tshowTracesBtn = \"\"\n\telse\n\t\tshowTracesBtn = \"\"\"\n\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t
\n\t\t\t
\n\t\t\t\"\"\"\n\n\tshowTracesScript = \"\"\"\n\t\t$( document ).ready(function(){\n\t\t\tvar b = document.getElementById('cbx-print-traces');\n\t\t\tvar t = document.getElementsByClassName('instance-traces')[0];\n\t\t\tif (b && b.checked && t){\n\t\t\t\tt.style = 'display: block;'\n\t\t\t} else if(t){\n\t\t\t\tt.style = 'display: none;'\n\t\t\t}\n\t\t\tif(b){\n\t\t\t\tb.addEventListener('change', function(e){\n\t\t\t\t\tif (e.target.checked){\n\t\t\t\t\t\tt.style = 'display: block;'\n\t\t\t\t\t} else {\n\t\t\t\t\t\tt.style = 'display: none;'\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\n\n\t\t\tvar attachmentsCheckbox = document.getElementById('cbx-print-attachments');\n\t\t\tvar attachmentsView = document.getElementsByClassName('attachments-section')[0];\n\t\t\tif (attachmentsCheckbox && attachmentsCheckbox.checked && attachmentsView){\n\t\t\t\tattachmentsView.style = 'display: block;'\n\t\t\t} else if(attachmentsView){\n\t\t\t\tattachmentsView.style = 'display: none;'\n\t\t\t}\n\t\t\tif(attachmentsCheckbox){\n\t\t\t\tattachmentsCheckbox.addEventListener('change', function(e){\n\t\t\t\t\tif (e.target.checked){\n\t\t\t\t\t\tattachmentsView.style = 'display: block;'\n\t\t\t\t\t} else {\n\t\t\t\t\t\tattachmentsView.style = 'display: none;'\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t});\n\n\t\"\"\"\n\n\tif options?.styles\n\t\tallCssLink = \"\"\n\n\tform = db.forms.findOne({_id: instance.form});\n\tformDescriptionHtml = \"\"\n\tif form\n\t\tformDescription = form.description\n\t\tif formDescription\n\t\t\tformDescription = formDescription.replace(/\\n/g,\"
\")\n\t\t\tformDescriptionHtml = \"\"\"\n\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t#{formDescription}\n\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\"\"\"\n\n\thtml = \"\"\"\n\t\t\n\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t#{allCssLink}\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t#{options.plugins || \"\"}\n\n\t\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t#{showTracesBtn}\n\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t#{formDescriptionHtml}\n\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{attachment}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{related_instances}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{related_records}\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t#{body}\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t\t\t#{trace}\n\t\t\t\t\t\t\t\t\t
\n\n\t\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t
\n\t\t\t\n\t\t\t\n\t\t\n\t\"\"\"\n\n\treturn html","var _getLocale, _getRequiredFields, _getStartStepEditableFields, _getStartStepRequiredFields, _getTemplateData, _getViewHtml, getLinkText, marked; \n\nmarked = require(\"marked\");\n\nInstanceReadOnlyTemplate = {};\n\nInstanceReadOnlyTemplate.instance_attachment = \"\\n\t\\n\t\t{{this.name}}\\n\t\\n\";\n\nInstanceReadOnlyTemplate.afSelectUserRead = \"
{{value}}
\";\n\nInstanceReadOnlyTemplate.afFormGroupRead = \"
\\n\t{{#with getField this.name}}\\n\t\t{{#if equals type 'section'}}\\n\t\t\t\t
\\n\t\t\t\t\t\\n\t\t\t\t\t

{{{description}}}

\\n\t\t\t\t
\\n\t\t{{else}}\\n\t\t\t{{#if equals type 'table'}}\\n\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t{{{description}}}\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t
\\n\t\t\t{{else}}\\n\t\t\t\t{{#if showLabel}}\\n\t\t\t\t\t\\n\t\t\t\t{{/if}}\\n\t\t\t\t{{#if isTextarea this}}\\n\t\t\t\t\t

{{{getValue code}}}

\\n\t\t\t\t{{else}}\\n\t\t\t\t\t
{{{getValue code}}}
\\n\t\t\t\t{{/if}}\\n\t\t\t{{/if}}\\n\t\t{{/if}}\\n\t{{/with}}\\n
\";\n\nInstanceReadOnlyTemplate.afFormGroup = \"\\n{{#with getField this.name}}\\n\t\t{{#if equals type 'section'}}\\n\t\t\t
\\n\t\t\t\t
\\n\t\t\t\t\t\\n\t\t\t\t\t

{{{description}}}

\\n\t\t\t\t
\\n \t\t\t\t
\\n\t\t{{else}}\\n\t\t\t{{#if equals type 'table'}}\\n\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t{{{description}}}\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t{{{getTableThead this}}}\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t{{{getTableBody this}}}\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t
\\n\t\t\t{{else}}\\n\t\t\t\t{{#if equals type 'input'}}\\n\t\t\t\t\t
\\n\t\t\t\t\t\t\\n\t\t\t\t\t\t{{#if is_textarea}}\\n\t\t\t\t\t\t\t\\n\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t{{#unless is_textarea}}\\n\t\t\t\t\t\t\t\\n\t\t\t\t\t\t{{/unless}}\\n\t\t\t\t\t
\\n\t\t\t\t{{else}}\\n\t\t\t\t\t{{#if equals type 'number'}}\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\\n\t\t\t\t\t\t
\\n\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t{{#if equals type 'date'}}\\n\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t{{#if equals type 'dateTime'}}\\n\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t{{#if equals type 'password'}}\\n\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t{{#if equals type 'select'}}\\n\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t{{#if equals type 'radio'}}\\n\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n \t\t\t\t\t\t\t\t\t\t\t\t\\n \t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n \t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'multiSelect'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#each options this}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/each}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'url'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'email'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{#if equals type 'checkbox'}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{else}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
{{{getValue code}}}
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t\t{{/if}}\\n\t\t\t\t\t{{/if}}\\n\t\t\t\t{{/if}}\\n\t\t\t{{/if}}\\n\t\t{{/if}}\\n\t{{/with}}\";\n\nInstanceReadOnlyTemplate.create = function(tempalteName, steedosData) {\n var template, templateCompiled, templateRenderFunction;\n template = InstanceReadOnlyTemplate[tempalteName];\n templateCompiled = SpacebarsCompiler.compile(template, {\n isBody: true\n });\n templateRenderFunction = eval(templateCompiled);\n Template[tempalteName] = new Blaze.Template(tempalteName, templateRenderFunction);\n Template[tempalteName].steedosData = steedosData;\n return Template[tempalteName].helpers(InstanceformTemplate.helpers);\n};\n\nInstanceReadOnlyTemplate.createInstanceSignText = function(steedosData) {\n var instanceSignTextCompiled, instanceSignTextHtml, instanceSignTextRenderFunction;\n instanceSignTextHtml = _getViewHtml('client/views/instance/instance_sign_text.html');\n instanceSignTextCompiled = SpacebarsCompiler.compile(instanceSignTextHtml, {\n isBody: true\n });\n instanceSignTextRenderFunction = eval(instanceSignTextCompiled);\n Template.instanceSignText = new Blaze.Template(\"instanceSignText\", instanceSignTextRenderFunction);\n Template.instanceSignText.steedosData = steedosData;\n return Template.instanceSignText.helpers(InstanceSignText.helpers);\n};\n\nInstanceReadOnlyTemplate.createImageSign = function(steedosData) {\n var imageSignCompiled, imageSignHtml, imageSignRenderFunction;\n imageSignHtml = _getViewHtml('client/views/instance/image_sign.html');\n imageSignCompiled = SpacebarsCompiler.compile(imageSignHtml, {\n isBody: true\n });\n imageSignRenderFunction = eval(imageSignCompiled);\n Template.imageSign = new Blaze.Template(\"imageSign\", imageSignRenderFunction);\n Template.imageSign.steedosData = steedosData;\n return Template.imageSign.helpers(ImageSign.helpers);\n};\n\nInstanceReadOnlyTemplate.createTracesHanlder = function(steedosData) {\n var tracesHanlderCompiled, tracesHanlderHtml, tracesHanlderRenderFunction;\n tracesHanlderHtml = _getViewHtml('client/views/instance/traces_handler.html');\n tracesHanlderCompiled = SpacebarsCompiler.compile(tracesHanlderHtml, {\n isBody: true\n });\n tracesHanlderRenderFunction = eval(tracesHanlderCompiled);\n Template.instance_traces_handler = new Blaze.Template(\"instance_traces_handler\", tracesHanlderRenderFunction);\n Template.instance_traces_handler.steedosData = steedosData;\n return Template.instance_traces_handler.helpers(TracesHandler.helpers);\n};\n\nInstanceReadOnlyTemplate.init = function(steedosData) {\n InstanceReadOnlyTemplate.create(\"afSelectUserRead\", steedosData);\n if (Meteor.isServer) {\n InstanceReadOnlyTemplate.create(\"afFormGroup\", steedosData);\n }\n InstanceReadOnlyTemplate.create(\"afFormGroupRead\", steedosData);\n if (Meteor.isServer) {\n InstanceReadOnlyTemplate.create(\"instance_attachment\", {\n absolute: steedosData.absolute\n });\n InstanceReadOnlyTemplate.createImageSign(steedosData);\n InstanceReadOnlyTemplate.createTracesHanlder(steedosData);\n return InstanceReadOnlyTemplate.createInstanceSignText(steedosData);\n }\n};\n\ngetLinkText = function(item, label, detail_url) {\n if (detail_url) {\n detail_url = detail_url.replace(\"{_id}\", item._id);\n if (!/^http(s?):\\/\\//.test(detail_url)) {\n detail_url = Steedos.absoluteUrl(detail_url);\n }\n return '' + label + '';\n } else {\n return label;\n }\n};\n\nInstanceReadOnlyTemplate.getValue = function(value, field, locale, utcOffset) {\n var date, detail_url, e, fieldOptions, hours, month, nameField, records, res, seconds, selectedOption, selectedOptions, splitedValues, t, t0, t1, uiSchema, year;\n if (!value && value !== false) {\n return '';\n }\n if ([\"select\", \"multiSelect\", \"radio\"].indexOf(field.type) > -1) {\n fieldOptions = field.options.split(\"\\n\").map(function(n) {\n var itemSplits;\n itemSplits = n.split(\":\");\n return {\n label: itemSplits[0],\n value: itemSplits[1] || n\n };\n });\n }\n switch (field.type) {\n case 'email':\n value = value ? '' + value + '' : '';\n break;\n case 'url':\n if (value) {\n if (value.indexOf(\"http\") === 0) {\n try {\n value = \"\" + value + \"\";\n } catch (error) {\n e = error;\n value = \"\" + value + \"\";\n }\n } else {\n value = \"\" + value + \"\";\n }\n } else {\n value = '';\n }\n break;\n case 'group':\n if (field.is_multiselect) {\n value = value != null ? value.getProperty(\"fullname\").toString() : void 0;\n } else {\n value = value != null ? value.fullname : void 0;\n }\n break;\n case 'user':\n if (field.is_multiselect) {\n value = value != null ? value.getProperty(\"name\").toString() : void 0;\n } else {\n value = value != null ? value.name : void 0;\n }\n break;\n case 'password':\n value = '******';\n break;\n case 'checkbox':\n if (value && value !== 'false') {\n value = TAPi18n.__(\"form_field_checkbox_yes\", {}, locale);\n } else {\n value = TAPi18n.__(\"form_field_checkbox_no\", {}, locale);\n }\n break;\n case 'dateTime':\n if (value && value.length === 16) {\n t = value.split(\"T\");\n t0 = t[0].split(\"-\");\n t1 = t[1].split(\":\");\n year = t0[0];\n month = t0[1];\n date = t0[2];\n hours = t1[0];\n seconds = t1[1];\n value = new Date(year, month - 1, date, hours, seconds);\n } else {\n value = new Date(value);\n }\n value = InstanceReadOnlyTemplate.formatDate(value, utcOffset);\n break;\n case 'time':\n if (value && value.length === 16) {\n t = value.split(\"T\");\n t0 = t[0].split(\"-\");\n t1 = t[1].split(\":\");\n year = t0[0];\n month = t0[1];\n date = t0[2];\n hours = t1[0];\n seconds = t1[1];\n value = new Date(year, month - 1, date, hours, seconds);\n } else {\n value = new Date(value);\n }\n value = InstanceReadOnlyTemplate.formatTime(value);\n break;\n case 'input':\n if (field.is_textarea) {\n value = value;\n }\n break;\n case 'select':\n selectedOption = fieldOptions.find(function(item) {\n return item.value === value;\n });\n if (selectedOption) {\n value = selectedOption.label;\n }\n break;\n case 'radio':\n selectedOption = fieldOptions.find(function(item) {\n return item.value === value;\n });\n if (selectedOption) {\n value = selectedOption.label;\n }\n break;\n case 'multiSelect':\n splitedValues = value.split(\",\");\n selectedOptions = fieldOptions.filter(function(item) {\n return splitedValues.indexOf(item.value) > -1;\n });\n if (selectedOptions.length) {\n value = selectedOptions.map(function(item) {\n return item.label;\n }).join(\",\");\n }\n break;\n case 'number':\n if (value || value === 0) {\n if (field.is_percent) {\n value = Steedos.numberToPercentString(value, field.digits);\n } else {\n value = Steedos.numberToString(value, field.digits);\n }\n }\n break;\n case 'odata':\n detail_url = field.detail_url;\n if (field.is_multiselect) {\n value = _.map(value, function(item) {\n return getLinkText(item, item['@label'], detail_url);\n });\n } else {\n value = getLinkText(value, value['@label'], detail_url);\n }\n break;\n case 'image':\n if (field.is_multiselect) {\n value = _.map(value, function(item) {\n return '
';\n });\n value = value.join(\"\");\n } else {\n value = '
';\n }\n break;\n case 'file':\n if (value) {\n if (!field.is_multiselect) {\n value = [value];\n }\n if (Meteor.isClient) {\n res = Steedos.authRequest('/api/v1/cfs_files_filerecord?filters=[[\"_id\",\"in\", ' + JSON.stringify(value) + ']]&fields=[\"_id\",\"original\"]', {\n async: false\n });\n records = res.data.items;\n } else if (Meteor.isServer) {\n records = Steedos.objectFind(\"cfs_files_filerecord\", {\n filters: [[\"_id\", 'in', value]],\n fields: [\"_id\", \"original\"]\n });\n }\n value = _.map(records, function(item) {\n var fileName, filePreviewHtml, fileUrl;\n fileName = item.original.name;\n fileUrl = Steedos.absoluteUrl('/api/files/files/' + item._id);\n filePreviewHtml = '';\n if ([\".pdf\", \".jpg\", \".jpeg\", \".png\", \".gif\"].indexOf(fileName.slice(-4)) > -1) {\n filePreviewHtml = \" 预览\";\n }\n return \"
\" + fileName + \" \" + (filePreviewHtml != null ? filePreviewHtml : {\n filePreviewHtml: ''\n }) + \"
\";\n });\n value = value.join(\"\");\n }\n break;\n case 'lookup':\n if (value) {\n if (!field.is_multiselect) {\n value = [value];\n }\n if (Meteor.isClient) {\n uiSchema = Creator.getObject(field.reference_to);\n nameField = (uiSchema != null ? uiSchema.NAME_FIELD_KEY : void 0) || 'name';\n res = Steedos.authRequest('/api/v1/' + field.reference_to + '?filters=[[\"' + (field.reference_to_field || '_id') + '\",\"in\", ' + JSON.stringify(value) + ']]&fields=[\"_id\",\"' + nameField + '\"]', {\n async: false\n });\n records = res.data.items;\n } else if (Meteor.isServer) {\n nameField = Steedos.getObjectNameFieldKey(field.reference_to);\n records = Steedos.objectFind(field.reference_to, {\n filters: [[field.reference_to_field || '_id', 'in', value]],\n fields: [\"_id\", nameField]\n });\n }\n value = _.map(records, function(item) {\n return \"\" + item[nameField] + \"\";\n });\n value = value.join(\" , \");\n }\n break;\n case 'html':\n value = value ? \"
\" + value + \"
\" : '';\n }\n return value;\n};\n\nInstanceReadOnlyTemplate.getLabel = function(fields, code) {\n var field;\n field = fields.findPropertyByPK(\"code\", code);\n if (field) {\n if (field.name) {\n return field.name;\n } else {\n return field.code;\n }\n }\n};\n\nInstanceReadOnlyTemplate.getInstanceFormVersion = function(instance) {\n var form, form_fields, form_version;\n form = db.forms.findOne(instance.form);\n form_version = {};\n form_fields = [];\n if (form.current._id === instance.form_version) {\n form_version = form.current;\n } else {\n form_version = _.where(form.historys, {\n _id: instance.form_version\n })[0];\n }\n form_version.fields.forEach(function(field) {\n if (field.type === 'section') {\n form_fields.push(field);\n if (field.fields) {\n return field.fields.forEach(function(f) {\n return form_fields.push(f);\n });\n }\n } else if (field.type === 'table') {\n field['sfields'] = field['fields'];\n delete field['fields'];\n return form_fields.push(field);\n } else {\n return form_fields.push(field);\n }\n });\n form_version.fields = form_fields;\n return form_version;\n};\n\nInstanceReadOnlyTemplate.getFlowVersion = function(instance) {\n var flow, flow_version;\n flow = db.flows.findOne(instance.flow);\n flow_version = {};\n if (flow.current._id === instance.flow_version) {\n flow_version = flow.current;\n } else {\n flow_version = _.where(flow.historys, {\n _id: instance.flow_version\n })[0];\n }\n return flow_version;\n};\n\n_getViewHtml = function(path) {\n var viewHtml;\n viewHtml = Assets.getText(path);\n if (viewHtml) {\n viewHtml = viewHtml.replace(//i, \"\").replace(/<\\/template>/i, \"\");\n }\n return viewHtml;\n};\n\n_getLocale = function(user) {\n var locale, ref, ref1;\n if ((user != null ? (ref = user.locale) != null ? ref.toLocaleLowerCase() : void 0 : void 0) === 'zh-cn') {\n locale = \"zh-CN\";\n } else if ((user != null ? (ref1 = user.locale) != null ? ref1.toLocaleLowerCase() : void 0 : void 0) === 'en-us') {\n locale = \"en\";\n } else {\n locale = \"zh-CN\";\n }\n return locale;\n};\n\n_getRequiredFields = function(fields, rev) {\n if (!rev) {\n rev = [];\n }\n fields.forEach(function(field) {\n if (field.type === 'section') {\n return _getRequiredFields(field.fields, rev);\n } else if (field.type === 'table') {\n\n } else {\n if (field.is_required) {\n return rev.push(field.code);\n }\n }\n });\n return rev;\n};\n\n_getStartStepEditableFields = function(fields, steps) {\n var editableCode, startStep;\n startStep = steps.findPropertyByPK(\"step_type\", \"start\");\n editableCode = [];\n _.keys(startStep.permissions).forEach(function(key) {\n if (startStep.permissions[key] === 'editable') {\n return editableCode.push(key);\n }\n });\n return editableCode;\n};\n\n_getStartStepRequiredFields = function(fields, steps) {\n var editableCode, requiredFields;\n requiredFields = _getRequiredFields(fields);\n editableCode = _getStartStepEditableFields(fields, steps);\n return _.intersection(requiredFields, editableCode);\n};\n\n_getTemplateData = function(user, space, instance, options) {\n var flow, form, form_version, locale, steedosData;\n if (Meteor.isServer) {\n form_version = InstanceReadOnlyTemplate.getInstanceFormVersion(instance);\n } else {\n form_version = WorkflowManager.getInstanceFormVersion(instance);\n }\n locale = _getLocale(user);\n steedosData = {};\n if (Meteor.isClient) {\n steedosData = _.clone(WorkflowManager_format.getAutoformSchemaValues());\n steedosData.insname = instance.name;\n steedosData.ins_state = instance.state;\n steedosData.ins_final_decision = instance.ins_final_decision;\n steedosData.ins_code = instance.code;\n steedosData.ins_is_archived = instance.is_archived;\n steedosData.ins_is_deleted = instance.ins_is_deleted;\n steedosData.applicant_name = instance.applicant_name;\n steedosData.applicantContext = instance.applicant_name;\n }\n steedosData.instance = instance;\n steedosData.form_version = form_version;\n steedosData.locale = locale;\n steedosData.utcOffset = user.utcOffset;\n steedosData.space = instance.space;\n steedosData.sessionUserId = user._id;\n if (Meteor.isServer) {\n if (options != null ? options.editable : void 0) {\n form = db.forms.findOne({\n _id: instance.form\n });\n flow = db.flows.findOne({\n _id: instance.flow\n });\n steedosData.startStepEditableFields = _getStartStepEditableFields(form.current.fields, flow.current.steps);\n }\n }\n return steedosData;\n};\n\nInstanceReadOnlyTemplate.formatDate = function(date, utcOffset) {\n var passing;\n if (Meteor.isServer) {\n passing = false;\n } else {\n passing = true;\n }\n if (!utcOffset && utcOffset !== 0) {\n utcOffset = 8;\n }\n return moment(date).utcOffset(utcOffset, passing).format(\"YYYY-MM-DD HH:mm\");\n};\n\nInstanceReadOnlyTemplate.formatTime = function(date) {\n var utcOffset;\n utcOffset = 0;\n return moment(date).utcOffset(utcOffset).format(\"HH:mm\");\n};\n\nInstanceReadOnlyTemplate.getInstanceView = function(user, space, instance, options) {\n var body, instanceCompiled, instanceRenderFunction, instanceTemplate, steedosData;\n steedosData = _getTemplateData(user, space, instance, options);\n steedosData.absolute = false;\n if (options != null ? options.absolute : void 0) {\n steedosData.absolute = true;\n }\n instanceTemplate = TemplateManager.getTemplate(instance, options != null ? options.templateName : void 0);\n instanceTemplate = instanceTemplate.replace(/afSelectUser/g, \"afSelectUserRead\");\n if (!(options != null ? options.editable : void 0)) {\n instanceTemplate = instanceTemplate.replace(/afFormGroup/g, \"afFormGroupRead\");\n }\n instanceCompiled = SpacebarsCompiler.compile(instanceTemplate, {\n isBody: true\n });\n instanceRenderFunction = eval(instanceCompiled);\n Template.instance_readonly_view = new Blaze.Template(\"instance_readonly_view\", instanceRenderFunction);\n Template.instance_readonly_view.steedosData = steedosData;\n Template.instance_readonly_view.helpers(InstanceformTemplate.helpers);\n InstanceReadOnlyTemplate.init(steedosData);\n body = Blaze.toHTMLWithData(Template.instance_readonly_view, steedosData);\n return \"
\\n\t\" + body + \"\\n
\";\n};\n\nInstanceReadOnlyTemplate.getTracesView = function(user, space, instance, options) {\n var body, form, steedosData, traceCompiled, traceRenderFunction, tracesHtml;\n steedosData = _getTemplateData(user, space, instance);\n form = db.forms.findOne(instance.form);\n if (form.instance_style === \"table\" || (options != null ? options.templateName : void 0) === \"table\") {\n tracesHtml = _getViewHtml('client/views/instance/traces_table.html');\n } else {\n tracesHtml = _getViewHtml('client/views/instance/traces.html');\n }\n traceCompiled = SpacebarsCompiler.compile(tracesHtml, {\n isBody: true\n });\n traceRenderFunction = eval(traceCompiled);\n Template.trace_readonly_view = new Blaze.Template(\"trace_readonly_view\", traceRenderFunction);\n Template.trace_readonly_view.steedosData = steedosData;\n Template.trace_readonly_view.helpers(TracesTemplate.helpers);\n body = Blaze.toHTMLWithData(Template.trace_readonly_view, instance.traces);\n return body;\n};\n\nInstanceReadOnlyTemplate.getAttachmentView = function(user, space, instance) {\n var attachmentCompiled, attachmentHtml, attachmentRenderFunction, body, steedosData;\n steedosData = _getTemplateData(user, space, instance);\n attachmentHtml = _getViewHtml('client/views/instance/instance_attachments.html');\n attachmentCompiled = SpacebarsCompiler.compile(attachmentHtml, {\n isBody: true\n });\n attachmentRenderFunction = eval(attachmentCompiled);\n Template.attachments_readonly_view = new Blaze.Template(\"attachments_readonly_view\", attachmentRenderFunction);\n Template.attachments_readonly_view.steedosData = steedosData;\n Template.attachments_readonly_view.helpers(InstanceAttachmentTemplate.helpers);\n body = Blaze.toHTMLWithData(Template.attachments_readonly_view);\n return body;\n};\n\nInstanceReadOnlyTemplate.getRelatedInstancesView = function(user, space, instance, options) {\n var body, relatedInstancesCompiled, relatedInstancesHtml, relatedInstancesRenderFunction, steedosData;\n steedosData = _getTemplateData(user, space, instance);\n steedosData.absolute = false;\n if (options != null ? options.absolute : void 0) {\n steedosData.absolute = true;\n }\n relatedInstancesHtml = _getViewHtml('client/views/instance/related_instances.html');\n relatedInstancesCompiled = SpacebarsCompiler.compile(relatedInstancesHtml, {\n isBody: true\n });\n relatedInstancesRenderFunction = eval(relatedInstancesCompiled);\n Template.related_instances_view = new Blaze.Template(\"related_instances_view\", relatedInstancesRenderFunction);\n Template.related_instances_view.steedosData = steedosData;\n Template.related_instances_view.helpers(RelatedInstances.helpers);\n body = Blaze.toHTMLWithData(Template.related_instances_view, steedosData);\n return body;\n};\n\nInstanceReadOnlyTemplate.getRelatedRecordsView = function(user, space, instance, options) {\n var body, relatedRecordsCompiled, relatedRecordsHtml, relatedRecordsRenderFunction, steedosData;\n steedosData = _getTemplateData(user, space, instance);\n steedosData.absolute = false;\n if (options != null ? options.absolute : void 0) {\n steedosData.absolute = true;\n }\n relatedRecordsHtml = _getViewHtml('client/views/instance/related_records.html');\n relatedRecordsCompiled = SpacebarsCompiler.compile(relatedRecordsHtml, {\n isBody: true\n });\n relatedRecordsRenderFunction = eval(relatedRecordsCompiled);\n Template.related_records_view = new Blaze.Template(\"related_records_view\", relatedRecordsRenderFunction);\n Template.related_records_view.steedosData = steedosData;\n Template.related_records_view.helpers(RelatedRecords.helpers);\n body = Blaze.toHTMLWithData(Template.related_records_view, steedosData);\n return body;\n};\n\nInstanceReadOnlyTemplate.getOnLoadScript = function(instance) {\n var form_script, form_version;\n form_version = WorkflowManager.getFormVersion(instance.form, instance.form_version);\n form_script = form_version.form_script;\n if (form_script && form_script.replace(/\\n/g, \"\").replace(/\\s/g, \"\").length > 0) {\n form_script = \"CoreForm = {};CoreForm.instanceform = {};\" + form_script;\n return form_script += \";if(CoreForm.form_OnLoad){window.onload = CoreForm.form_OnLoad();}\";\n } else {\n return form_script = \"\";\n }\n};\n\nInstanceReadOnlyTemplate.getInstanceHtml = function(user, space, instance, options) {\n var allCssLink, attachment, body, creatorService, cssHref, form, formDescription, formDescriptionHtml, html, ins_record_ids, instanceBoxStyle, instance_style, jqHref, locale, onLoadScript, openFileScript, ref, ref1, related_instances, related_records, showTracesBtn, showTracesScript, trace, traceCheck, width;\n body = InstanceReadOnlyTemplate.getInstanceView(user, space, instance, options);\n onLoadScript = InstanceReadOnlyTemplate.getOnLoadScript(instance);\n creatorService = (ref = Meteor.settings[\"public\"].webservices) != null ? (ref1 = ref.creator) != null ? ref1.url : void 0 : void 0;\n ins_record_ids = instance.record_ids;\n locale = _getLocale(user);\n openFileScript = \"if(window.isNode && isNode()){\\n\tattachs = document.getElementsByClassName(\\\"ins_attach_href\\\");\\n\tfor(var i = 0; i < attachs.length; i++){\\n\t\tattach = attachs[i];\\n\t\tattach.addEventListener(\\\"click\\\", function(e){\\n\t\t\tif(isImage(this.dataset.type) || isHtml(this.dataset.type)){\\n\t\t\t\te.preventDefault();\\n\t\t\t\topenWindow(\\\"/api/files/instances/\\\" + this.dataset.id);\\n\t\t\t}else if(nw_core.canOpenFile(this.dataset.name)){\\n\t\t\t\te.preventDefault();\\n\t\t\t\tnw_core.openFile(this.href, this.dataset.name)\\n\t\t\t}\\n\t\t});\\n\t}\\n}\\n\\nvar flow = \\\"\" + instance.flow + \"\\\";\\nvar space = \\\"\" + instance.space + \"\\\";\\n\\nfunction getCookie(name){\\n\tlet pattern = RegExp(name + \\\"=.[^;]*\\\")\\n\tlet matched = document.cookie.match(pattern)\\n\tif(matched){\\n\t\tlet cookie = matched[0].split('=')\\n\t\treturn cookie[1]\\n\t}\\n\treturn ''\\n}\\n\\nvar records = document.getElementsByClassName(\\\"ins-related-records\\\");\\nfor(var i = 0; i < records.length; i++){\\n\t\tvar record = records[i];\\n\t\trecord.addEventListener(\\\"click\\\", function(e){\\n\t\t\tvar creatorService = \\\"\" + creatorService + \"\\\"\\n\t\t\tvar ins_record_ids = \" + (JSON.stringify(ins_record_ids)) + \"\\n\t\t\tif(creatorService && ins_record_ids && ins_record_ids.length > 0){\\n\t\t\t\tvar objcetName = ins_record_ids[0].o\\n\t\t\t\tvar id = ins_record_ids[0].ids[0]\\n\t\t\t\tvar uobj = {};\\n\t\t\t\tuobj[\\\"X-User-Id\\\"] = getCookie(\\\"X-User-Id\\\");\\n\t\t\t\tuobj[\\\"X-Auth-Token\\\"] = getCookie(\\\"X-Auth-Token\\\");\\n\t\t\t\tredirectUrl = creatorService + \\\"app/-/\\\" + objcetName + \\\"/view/\\\" + id + \\\"?\\\" + $.param(uobj);\\n\t\t\t\topenWindow(redirectUrl);\\n\t\t\t}\\n\t\t});\\n\t}\\n\";\n if (!Steedos.isMobile()) {\n form = db.forms.findOne(instance.form);\n if ((form != null ? form.instance_style : void 0) === 'table') {\n instance_style = \"instance-table\";\n }\n }\n if ((options != null ? options.templateName : void 0) === 'table') {\n instance_style = \"instance-table\";\n }\n if (options != null ? options.instance_style : void 0) {\n instance_style = options.instance_style;\n }\n if (!options || options.showTrace === true) {\n trace = InstanceReadOnlyTemplate.getTracesView(user, space, instance);\n } else {\n trace = \"\";\n }\n instanceBoxStyle = \"\";\n if (instance && instance.final_decision) {\n if (instance.final_decision === \"approved\") {\n instanceBoxStyle = \"box-success\";\n } else if (instance.final_decision === \"rejected\") {\n instanceBoxStyle = \"box-danger\";\n }\n }\n if (!options || options.showAttachments === true) {\n attachment = InstanceReadOnlyTemplate.getAttachmentView(user, space, instance);\n related_instances = InstanceReadOnlyTemplate.getRelatedInstancesView(user, space, instance, options);\n related_records = InstanceReadOnlyTemplate.getRelatedRecordsView(user, space, instance, options);\n } else {\n attachment = \"\";\n related_instances = \"\";\n related_records = \"\";\n }\n width = \"960px\";\n if (options != null ? options.width : void 0) {\n width = \"\";\n }\n cssHref = Meteor.absoluteUrl(\"steedos-css\");\n jqHref = Meteor.absoluteUrl(\"website/libs/jquery.min.js\");\n allCssLink = \"\";\n traceCheck = \"\";\n if (!_.isEmpty(trace)) {\n traceCheck = \"checked\";\n }\n if ((options != null ? options.tagger : void 0) === 'email' || (options != null ? options.editable : void 0)) {\n showTracesBtn = \"\";\n } else {\n showTracesBtn = \"
\\n\t
\\n\t\t\\n\t\t\\n\t
\\n
\";\n }\n showTracesScript = \"$( document ).ready(function(){\\n\tvar b = document.getElementById('cbx-print-traces');\\n\tvar t = document.getElementsByClassName('instance-traces')[0];\\n\tif (b && b.checked && t){\\n\t\tt.style = 'display: block;'\\n\t} else if(t){\\n\t\tt.style = 'display: none;'\\n\t}\\n\tif(b){\\n\t\tb.addEventListener('change', function(e){\\n\t\t\tif (e.target.checked){\\n\t\t\t\tt.style = 'display: block;'\\n\t\t\t} else {\\n\t\t\t\tt.style = 'display: none;'\\n\t\t\t}\\n\t\t});\\n\t}\\n\\n\\n\tvar attachmentsCheckbox = document.getElementById('cbx-print-attachments');\\n\tvar attachmentsView = document.getElementsByClassName('attachments-section')[0];\\n\tif (attachmentsCheckbox && attachmentsCheckbox.checked && attachmentsView){\\n\t\tattachmentsView.style = 'display: block;'\\n\t} else if(attachmentsView){\\n\t\tattachmentsView.style = 'display: none;'\\n\t}\\n\tif(attachmentsCheckbox){\\n\t\tattachmentsCheckbox.addEventListener('change', function(e){\\n\t\t\tif (e.target.checked){\\n\t\t\t\tattachmentsView.style = 'display: block;'\\n\t\t\t} else {\\n\t\t\t\tattachmentsView.style = 'display: none;'\\n\t\t\t}\\n\t\t});\\n\t}\\n});\\n\";\n if (options != null ? options.styles : void 0) {\n allCssLink = \"\";\n }\n form = db.forms.findOne({\n _id: instance.form\n });\n formDescriptionHtml = \"\";\n if (form) {\n formDescription = form.description;\n if (formDescription) {\n formDescription = formDescription.replace(/\\n/g, \"
\");\n formDescriptionHtml = \"
\\n\t
\\n\t\t\" + formDescription + \"\\n\t
\\n
\";\n }\n }\n html = \"\\n\\n\t\\n\t\t\\n\t\t\" + allCssLink + \"\\n\t\t\\n\t\t\\n\t\t\" + (options.plugins || \"\") + \"\\n\\n\t\t\\n\t\\n\t\\n\t\t
\\n\t\t\t
\\n\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t\t\t\" + showTracesBtn + \"\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\" + formDescriptionHtml + \"\\n\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + attachment + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + related_instances + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t\t\" + related_records + \"\\n\t\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t\t\t\" + body + \"\\n\t\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t\t\" + trace + \"\\n\t\t\t\t\t\t\t
\\n\\n\t\t\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t
\\n\t\t\t
\\n\t\t
\\n\t\\n\t\\n\";\n return html;\n};\n","TemplateManager = {};\n\nformId = 'instanceform';\n\n\nTemplateManager.instance_title = ()->\n\tpageTitle = \"\"\"\n\t\t{{instance.name}}\n\t\"\"\"\n\n\tpageTitleTrClass = \"instance-name\"\n\n\tif CoreForm?.pageTitleFieldName\n\t\tpageTitle = \"\"\"\n\t\t\t\t{{> afFormGroup name=\"#{CoreForm.pageTitleFieldName}\" label=false}}\n\t\t\"\"\"\n\t\tpageTitleTrClass = \"\"\n\n\tif CoreForm?.pageTitle\n\t\tpageTitle = \"\"\"\n\t\t\t#{CoreForm.pageTitle}\n\t\t\"\"\"\n\t\tpageTitleTrClass = \"\"\n\n\tval =\n\t\tpageTitle: pageTitle\n\t\tpageTitleTrClass: pageTitleTrClass\n\n\treturn val\n\nTemplateManager.handleTableTemplate = (instance, _export) ->\n\n\ttemplate = \"\"\"\n\t
\n\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\n\n\t\t
\n\t\t\t\t\t#{this.instance_title().pageTitle}\n\t\t\t\t
\n\t\t\n\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\n\t\"\"\";\n\n\ttable_fields = InstanceformTemplate.helpers.table_fields(instance)\n\n\ttable_fields && table_fields.forEach (table_field)->\n\n\t\trequired = \"\"\n\t\tif !CoreForm?.pageTitleFieldName || CoreForm?.pageTitleFieldName != table_field.code\n\t\t\tif table_field.is_required\n\t\t\t\trequired = \"is-required\"\n\n\t\t\tif _export\n\t\t\t\trequired = \"\";\n\n\t\t\tpureCode = Steedos.removeSpecialCharacter(table_field.code);\n\n\t\t\tif InstanceformTemplate.helpers.isOpinionField(table_field)\n\t\t\t\ttemplate += table_field.tr_start\n\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\"\"\"\n\t\t\t\ttemplate += table_field.tr_end\n\t\t\telse\n\t\t\t\tif InstanceformTemplate.helpers.includes(table_field.type, 'section,table')\n\t\t\t\t\ttemplate += table_field.tr_start\n\t\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\t\n\t\t\t\t\t\"\"\"\n\t\t\t\t\ttemplate += table_field.tr_end\n\t\t\t\telse\n\t\t\t\t\ttemplate += table_field.tr_start\n\n\t\t\t\t\tif _export\n\t\t\t\t\t\ttitle_permission = \"\"\n\t\t\t\t\t\tfield_permission = \"\"\n\t\t\t\t\telse\n\t\t\t\t\t\ttitle_permission = \"title-\" + table_field.permission\n\t\t\t\t\t\tfield_permission = \"field-\" + table_field.permission\n\n\t\t\t\t\ttemplate += \"\"\"\n\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\"\"\"\n\t\t\t\t\ttemplate += table_field.tr_end\n\n\ttemplate += \"\"\"\n\t\t
\n\t\t\t\t\t\t{{afFieldLabelText name=\"#{table_field.code}\"}}\n\t\t\t\t\t\n\t\t\t\t\t\t{{> instanceSignText name=\"#{table_field.code}\"}}\n\t\t\t\t\t\n\t\t\t\t\t\t {{> afFormGroup name=\"#{table_field.code}\" label=false}}\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t{{afFieldLabelText name=\"#{table_field.code}\"}}\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t{{> afFormGroup name=\"#{table_field.code}\" label=false}}\n\t\t\t\t\t\t
\n\n\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t\n\t\t\t\n\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t\n\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t\t{{>Template.dynamic template=\"afSelectUser\" data=applicantContext}}\n\t\t\t\t\t
\n\t\t\t\t		\n\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\t{{formatDate instance.submit_date '{\"format\":\"YYYY-MM-DD\"}'}}\n\t\t\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t
\n\t
\n\t\"\"\"\n\treturn template\n\n#此处模板公用与：instance 编辑、查看、打印、转发时生成附件、发送邮件body部分(table 模板)\n#如果有修改，请测试确认其他功能是否正常。\nTemplateManager._template =\n\tdefault: (instance)->\n\n\t\ttemplate = \"\"\"\n\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t

#{TemplateManager.instance_title().pageTitle}

\n\t\t\t\t\t\n\t\t\t\t
\n\t\t\t\t\n\t\t\t
\n\t\t\t{{#each steedos_form.fields}}\n\t\t\t\t{{#if isOpinionField this}}\n\t\t\t\t\t
\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t\n\n\t\t\t\t\t\t\t{{> instanceSignText name=this.code}}\n\t\t\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t{{else}}\n\t\t\t\t\t{{#if includes this.type 'section,table'}}\n\t\t\t\t\t\t
\n\t\t\t\t\t\t\t{{> afFormGroup name=this.code label=false}}\n\t\t\t\t\t\t
\n\t\t\t\t\t{{else}}\n\t\t\t\t\t\t
\n\t\t\t\t\t\t{{> afFormGroup name=this.code}}\n\t\t\t\t\t\t
\n\t\t\t\t\t{{/if}}\n\t\t\t\t{{/if}}\n\t\t\t{{/each}}\n\t\t\t
\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
\n\t\t\t\t\t {{_t \"instance_initiator\"}} :\n\t\t\t\t\t
\n\t\t\t\t\t{{>Template.dynamic template=\"afSelectUser\" data=applicantContext}}\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t
\n\t\t\"\"\"\n\t\treturn template\n\n\ttable: (instance)->\n\t\treturn TemplateManager.handleTableTemplate(instance)\n#\ttable: '''\n#\t\t\n#\t\t\t\n#\t\t\t\t\n#\t\t\t\n# \n#\t\t\t\t\n#\t\t\t\n#
\n#\t\t\t\t\t

{{instance.name}}

\n#\t\t\t\t\t\n#\t\t\t\t
\n#\t\t\t\t\t\n#\t\t\t\t\t{{>Template.dynamic template=\"afSelectUser\" data=applicantContext}}\n#\t\t\t\t
\n#\t\t\n#\t\t {{#each table_fields}}\n#\t\t\t\t{{#if isOpinionField this}}\n#\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\n#\t\t\t\t\t\t\n#\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t{{else}}\n#\t\t\t\t\t{{#if includes this.type 'section,table'}}\n#\t\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\t\n#\t\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t\t{{else}}\n#\t\t\t\t\t\t{{{tr_start}}}\n#\t\t\t\t\t\t\t\n#\t\t\t\t\t\t\t\n#\t\t\t\t\t\t{{{tr_end}}}\n#\t\t\t\t\t{{/if}}\n#\t\t\t\t{{/if}}\n#\n#\t\t {{/each}}\n#\t\t
\n#\t\t\t\t\t\t\t{{afFieldLabelText name=this.code}}\n#\t\t\t\t\t\t\n#\t\t\t\t\t\t\t{{> instanceSignText step=(getOpinionFieldStepName this) default=''}}\n#\t\t\t\t\t\t\n#\t\t\t\t\t\t\t {{> afFormGroup name=this.code label=false}}\n#\t\t\t\t\t\t\t\n#\t\t\t\t\t\t\t\t{{afFieldLabelText name=this.code}}\n#\t\t\t\t\t\t\t\n#\t\t\t\t\t\t\t\t{{> afFormGroup name=this.code label=false}}\n#\t\t\t\t\t\t\t
\n#\t'''\n\nTemplateManager._templateHelps =\n\tapplicantContext: ->\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\tdata = {\n\t\t\tname: 'ins_applicant',\n\t\t\tatts: {\n\t\t\t\tname: 'ins_applicant',\n\t\t\t\tid: 'ins_applicant',\n\t\t\t\tclass: 'selectUser form-control',\n\t\t\t\tstyle: 'padding:6px 12px;width:140px;display:inline'\n\t\t\t}\n\t\t}\n#\t\tif not steedos_instance || steedos_instance.state != \"draft\"\n\t\tdata.atts.disabled = true\n\t\treturn data;\n\ninstanceId: ->\n\treturn 'instanceform';#\"instance_\" + Session.get(\"instanceId\");\n\nform_types: ->\n\tif ApproveManager.isReadOnly()\n\t\treturn 'disabled';\n\telse\n\t\treturn 'method';\n\nsteedos_form: ->\n\tform_version = WorkflowManager.getInstanceFormVersion();\n\tif form_version\n\t\treturn form_version\n\ninnersubformContext: (obj)->\n\tdoc_values = WorkflowManager_format.getAutoformSchemaValues();\n\tobj[\"tableValues\"] = if doc_values then doc_values[obj.code] else []\n\tobj[\"formId\"] = formId;\n\treturn obj;\n\ninstance: ->\n\tSession.get(\"change_date\")\n\tif (Session.get(\"instanceId\"))\n\t\tsteedos_instance = WorkflowManager.getInstance();\n\t\treturn steedos_instance;\n\nequals: (a, b) ->\n\treturn (a == b)\n\nincludes: (a, b) ->\n\treturn b.split(',').includes(a);\n\nfields: ->\n\tform_version = WorkflowManager.getInstanceFormVersion();\n\tif form_version\n\t\treturn new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n\ndoc_values: ->\n\tWorkflowManager_format.getAutoformSchemaValues();\n\ninstance_box_style: ->\n\tbox = Session.get(\"box\")\n\tif box == \"inbox\" || box == \"draft\"\n\t\tjudge = Session.get(\"judge\")\n\t\tif judge\n\t\t\tif (judge == \"approved\")\n\t\t\t\treturn \"box-success\"\n\t\t\telse if (judge == \"rejected\")\n\t\t\t\treturn \"box-danger\"\n\tins = WorkflowManager.getInstance();\n\tif ins && ins.final_decision\n\t\tif ins.final_decision == \"approved\"\n\t\t\treturn \"box-success\"\n\t\telse if (ins.final_decision == \"rejected\")\n\t\t\treturn \"box-danger\"\n\n\nTemplateManager.getTemplate = (instance, templateName) ->\n\tflow = db.flows.findOne(instance.flow);\n\tform = db.forms.findOne(instance.form);\n\n\tif templateName\n\t\tif templateName == 'table'\n\t\t\treturn TemplateManager._template.table(instance)\n\t\treturn TemplateManager._template.default(instance)\n\n\tif Session?.get(\"instancePrint\")\n\t\tif flow?.print_template\n\t\t\treturn \"
\" + flow.print_template + \"
\"\n\t\telse\n\t\t\tif flow?.instance_template\n\t\t\t\treturn \"
\" + flow.instance_template + \"
\"\n\t\t\telse\n\t\t\t\treturn TemplateManager._template.table(instance)\n\telse\n\t\tif Steedos.isMobile()\n\t\t\treturn TemplateManager._template.default(instance)\n\n\t\tif flow?.instance_template\n\t\t\treturn \"
\" + flow.instance_template + \"
\"\n\n\t\tif form?.instance_style\n\t\t\tif form.instance_style == 'table'\n\t\t\t\treturn TemplateManager._template.table(instance)\n\t\t\treturn TemplateManager._template.default(instance)\n\t\telse\n\t\t\treturn TemplateManager._template.default(instance)\n\n#TemplateManager.exportTemplate = (flowId) ->\n#\ttemplate = TemplateManager.getTemplate(flowId);\n#\n#\tflow = WorkflowManager.getFlow(flowId);\n#\n#\tif flow?.instance_template\n#\t\treturn template;\n#\n#\treturn template;\n\n","var formId; \n\nTemplateManager = {};\n\nformId = 'instanceform';\n\nTemplateManager.instance_title = function() {\n var pageTitle, pageTitleTrClass, val;\n pageTitle = \"{{instance.name}}\";\n pageTitleTrClass = \"instance-name\";\n if (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) {\n pageTitle = \"{{> afFormGroup name=\\\"\" + CoreForm.pageTitleFieldName + \"\\\" label=false}}\";\n pageTitleTrClass = \"\";\n }\n if (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitle : void 0) {\n pageTitle = \"\" + CoreForm.pageTitle;\n pageTitleTrClass = \"\";\n }\n val = {\n pageTitle: pageTitle,\n pageTitleTrClass: pageTitleTrClass\n };\n return val;\n};\n\nTemplateManager.handleTableTemplate = function(instance, _export) {\n var table_fields, template;\n template = \"
\\n\t\\n\t\t\\n\t\t\t\\n\t\t\\n\\n\t
\\n\t\t\t\t\" + (this.instance_title().pageTitle) + \"\\n\t\t\t
\\n\t\\n\t\t\t\\n\t\t\t\t\\n\t\t\t\t\\n\t\t\t\t\\n\t\t\t\t\\n\t\t\t\";\n table_fields = InstanceformTemplate.helpers.table_fields(instance);\n table_fields && table_fields.forEach(function(table_field) {\n var field_permission, pureCode, required, title_permission;\n required = \"\";\n if (!(typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) || (typeof CoreForm !== \"undefined\" && CoreForm !== null ? CoreForm.pageTitleFieldName : void 0) !== table_field.code) {\n if (table_field.is_required) {\n required = \"is-required\";\n }\n if (_export) {\n required = \"\";\n }\n pureCode = Steedos.removeSpecialCharacter(table_field.code);\n if (InstanceformTemplate.helpers.isOpinionField(table_field)) {\n template += table_field.tr_start;\n template += \"\\n\";\n return template += table_field.tr_end;\n } else {\n if (InstanceformTemplate.helpers.includes(table_field.type, 'section,table')) {\n template += table_field.tr_start;\n template += \"\";\n return template += table_field.tr_end;\n } else {\n template += table_field.tr_start;\n if (_export) {\n title_permission = \"\";\n field_permission = \"\";\n } else {\n title_permission = \"title-\" + table_field.permission;\n field_permission = \"field-\" + table_field.permission;\n }\n template += \"\\n\";\n return template += table_field.tr_end;\n }\n }\n }\n });\n template += \"\t
\\n\t{{afFieldLabelText name=\\\"\" + table_field.code + \"\\\"}}\\n\\n\t{{> instanceSignText name=\\\"\" + table_field.code + \"\\\"}}\\n\\n {{> afFormGroup name=\\\"\" + table_field.code + \"\\\" label=false}}\\n\\n\t{{afFieldLabelText name=\\\"\" + table_field.code + \"\\\"}}\\n\\n\t{{> afFormGroup name=\\\"\" + table_field.code + \"\\\" label=false}}\\n
\\n\\n\t\\n\t\t\\n\t\t\t\\n\t\t\t\\n\t\t\\n\t
\\n\t\t\t\t
\\n\t\t\t\t\t\\n\t\t\t\t
\\n\t\t\t\t
\\n\t\t\t\t\t{{>Template.dynamic template=\\\"afSelectUser\\\" data=applicantContext}}\\n\t\t\t\t
\\n\t\t\t		\\n\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t\t\t\\n\t\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t\t\t
\\n\t\t\t\t\t\t\t{{formatDate instance.submit_date '{\\\"format\\\":\\\"YYYY-MM-DD\\\"}'}}\\n\t\t\t\t\t\t
\\n\t\t\t\t\t
\\n\t\t\t\t
\\n\t\t\t
\\n
\";\n return template;\n};\n\nTemplateManager._template = {\n \"default\": function(instance) {\n var template;\n template = \"
\\n\t
\\n\t\t

\" + (TemplateManager.instance_title().pageTitle) + \"

\\n\t\t\\n\t
\\n\t\\n
\\n{{#each steedos_form.fields}}\\n\t{{#if isOpinionField this}}\\n\t\t
\\n\t\t\t
\\n\t\t\t\t\\n\\n\t\t\t\t{{> instanceSignText name=this.code}}\\n\t\t\t
\\n\t\t
\\n\t{{else}}\\n\t\t{{#if includes this.type 'section,table'}}\\n\t\t\t
\\n\t\t\t\t{{> afFormGroup name=this.code label=false}}\\n\t\t\t
\\n\t\t{{else}}\\n\t\t\t
\\n\t\t\t{{> afFormGroup name=this.code}}\\n\t\t\t
\\n\t\t{{/if}}\\n\t{{/if}}\\n{{/each}}\\n
\\n\t
\\n\t
\\n\t\t
\\n\t\t {{_t \\\"instance_initiator\\\"}} :\\n\t\t
\\n\t\t{{>Template.dynamic template=\\\"afSelectUser\\\" data=applicantContext}}\\n\t
\\n\t
\\n
\";\n return template;\n },\n table: function(instance) {\n return TemplateManager.handleTableTemplate(instance);\n }\n};\n\nTemplateManager._templateHelps = {\n applicantContext: function() {\n var data, steedos_instance;\n steedos_instance = WorkflowManager.getInstance();\n data = {\n name: 'ins_applicant',\n atts: {\n name: 'ins_applicant',\n id: 'ins_applicant',\n \"class\": 'selectUser form-control',\n style: 'padding:6px 12px;width:140px;display:inline'\n }\n };\n data.atts.disabled = true;\n return data;\n }\n};\n\n({\n instanceId: function() {\n return 'instanceform';\n },\n form_types: function() {\n if (ApproveManager.isReadOnly()) {\n return 'disabled';\n } else {\n return 'method';\n }\n },\n steedos_form: function() {\n var form_version;\n form_version = WorkflowManager.getInstanceFormVersion();\n if (form_version) {\n return form_version;\n }\n },\n innersubformContext: function(obj) {\n var doc_values;\n doc_values = WorkflowManager_format.getAutoformSchemaValues();\n obj[\"tableValues\"] = doc_values ? doc_values[obj.code] : [];\n obj[\"formId\"] = formId;\n return obj;\n },\n instance: function() {\n var steedos_instance;\n Session.get(\"change_date\");\n if (Session.get(\"instanceId\")) {\n steedos_instance = WorkflowManager.getInstance();\n return steedos_instance;\n }\n },\n equals: function(a, b) {\n return a === b;\n },\n includes: function(a, b) {\n return b.split(',').includes(a);\n },\n fields: function() {\n var form_version;\n form_version = WorkflowManager.getInstanceFormVersion();\n if (form_version) {\n return new SimpleSchema(WorkflowManager_format.getAutoformSchema(form_version));\n }\n },\n doc_values: function() {\n return WorkflowManager_format.getAutoformSchemaValues();\n },\n instance_box_style: function() {\n var box, ins, judge;\n box = Session.get(\"box\");\n if (box === \"inbox\" || box === \"draft\") {\n judge = Session.get(\"judge\");\n if (judge) {\n if (judge === \"approved\") {\n return \"box-success\";\n } else if (judge === \"rejected\") {\n return \"box-danger\";\n }\n }\n }\n ins = WorkflowManager.getInstance();\n if (ins && ins.final_decision) {\n if (ins.final_decision === \"approved\") {\n return \"box-success\";\n } else if (ins.final_decision === \"rejected\") {\n return \"box-danger\";\n }\n }\n }\n});\n\nTemplateManager.getTemplate = function(instance, templateName) {\n var flow, form;\n flow = db.flows.findOne(instance.flow);\n form = db.forms.findOne(instance.form);\n if (templateName) {\n if (templateName === 'table') {\n return TemplateManager._template.table(instance);\n }\n return TemplateManager._template[\"default\"](instance);\n }\n if (typeof Session !== \"undefined\" && Session !== null ? Session.get(\"instancePrint\") : void 0) {\n if (flow != null ? flow.print_template : void 0) {\n return \"
\" + flow.print_template + \"
\";\n } else {\n if (flow != null ? flow.instance_template : void 0) {\n return \"
\" + flow.instance_template + \"
\";\n } else {\n return TemplateManager._template.table(instance);\n }\n }\n } else {\n if (Steedos.isMobile()) {\n return TemplateManager._template[\"default\"](instance);\n }\n if (flow != null ? flow.instance_template : void 0) {\n return \"
\" + flow.instance_template + \"
\";\n }\n if (form != null ? form.instance_style : void 0) {\n if (form.instance_style === 'table') {\n return TemplateManager._template.table(instance);\n }\n return TemplateManager._template[\"default\"](instance);\n } else {\n return TemplateManager._template[\"default\"](instance);\n }\n }\n};\n","SteedosTable = {};\n\nSteedosTable.formId = \"instanceform\";\n\nSteedosTable.checkItem = function (field, item_index) {\n var fieldObj = SteedosTable.getField(field);\n\n var fieldVal = SteedosTable.getItemModalValue(field, item_index);\n\n var sf_name = '';\n var rev = true;\n fieldObj.sfields.forEach(function (sf) {\n if (sf.permission == 'editable') {\n sf_name = fieldObj.code + \".\" + sf.code;\n if (!InstanceManager.checkFormFieldValue($(\"[name='\" + sf_name + \"']\")[0], sf_name, fieldVal[sf.code])) {\n rev = false;\n }\n }\n });\n\n return rev;\n}\n\nSteedosTable.setTableItemValue = function (field, item_index, item_value) {\n\n var tableValue = SteedosTable.getTableValue(field);\n tableValue[item_index] = item_value;\n}\n\nSteedosTable.getTableItemValue = function (field, item_index) {\n return SteedosTable.getTableValue(field)[item_index];\n}\n\nSteedosTable.removeTableItem = function (field, item_index) {\n var item_value = SteedosTable.getTableItemValue(field, item_index);\n item_value.removed = true;\n}\n\nSteedosTable.setTableValue = function (field, value) {\n $(\"table[name='\" + field + \"']\").val({\n val: value\n });\n}\n\nSteedosTable.getTableValue = function (field) {\n return $(\"table[name='\" + field + \"']\").val().val;\n}\n\nSteedosTable.getValidValue = function (field) {\n var value = SteedosTable.getTableValue(field);\n\n if (!value) {\n return\n }\n\n var validValue = [];\n\n value.forEach(function (v) {\n if (!v.removed) {\n validValue.push(v);\n }\n });\n return validValue;\n}\n\n\nSteedosTable.handleData = function (field, values) {\n\n if (!values || !(values instanceof Array)) {\n return values;\n }\n\n var fieldObj = SteedosTable.getField(field);\n\n values.forEach(function (v) {\n fieldObj.sfields.forEach(function (f) {\n if (f.type == 'user' || f.type == 'group') {\n var value = v[f.code]\n if (f.is_multiselect) {\n if (value && value.length > 0 && typeof (value[0]) == 'object') {\n v[f.code] = v[f.code].getProperty(\"id\");\n }\n } else {\n if (value && typeof (value) == 'object') {\n v[f.code] = v[f.code].id;\n }\n }\n } else if (f.type == 'dateTime') {\n var value = v[f.code]\n if (value) {\n if (value.length == 16) {\n var t = value.split(\"T\");\n var t0 = t[0].split(\"-\");\n var t1 = t[1].split(\":\");\n\n year = t0[0];\n month = t0[1];\n date = t0[2];\n hours = t1[0];\n seconds = t1[1];\n value = new Date(year, month - 1, date, hours, seconds);\n v[f.code] = value;\n }\n\n }\n }\n });\n });\n return values;\n}\n\nSteedosTable.getField = function (field) {\n var instanceFields = WorkflowManager.getInstanceFields();\n if (!instanceFields)\n return;\n\n var fieldObj = instanceFields.findPropertyByPK(\"code\", field);\n\n return fieldObj;\n}\n\n\nSteedosTable.getModalData = function (field, index) {\n\n var data = {};\n\n var fieldObj = SteedosTable.getField(field);\n\n if (!fieldObj) {\n return;\n }\n\n data.field = fieldObj;\n\n data.field.formula = Form_formula.getFormulaFieldVariable(\"Form_formula.field_values\", fieldObj.sfields);\n\n data.value = {};\n\n data.value[field] = SteedosTable.getTableItemValue(field, index);\n\n data.index = index;\n\n return data;\n}\n\n\n\nSteedosTable.getItemModalValue = function (field, item_index) {\n\n if (!AutoForm.getFormValues(\"steedos_table_modal_\" + field + \"_\" + item_index)) {\n return {}\n }\n\n var item_value = AutoForm.getFormValues(\"steedos_table_modal_\" + field + \"_\" + item_index).insertDoc[field];\n return item_value;\n}\n\n\nSteedosTable.addItem = function (field, index, _item_value) {\n var keys = SteedosTable.getKeys(field);\n var item_value = _item_value || SteedosTable.getItemModalValue(field, index);\n $(\"tbody[name='\" + field + \"Tbody']\").append(SteedosTable.getTr(keys, item_value, index, field, true))\n\n}\n\nSteedosTable.updateItem = function (field, index, _item_value) {\n\n var item = $(\"tr[name='\" + field + \"_item_\" + index + \"']\");\n\n var item_value = _item_value || SteedosTable.getItemModalValue(field, index);\n\n if (item && item.length > 0) {\n var keys = SteedosTable.getKeys(field);\n var tds = SteedosTable.getRemoveTd(field, index);\n\n var sfields = SteedosTable.getField(field).sfields;\n\n keys.forEach(function (key) {\n var sfield = sfields.findPropertyByPK(\"code\", key);\n\n var value = item_value[key];\n\n tds = tds + SteedosTable.getTd(sfield, index, value);\n\n });\n\n item.empty();\n\n item.append(tds);\n\n } else {\n\n SteedosTable.addItem(field, index);\n }\n\n if (SteedosTable.getTableValue(field)) {\n\n SteedosTable.setTableItemValue(field, index, item_value);\n\n //SteedosTable.valueHash[field][index] = item_value;\n\n } else {\n //SteedosTable.valueHash[field] = [item_value];\n\n SteedosTable.setTableValue(field, [item_value])\n\n }\n\n //执行主表公式计算\n InstanceManager.runFormula(field);\n\n}\n\nSteedosTable.removeItem = function (field, index) {\n\n $(\"tr[name='\" + field + \"_item_\" + index + \"']\").hide();\n\n SteedosTable.removeTableItem(field, index);\n\n InstanceManager.runFormula(field);\n}\n\nSteedosTable.showModal = function (field, index, method) {\n\n\n var modalData = SteedosTable.getModalData(field, index);\n\n modalData.method = method;\n setTimeout(function(){\n Modal.show(\"steedosTableModal\", modalData);\n }, 300)\n}\n\nSteedosTable.getKeys = function (field) {\n if (!AutoForm.getCurrentDataForForm(SteedosTable.formId)) {\n return [];\n }\n\n var ss = AutoForm.getFormSchema(SteedosTable.formId);\n\n var keys = [];\n\n if (ss.schema(field + \".$\").type === Object) {\n keys = ss.objectKeys(SimpleSchema._makeGeneric(field) + '.$')\n }\n\n return keys;\n\n}\n\nSteedosTable.getThead = function (field, editable) {\n\n var fieldObj = field;\n if (!_.isObject(field))\n fieldObj = SteedosTable.getField(field);\n\n if (!fieldObj) {\n return '';\n }\n\n var thead = '',\n trs = '',\n label = '',\n width = 100;\n\n if (editable) {\n // trs = \"\"\n trs = \"\"\n }\n\n var sfields = fieldObj.sfields;\n\n if (!sfields) {\n return thead;\n }\n\n var sf_length = sfields.length;\n\n if (sf_length > 0) {\n var wide_fields = sfields.filterProperty(\"is_wide\", true);\n\n width = 100 / (sf_length + wide_fields.length);\n }\n\n sfields.forEach(function (sf, index) {\n\n label = (sf.name != null && sf.name.length > 0) ? sf.name : sf.code;\n\n trs = trs + \"\" + label + \"\"\n });\n\n thead = '' + trs + '';\n\n return thead;\n}\n\nSteedosTable.getTbody = function (keys, field, values, editable, sfieldsEditable) {\n var tbody = \"\";\n\n if (values instanceof Array) {\n values.forEach(function (value, index) {\n tbody = tbody + SteedosTable.getTr(keys, value, index, field, editable, sfieldsEditable);\n });\n }\n\n return tbody;\n}\n\nSteedosTable.getTr = function (keys, item_value, index, field, editable, sfieldsEditable) {\n\n var fieldObj = field;\n if (!_.isObject(field))\n fieldObj = SteedosTable.getField(field);\n\n var tr = \"\";\n\n var tds = \"\";\n\n if (editable) {\n tds = SteedosTable.getRemoveTd(fieldObj.code, index);\n }\n\n var sfields = fieldObj.sfields;\n\n keys.forEach(function (key) {\n var sfield = sfields.findPropertyByPK(\"code\", key);\n\n var value = item_value[key];\n\n tds = tds + SteedosTable.getTd(sfield, index, value);\n\n });\n\n tr = tr + tds + \"\";\n return tr;\n}\n\nSteedosTable.getRemoveTd = function (field, index) {\n // return \"