diff --git a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/renderjs.js.js b/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/renderjs.js.js
deleted file mode 100644
index cfbd89c9e79d7eb7b99844254e934027d8a1597f..0000000000000000000000000000000000000000
--- a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/renderjs.js.js
+++ /dev/null
@@ -1,2050 +0,0 @@
-/*
- * js_channel is a very lightweight abstraction on top of
- * postMessage which defines message formats and semantics
- * to support interactions more rich than just message passing
- * js_channel supports:
- *  + query/response - traditional rpc
- *  + query/update/response - incremental async return of results
- *    to a query
- *  + notifications - fire and forget
- *  + error handling
- *
- * js_channel is based heavily on json-rpc, but is focused at the
- * problem of inter-iframe RPC.
- *
- * Message types:
- *  There are 5 types of messages that can flow over this channel,
- *  and you may determine what type of message an object is by
- *  examining its parameters:
- *  1. Requests
- *    + integer id
- *    + string method
- *    + (optional) any params
- *  2. Callback Invocations (or just "Callbacks")
- *    + integer id
- *    + string callback
- *    + (optional) params
- *  3. Error Responses (or just "Errors)
- *    + integer id
- *    + string error
- *    + (optional) string message
- *  4. Responses
- *    + integer id
- *    + (optional) any result
- *  5. Notifications
- *    + string method
- *    + (optional) any params
- */
-
-;var Channel = (function() {
-    "use strict";
-
-    // current transaction id, start out at a random *odd* number between 1 and a million
-    // There is one current transaction counter id per page, and it's shared between
-    // channel instances.  That means of all messages posted from a single javascript
-    // evaluation context, we'll never have two with the same id.
-    var s_curTranId = Math.floor(Math.random()*1000001);
-
-    // no two bound channels in the same javascript evaluation context may have the same origin, scope, and window.
-    // futher if two bound channels have the same window and scope, they may not have *overlapping* origins
-    // (either one or both support '*').  This restriction allows a single onMessage handler to efficiently
-    // route messages based on origin and scope.  The s_boundChans maps origins to scopes, to message
-    // handlers.  Request and Notification messages are routed using this table.
-    // Finally, channels are inserted into this table when built, and removed when destroyed.
-    var s_boundChans = { };
-
-    // add a channel to s_boundChans, throwing if a dup exists
-    function s_addBoundChan(win, origin, scope, handler) {
-        function hasWin(arr) {
-            for (var i = 0; i < arr.length; i++) if (arr[i].win === win) return true;
-            return false;
-        }
-
-        // does she exist?
-        var exists = false;
-
-
-        if (origin === '*') {
-            // we must check all other origins, sadly.
-            for (var k in s_boundChans) {
-                if (!s_boundChans.hasOwnProperty(k)) continue;
-                if (k === '*') continue;
-                if (typeof s_boundChans[k][scope] === 'object') {
-                    exists = hasWin(s_boundChans[k][scope]);
-                    if (exists) break;
-                }
-            }
-        } else {
-            // we must check only '*'
-            if ((s_boundChans['*'] && s_boundChans['*'][scope])) {
-                exists = hasWin(s_boundChans['*'][scope]);
-            }
-            if (!exists && s_boundChans[origin] && s_boundChans[origin][scope])
-            {
-                exists = hasWin(s_boundChans[origin][scope]);
-            }
-        }
-        if (exists) throw "A channel is already bound to the same window which overlaps with origin '"+ origin +"' and has scope '"+scope+"'";
-
-        if (typeof s_boundChans[origin] != 'object') s_boundChans[origin] = { };
-        if (typeof s_boundChans[origin][scope] != 'object') s_boundChans[origin][scope] = [ ];
-        s_boundChans[origin][scope].push({win: win, handler: handler});
-    }
-
-    function s_removeBoundChan(win, origin, scope) {
-        var arr = s_boundChans[origin][scope];
-        for (var i = 0; i < arr.length; i++) {
-            if (arr[i].win === win) {
-                arr.splice(i,1);
-            }
-        }
-        if (s_boundChans[origin][scope].length === 0) {
-            delete s_boundChans[origin][scope];
-        }
-    }
-
-    function s_isArray(obj) {
-        if (Array.isArray) return Array.isArray(obj);
-        else {
-            return (obj.constructor.toString().indexOf("Array") != -1);
-        }
-    }
-
-    // No two outstanding outbound messages may have the same id, period.  Given that, a single table
-    // mapping "transaction ids" to message handlers, allows efficient routing of Callback, Error, and
-    // Response messages.  Entries are added to this table when requests are sent, and removed when
-    // responses are received.
-    var s_transIds = { };
-
-    // class singleton onMessage handler
-    // this function is registered once and all incoming messages route through here.  This
-    // arrangement allows certain efficiencies, message data is only parsed once and dispatch
-    // is more efficient, especially for large numbers of simultaneous channels.
-    var s_onMessage = function(e) {
-        try {
-          var m = JSON.parse(e.data);
-          if (typeof m !== 'object' || m === null) throw "malformed";
-        } catch(e) {
-          // just ignore any posted messages that do not consist of valid JSON
-          return;
-        }
-
-        var w = e.source;
-        var o = e.origin;
-        var s, i, meth;
-
-        if (typeof m.method === 'string') {
-            var ar = m.method.split('::');
-            if (ar.length == 2) {
-                s = ar[0];
-                meth = ar[1];
-            } else {
-                meth = m.method;
-            }
-        }
-
-        if (typeof m.id !== 'undefined') i = m.id;
-
-        // w is message source window
-        // o is message origin
-        // m is parsed message
-        // s is message scope
-        // i is message id (or undefined)
-        // meth is unscoped method name
-        // ^^ based on these factors we can route the message
-
-        // if it has a method it's either a notification or a request,
-        // route using s_boundChans
-        if (typeof meth === 'string') {
-            var delivered = false;
-            if (s_boundChans[o] && s_boundChans[o][s]) {
-                for (var j = 0; j < s_boundChans[o][s].length; j++) {
-                    if (s_boundChans[o][s][j].win === w) {
-                        s_boundChans[o][s][j].handler(o, meth, m);
-                        delivered = true;
-                        break;
-                    }
-                }
-            }
-
-            if (!delivered && s_boundChans['*'] && s_boundChans['*'][s]) {
-                for (var j = 0; j < s_boundChans['*'][s].length; j++) {
-                    if (s_boundChans['*'][s][j].win === w) {
-                        s_boundChans['*'][s][j].handler(o, meth, m);
-                        break;
-                    }
-                }
-            }
-        }
-        // otherwise it must have an id (or be poorly formed
-        else if (typeof i != 'undefined') {
-            if (s_transIds[i]) s_transIds[i](o, meth, m);
-        }
-    };
-
-    // Setup postMessage event listeners
-    if (window.addEventListener) window.addEventListener('message', s_onMessage, false);
-    else if(window.attachEvent) window.attachEvent('onmessage', s_onMessage);
-
-    /* a messaging channel is constructed from a window and an origin.
-     * the channel will assert that all messages received over the
-     * channel match the origin
-     *
-     * Arguments to Channel.build(cfg):
-     *
-     *   cfg.window - the remote window with which we'll communicate
-     *   cfg.origin - the expected origin of the remote window, may be '*'
-     *                which matches any origin
-     *   cfg.scope  - the 'scope' of messages.  a scope string that is
-     *                prepended to message names.  local and remote endpoints
-     *                of a single channel must agree upon scope. Scope may
-     *                not contain double colons ('::').
-     *   cfg.debugOutput - A boolean value.  If true and window.console.log is
-     *                a function, then debug strings will be emitted to that
-     *                function.
-     *   cfg.debugOutput - A boolean value.  If true and window.console.log is
-     *                a function, then debug strings will be emitted to that
-     *                function.
-     *   cfg.postMessageObserver - A function that will be passed two arguments,
-     *                an origin and a message.  It will be passed these immediately
-     *                before messages are posted.
-     *   cfg.gotMessageObserver - A function that will be passed two arguments,
-     *                an origin and a message.  It will be passed these arguments
-     *                immediately after they pass scope and origin checks, but before
-     *                they are processed.
-     *   cfg.onReady - A function that will be invoked when a channel becomes "ready",
-     *                this occurs once both sides of the channel have been
-     *                instantiated and an application level handshake is exchanged.
-     *                the onReady function will be passed a single argument which is
-     *                the channel object that was returned from build().
-     */
-    return {
-        build: function(cfg) {
-            var debug = function(m) {
-                if (cfg.debugOutput && window.console && window.console.log) {
-                    // try to stringify, if it doesn't work we'll let javascript's built in toString do its magic
-                    try { if (typeof m !== 'string') m = JSON.stringify(m); } catch(e) { }
-                    console.log("["+chanId+"] " + m);
-                }
-            };
-
-            /* browser capabilities check */
-            if (!window.postMessage) throw("jschannel cannot run this browser, no postMessage");
-            if (!window.JSON || !window.JSON.stringify || ! window.JSON.parse) {
-                throw("jschannel cannot run this browser, no JSON parsing/serialization");
-            }
-
-            /* basic argument validation */
-            if (typeof cfg != 'object') throw("Channel build invoked without a proper object argument");
-
-            if (!cfg.window || !cfg.window.postMessage) throw("Channel.build() called without a valid window argument");
-
-            /* we'd have to do a little more work to be able to run multiple channels that intercommunicate the same
-             * window...  Not sure if we care to support that */
-            if (window === cfg.window) throw("target window is same as present window -- not allowed");
-
-            // let's require that the client specify an origin.  if we just assume '*' we'll be
-            // propagating unsafe practices.  that would be lame.
-            var validOrigin = false;
-            if (typeof cfg.origin === 'string') {
-                var oMatch;
-                if (cfg.origin === "*") validOrigin = true;
-                // allow valid domains under http and https.  Also, trim paths off otherwise valid origins.
-                else if (null !== (oMatch = cfg.origin.match(/^https?:\/\/(?:[-a-zA-Z0-9_\.])+(?::\d+)?/))) {
-                    cfg.origin = oMatch[0].toLowerCase();
-                    validOrigin = true;
-                }
-            }
-
-            if (!validOrigin) throw ("Channel.build() called with an invalid origin");
-
-            if (typeof cfg.scope !== 'undefined') {
-                if (typeof cfg.scope !== 'string') throw 'scope, when specified, must be a string';
-                if (cfg.scope.split('::').length > 1) throw "scope may not contain double colons: '::'";
-            }
-
-            /* private variables */
-            // generate a random and psuedo unique id for this channel
-            var chanId = (function () {
-                var text = "";
-                var alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-                for(var i=0; i < 5; i++) text += alpha.charAt(Math.floor(Math.random() * alpha.length));
-                return text;
-            })();
-
-            // registrations: mapping method names to call objects
-            var regTbl = { };
-            // current oustanding sent requests
-            var outTbl = { };
-            // current oustanding received requests
-            var inTbl = { };
-            // are we ready yet?  when false we will block outbound messages.
-            var ready = false;
-            var pendingQueue = [ ];
-
-            var createTransaction = function(id,origin,callbacks) {
-                var shouldDelayReturn = false;
-                var completed = false;
-
-                return {
-                    origin: origin,
-                    invoke: function(cbName, v) {
-                        // verify in table
-                        if (!inTbl[id]) throw "attempting to invoke a callback of a nonexistent transaction: " + id;
-                        // verify that the callback name is valid
-                        var valid = false;
-                        for (var i = 0; i < callbacks.length; i++) if (cbName === callbacks[i]) { valid = true; break; }
-                        if (!valid) throw "request supports no such callback '" + cbName + "'";
-
-                        // send callback invocation
-                        postMessage({ id: id, callback: cbName, params: v});
-                    },
-                    error: function(error, message) {
-                        completed = true;
-                        // verify in table
-                        if (!inTbl[id]) throw "error called for nonexistent message: " + id;
-
-                        // remove transaction from table
-                        delete inTbl[id];
-
-                        // send error
-                        postMessage({ id: id, error: error, message: message });
-                    },
-                    complete: function(v) {
-                        completed = true;
-                        // verify in table
-                        if (!inTbl[id]) throw "complete called for nonexistent message: " + id;
-                        // remove transaction from table
-                        delete inTbl[id];
-                        // send complete
-                        postMessage({ id: id, result: v });
-                    },
-                    delayReturn: function(delay) {
-                        if (typeof delay === 'boolean') {
-                            shouldDelayReturn = (delay === true);
-                        }
-                        return shouldDelayReturn;
-                    },
-                    completed: function() {
-                        return completed;
-                    }
-                };
-            };
-
-            var setTransactionTimeout = function(transId, timeout, method) {
-              return window.setTimeout(function() {
-                if (outTbl[transId]) {
-                  // XXX: what if client code raises an exception here?
-                  var msg = "timeout (" + timeout + "ms) exceeded on method '" + method + "'";
-                  (1,outTbl[transId].error)("timeout_error", msg);
-                  delete outTbl[transId];
-                  delete s_transIds[transId];
-                }
-              }, timeout);
-            };
-
-            var onMessage = function(origin, method, m) {
-                // if an observer was specified at allocation time, invoke it
-                if (typeof cfg.gotMessageObserver === 'function') {
-                    // pass observer a clone of the object so that our
-                    // manipulations are not visible (i.e. method unscoping).
-                    // This is not particularly efficient, but then we expect
-                    // that message observers are primarily for debugging anyway.
-                    try {
-                        cfg.gotMessageObserver(origin, m);
-                    } catch (e) {
-                        debug("gotMessageObserver() raised an exception: " + e.toString());
-                    }
-                }
-
-                // now, what type of message is this?
-                if (m.id && method) {
-                    // a request!  do we have a registered handler for this request?
-                    if (regTbl[method]) {
-                        var trans = createTransaction(m.id, origin, m.callbacks ? m.callbacks : [ ]);
-                        inTbl[m.id] = { };
-                        try {
-                            // callback handling.  we'll magically create functions inside the parameter list for each
-                            // callback
-                            if (m.callbacks && s_isArray(m.callbacks) && m.callbacks.length > 0) {
-                                for (var i = 0; i < m.callbacks.length; i++) {
-                                    var path = m.callbacks[i];
-                                    var obj = m.params;
-                                    var pathItems = path.split('/');
-                                    for (var j = 0; j < pathItems.length - 1; j++) {
-                                        var cp = pathItems[j];
-                                        if (typeof obj[cp] !== 'object') obj[cp] = { };
-                                        obj = obj[cp];
-                                    }
-                                    obj[pathItems[pathItems.length - 1]] = (function() {
-                                        var cbName = path;
-                                        return function(params) {
-                                            return trans.invoke(cbName, params);
-                                        };
-                                    })();
-                                }
-                            }
-                            var resp = regTbl[method](trans, m.params);
-                            if (!trans.delayReturn() && !trans.completed()) trans.complete(resp);
-                        } catch(e) {
-                            // automagic handling of exceptions:
-                            var error = "runtime_error";
-                            var message = null;
-                            // * if it's a string then it gets an error code of 'runtime_error' and string is the message
-                            if (typeof e === 'string') {
-                                message = e;
-                            } else if (typeof e === 'object') {
-                                // either an array or an object
-                                // * if it's an array of length two, then  array[0] is the code, array[1] is the error message
-                                if (e && s_isArray(e) && e.length == 2) {
-                                    error = e[0];
-                                    message = e[1];
-                                }
-                                // * if it's an object then we'll look form error and message parameters
-                                else if (typeof e.error === 'string') {
-                                    error = e.error;
-                                    if (!e.message) message = "";
-                                    else if (typeof e.message === 'string') message = e.message;
-                                    else e = e.message; // let the stringify/toString message give us a reasonable verbose error string
-                                }
-                            }
-
-                            // message is *still* null, let's try harder
-                            if (message === null) {
-                                try {
-                                    message = JSON.stringify(e);
-                                    /* On MSIE8, this can result in 'out of memory', which
-                                     * leaves message undefined. */
-                                    if (typeof(message) == 'undefined')
-                                      message = e.toString();
-                                } catch (e2) {
-                                    message = e.toString();
-                                }
-                            }
-
-                            trans.error(error,message);
-                        }
-                    }
-                } else if (m.id && m.callback) {
-                    if (!outTbl[m.id] ||!outTbl[m.id].callbacks || !outTbl[m.id].callbacks[m.callback])
-                    {
-                        debug("ignoring invalid callback, id:"+m.id+ " (" + m.callback +")");
-                    } else {
-                        // XXX: what if client code raises an exception here?
-                        outTbl[m.id].callbacks[m.callback](m.params);
-                    }
-                } else if (m.id) {
-                    if (!outTbl[m.id]) {
-                        debug("ignoring invalid response: " + m.id);
-                    } else {
-                        // XXX: what if client code raises an exception here?
-                        if (m.error) {
-                            (1,outTbl[m.id].error)(m.error, m.message);
-                        } else {
-                            if (m.result !== undefined) (1,outTbl[m.id].success)(m.result);
-                            else (1,outTbl[m.id].success)();
-                        }
-                        delete outTbl[m.id];
-                        delete s_transIds[m.id];
-                    }
-                } else if (method) {
-                    // tis a notification.
-                    if (regTbl[method]) {
-                        // yep, there's a handler for that.
-                        // transaction has only origin for notifications.
-                        regTbl[method]({ origin: origin }, m.params);
-                        // if the client throws, we'll just let it bubble out
-                        // what can we do?  Also, here we'll ignore return values
-                    }
-                }
-            };
-
-            // now register our bound channel for msg routing
-            s_addBoundChan(cfg.window, cfg.origin, ((typeof cfg.scope === 'string') ? cfg.scope : ''), onMessage);
-
-            // scope method names based on cfg.scope specified when the Channel was instantiated
-            var scopeMethod = function(m) {
-                if (typeof cfg.scope === 'string' && cfg.scope.length) m = [cfg.scope, m].join("::");
-                return m;
-            };
-
-            // a small wrapper around postmessage whose primary function is to handle the
-            // case that clients start sending messages before the other end is "ready"
-            var postMessage = function(msg, force) {
-                if (!msg) throw "postMessage called with null message";
-
-                // delay posting if we're not ready yet.
-                var verb = (ready ? "post  " : "queue ");
-                debug(verb + " message: " + JSON.stringify(msg));
-                if (!force && !ready) {
-                    pendingQueue.push(msg);
-                } else {
-                    if (typeof cfg.postMessageObserver === 'function') {
-                        try {
-                            cfg.postMessageObserver(cfg.origin, msg);
-                        } catch (e) {
-                            debug("postMessageObserver() raised an exception: " + e.toString());
-                        }
-                    }
-
-                    cfg.window.postMessage(JSON.stringify(msg), cfg.origin);
-                }
-            };
-
-            var onReady = function(trans, type) {
-                debug('ready msg received');
-                if (ready) throw "received ready message while in ready state.  help!";
-
-                if (type === 'ping') {
-                    chanId += '-R';
-                } else {
-                    chanId += '-L';
-                }
-
-                obj.unbind('__ready'); // now this handler isn't needed any more.
-                ready = true;
-                debug('ready msg accepted.');
-
-                if (type === 'ping') {
-                    obj.notify({ method: '__ready', params: 'pong' });
-                }
-
-                // flush queue
-                while (pendingQueue.length) {
-                    postMessage(pendingQueue.pop());
-                }
-
-                // invoke onReady observer if provided
-                if (typeof cfg.onReady === 'function') cfg.onReady(obj);
-            };
-
-            var obj = {
-                // tries to unbind a bound message handler.  returns false if not possible
-                unbind: function (method) {
-                    if (regTbl[method]) {
-                        if (!(delete regTbl[method])) throw ("can't delete method: " + method);
-                        return true;
-                    }
-                    return false;
-                },
-                bind: function (method, cb) {
-                    if (!method || typeof method !== 'string') throw "'method' argument to bind must be string";
-                    if (!cb || typeof cb !== 'function') throw "callback missing from bind params";
-
-                    if (regTbl[method]) throw "method '"+method+"' is already bound!";
-                    regTbl[method] = cb;
-                    return this;
-                },
-                call: function(m) {
-                    if (!m) throw 'missing arguments to call function';
-                    if (!m.method || typeof m.method !== 'string') throw "'method' argument to call must be string";
-                    if (!m.success || typeof m.success !== 'function') throw "'success' callback missing from call";
-
-                    // now it's time to support the 'callback' feature of jschannel.  We'll traverse the argument
-                    // object and pick out all of the functions that were passed as arguments.
-                    var callbacks = { };
-                    var callbackNames = [ ];
-
-                    var pruneFunctions = function (path, obj) {
-                        if (typeof obj === 'object') {
-                            for (var k in obj) {
-                                if (!obj.hasOwnProperty(k)) continue;
-                                var np = path + (path.length ? '/' : '') + k;
-                                if (typeof obj[k] === 'function') {
-                                    callbacks[np] = obj[k];
-                                    callbackNames.push(np);
-                                    delete obj[k];
-                                } else if (typeof obj[k] === 'object') {
-                                    pruneFunctions(np, obj[k]);
-                                }
-                            }
-                        }
-                    };
-                    pruneFunctions("", m.params);
-
-                    // build a 'request' message and send it
-                    var msg = { id: s_curTranId, method: scopeMethod(m.method), params: m.params };
-                    if (callbackNames.length) msg.callbacks = callbackNames;
-
-                    if (m.timeout)
-                      // XXX: This function returns a timeout ID, but we don't do anything with it.
-                      // We might want to keep track of it so we can cancel it using clearTimeout()
-                      // when the transaction completes.
-                      setTransactionTimeout(s_curTranId, m.timeout, scopeMethod(m.method));
-
-                    // insert into the transaction table
-                    outTbl[s_curTranId] = { callbacks: callbacks, error: m.error, success: m.success };
-                    s_transIds[s_curTranId] = onMessage;
-
-                    // increment current id
-                    s_curTranId++;
-
-                    postMessage(msg);
-                },
-                notify: function(m) {
-                    if (!m) throw 'missing arguments to notify function';
-                    if (!m.method || typeof m.method !== 'string') throw "'method' argument to notify must be string";
-
-                    // no need to go into any transaction table
-                    postMessage({ method: scopeMethod(m.method), params: m.params });
-                },
-                destroy: function () {
-                    s_removeBoundChan(cfg.window, cfg.origin, ((typeof cfg.scope === 'string') ? cfg.scope : ''));
-                    if (window.removeEventListener) window.removeEventListener('message', onMessage, false);
-                    else if(window.detachEvent) window.detachEvent('onmessage', onMessage);
-                    ready = false;
-                    regTbl = { };
-                    inTbl = { };
-                    outTbl = { };
-                    cfg.origin = null;
-                    pendingQueue = [ ];
-                    debug("channel destroyed");
-                    chanId = "";
-                }
-            };
-
-            obj.bind('__ready', onReady);
-            setTimeout(function() {
-                postMessage({ method: scopeMethod('__ready'), params: "ping" }, true);
-            }, 0);
-
-            return obj;
-        }
-    };
-})();
-;/*
- * DOMParser HTML extension
- * 2012-09-04
- *
- * By Eli Grey, http://eligrey.com
- * Public domain.
- * NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
- */
-/*! @source https://gist.github.com/1129031 */
-(function (DOMParser) {
-  "use strict";
-  var DOMParser_proto = DOMParser.prototype,
-    real_parseFromString = DOMParser_proto.parseFromString;
-
-  // Firefox/Opera/IE throw errors on unsupported types
-  try {
-    // WebKit returns null on unsupported types
-    if ((new DOMParser()).parseFromString("", "text/html")) {
-      // text/html parsing is natively supported
-      return;
-    }
-  } catch (ignore) {}
-
-  DOMParser_proto.parseFromString = function (markup, type) {
-    var result, doc, doc_elt, first_elt;
-    if (/^\s*text\/html\s*(?:;|$)/i.test(type)) {
-      doc = document.implementation.createHTMLDocument("");
-      doc_elt = doc.documentElement;
-
-      doc_elt.innerHTML = markup;
-      first_elt = doc_elt.firstElementChild;
-
-      if (doc_elt.childElementCount === 1
-          && first_elt.localName.toLowerCase() === "html") {
-        doc.replaceChild(first_elt, doc_elt);
-      }
-
-      result = doc;
-    } else {
-      result = real_parseFromString.apply(this, arguments);
-    }
-    return result;
-  };
-}(DOMParser));
-
-;// IE does not support have Document.prototype.contains.
-if (typeof document.contains !== 'function') {
-  Document.prototype.contains = function(node) {
-    if (node === this || node.parentNode === this)
-      return true;
-    return this.documentElement.contains(node);
- }
-}
-;/*! RenderJs */
-/*jslint nomen: true*/
-
-/*
- * renderJs - Generic Gadget library renderer.
- * http://www.renderjs.org/documentation
- */
-(function (document, window, RSVP, DOMParser, Channel, MutationObserver,
-           Node, FileReader, Blob) {
-  "use strict";
-
-  function readBlobAsDataURL(blob) {
-    var fr = new FileReader();
-    return new RSVP.Promise(function (resolve, reject) {
-      fr.addEventListener("load", function (evt) {
-        resolve(evt.target.result);
-      });
-      fr.addEventListener("error", reject);
-      fr.readAsDataURL(blob);
-    }, function () {
-      fr.abort();
-    });
-  }
-
-  function ajax(url) {
-    var xhr;
-    function resolver(resolve, reject) {
-      function handler() {
-        try {
-          if (xhr.readyState === 0) {
-            // UNSENT
-            reject(xhr);
-          } else if (xhr.readyState === 4) {
-            // DONE
-            if ((xhr.status < 200) || (xhr.status >= 300) ||
-                (!/^text\/html[;]?/.test(
-                  xhr.getResponseHeader("Content-Type") || ""
-                ))) {
-              reject(xhr);
-            } else {
-              resolve(xhr);
-            }
-          }
-        } catch (e) {
-          reject(e);
-        }
-      }
-
-      xhr = new XMLHttpRequest();
-      xhr.open("GET", url);
-      xhr.onreadystatechange = handler;
-      xhr.setRequestHeader('Accept', 'text/html');
-      xhr.withCredentials = true;
-      xhr.send();
-    }
-
-    function canceller() {
-      if ((xhr !== undefined) && (xhr.readyState !== xhr.DONE)) {
-        xhr.abort();
-      }
-    }
-    return new RSVP.Promise(resolver, canceller);
-  }
-
-  var gadget_model_dict = {},
-    javascript_registration_dict = {},
-    stylesheet_registration_dict = {},
-    gadget_loading_klass,
-    loading_klass_promise,
-    renderJS,
-    Monitor,
-    scope_increment = 0,
-    isAbsoluteOrDataURL = new RegExp('^(?:[a-z]+:)?//|data:', 'i');
-
-  /////////////////////////////////////////////////////////////////
-  // Helper functions
-  /////////////////////////////////////////////////////////////////
-  function removeHash(url) {
-    var index = url.indexOf('#');
-    if (index > 0) {
-      url = url.substring(0, index);
-    }
-    return url;
-  }
-
-  function letsCrash(e) {
-    if (e.constructor === XMLHttpRequest) {
-      e = {
-        readyState: e.readyState,
-        status: e.status,
-        statusText: e.statusText,
-        response_headers: e.getAllResponseHeaders()
-      };
-    }
-    if (e.constructor === Array ||
-        e.constructor === String ||
-        e.constructor === Object) {
-      try {
-        e = JSON.stringify(e);
-      } catch (ignore) {
-      }
-    }
-    document.getElementsByTagName('body')[0].textContent = e;
-    // XXX Do not crash the application if it fails
-    // Where to write the error?
-    /*global console*/
-    console.error(e.stack);
-    console.error(e);
-  }
-
-  /////////////////////////////////////////////////////////////////
-  // Service Monitor promise
-  /////////////////////////////////////////////////////////////////
-  function ResolvedMonitorError(message) {
-    this.name = "resolved";
-    if ((message !== undefined) && (typeof message !== "string")) {
-      throw new TypeError('You must pass a string.');
-    }
-    this.message = message || "Default Message";
-  }
-  ResolvedMonitorError.prototype = new Error();
-  ResolvedMonitorError.prototype.constructor = ResolvedMonitorError;
-
-  Monitor = function () {
-    var monitor = this,
-      promise_list = [],
-      promise,
-      reject,
-      notify,
-      resolved;
-
-    if (!(this instanceof Monitor)) {
-      return new Monitor();
-    }
-
-    function canceller() {
-      var len = promise_list.length,
-        i;
-      for (i = 0; i < len; i += 1) {
-        promise_list[i].cancel();
-      }
-      // Clean it to speed up other canceller run
-      promise_list = [];
-    }
-
-    promise = new RSVP.Promise(function (done, fail, progress) {
-      reject = function (rejectedReason) {
-        if (resolved) {
-          return;
-        }
-        monitor.isRejected = true;
-        monitor.rejectedReason = rejectedReason;
-        resolved = true;
-        canceller();
-        return fail(rejectedReason);
-      };
-      notify = progress;
-    }, canceller);
-
-    monitor.cancel = function () {
-      if (resolved) {
-        return;
-      }
-      resolved = true;
-      promise.cancel();
-      promise.fail(function (rejectedReason) {
-        monitor.isRejected = true;
-        monitor.rejectedReason = rejectedReason;
-      });
-    };
-    monitor.then = function () {
-      return promise.then.apply(promise, arguments);
-    };
-    monitor.fail = function () {
-      return promise.fail.apply(promise, arguments);
-    };
-
-    monitor.monitor = function (promise_to_monitor) {
-      if (resolved) {
-        throw new ResolvedMonitorError();
-      }
-      var queue = new RSVP.Queue()
-        .push(function () {
-          return promise_to_monitor;
-        })
-        .push(function (fulfillmentValue) {
-          // Promise to monitor is fullfilled, remove it from the list
-          var len = promise_list.length,
-            sub_promise_to_monitor,
-            new_promise_list = [],
-            i;
-          for (i = 0; i < len; i += 1) {
-            sub_promise_to_monitor = promise_list[i];
-            if (!(sub_promise_to_monitor.isFulfilled ||
-                sub_promise_to_monitor.isRejected)) {
-              new_promise_list.push(sub_promise_to_monitor);
-            }
-          }
-          promise_list = new_promise_list;
-        }, function (rejectedReason) {
-          if (rejectedReason instanceof RSVP.CancellationError) {
-            if (!(promise_to_monitor.isFulfilled &&
-                  promise_to_monitor.isRejected)) {
-              // The queue could be cancelled before the first push is run
-              promise_to_monitor.cancel();
-            }
-          }
-          reject(rejectedReason);
-          throw rejectedReason;
-        }, function (notificationValue) {
-          notify(notificationValue);
-          return notificationValue;
-        });
-
-      promise_list.push(queue);
-
-      return this;
-    };
-  };
-
-  Monitor.prototype = Object.create(RSVP.Promise.prototype);
-  Monitor.prototype.constructor = Monitor;
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSGadget
-  /////////////////////////////////////////////////////////////////
-  function RenderJSGadget() {
-    if (!(this instanceof RenderJSGadget)) {
-      return new RenderJSGadget();
-    }
-  }
-  RenderJSGadget.prototype.__title = "";
-  RenderJSGadget.prototype.__interface_list = [];
-  RenderJSGadget.prototype.__path = "";
-  RenderJSGadget.prototype.__html = "";
-  RenderJSGadget.prototype.__required_css_list = [];
-  RenderJSGadget.prototype.__required_js_list = [];
-
-  function createMonitor(g) {
-    if (g.__monitor !== undefined) {
-      g.__monitor.cancel();
-    }
-    g.__monitor = new Monitor();
-    g.__monitor.fail(function (error) {
-      if (!(error instanceof RSVP.CancellationError)) {
-        return g.aq_reportServiceError(error);
-      }
-    }).fail(function (error) {
-      // Crash the application if the acquisition generates an error.
-      return letsCrash(error);
-    });
-  }
-
-  function clearGadgetInternalParameters(g) {
-    g.__sub_gadget_dict = {};
-    createMonitor(g);
-  }
-
-  function loadSubGadgetDOMDeclaration(g) {
-    var element_list = g.__element.querySelectorAll('[data-gadget-url]'),
-      element,
-      promise_list = [],
-      scope,
-      url,
-      sandbox,
-      i;
-
-    for (i = 0; i < element_list.length; i += 1) {
-      element = element_list[i];
-      scope = element.getAttribute("data-gadget-scope");
-      url = element.getAttribute("data-gadget-url");
-      sandbox = element.getAttribute("data-gadget-sandbox");
-      if (url !== null) {
-        promise_list.push(g.declareGadget(url, {
-          element: element,
-          scope: scope || undefined,
-          sandbox: sandbox || undefined
-        }));
-      }
-    }
-
-    return RSVP.all(promise_list);
-  }
-
-  RenderJSGadget.__ready_list = [clearGadgetInternalParameters,
-                                 loadSubGadgetDOMDeclaration];
-  RenderJSGadget.ready = function (callback) {
-    this.__ready_list.push(callback);
-    return this;
-  };
-
-  RenderJSGadget.__service_list = [];
-  RenderJSGadget.declareService = function (callback) {
-    this.__service_list.push(callback);
-    return this;
-  };
-
-  function startService(gadget) {
-    gadget.__monitor.monitor(new RSVP.Queue()
-      .push(function () {
-        var i,
-          service_list = gadget.constructor.__service_list;
-        for (i = 0; i < service_list.length; i += 1) {
-          gadget.__monitor.monitor(service_list[i].apply(gadget));
-        }
-      })
-      );
-  }
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSGadget.declareMethod
-  /////////////////////////////////////////////////////////////////
-  RenderJSGadget.declareMethod = function (name, callback) {
-    this.prototype[name] = function () {
-      var context = this,
-        argument_list = arguments;
-
-      return new RSVP.Queue()
-        .push(function () {
-          return callback.apply(context, argument_list);
-        });
-    };
-    // Allow chain
-    return this;
-  };
-
-  RenderJSGadget
-    .declareMethod('getInterfaceList', function () {
-      // Returns the list of gadget prototype
-      return this.__interface_list;
-    })
-    .declareMethod('getRequiredCSSList', function () {
-      // Returns a list of CSS required by the gadget
-      return this.__required_css_list;
-    })
-    .declareMethod('getRequiredJSList', function () {
-      // Returns a list of JS required by the gadget
-      return this.__required_js_list;
-    })
-    .declareMethod('getPath', function () {
-      // Returns the path of the code of a gadget
-      return this.__path;
-    })
-    .declareMethod('getTitle', function () {
-      // Returns the title of a gadget
-      return this.__title;
-    })
-    .declareMethod('getElement', function () {
-      // Returns the DOM Element of a gadget
-      if (this.__element === undefined) {
-        throw new Error("No element defined");
-      }
-      return this.__element;
-    });
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSGadget.declareAcquiredMethod
-  /////////////////////////////////////////////////////////////////
-  function acquire(child_gadget, method_name, argument_list) {
-    var gadget = this,
-      key,
-      gadget_scope;
-
-    for (key in gadget.__sub_gadget_dict) {
-      if (gadget.__sub_gadget_dict.hasOwnProperty(key)) {
-        if (gadget.__sub_gadget_dict[key] === child_gadget) {
-          gadget_scope = key;
-        }
-      }
-    }
-    return new RSVP.Queue()
-      .push(function () {
-        // Do not specify default __acquired_method_dict on prototype
-        // to prevent modifying this default value (with
-        // allowPublicAcquiredMethod for example)
-        var aq_dict = gadget.__acquired_method_dict || {};
-        if (aq_dict.hasOwnProperty(method_name)) {
-          return aq_dict[method_name].apply(gadget,
-                                            [argument_list, gadget_scope]);
-        }
-        throw new renderJS.AcquisitionError("aq_dynamic is not defined");
-      })
-      .push(undefined, function (error) {
-        if (error instanceof renderJS.AcquisitionError) {
-          return gadget.__aq_parent(method_name, argument_list);
-        }
-        throw error;
-      });
-  }
-
-  RenderJSGadget.declareAcquiredMethod =
-    function (name, method_name_to_acquire) {
-      this.prototype[name] = function () {
-        var argument_list = Array.prototype.slice.call(arguments, 0),
-          gadget = this;
-        return new RSVP.Queue()
-          .push(function () {
-            return gadget.__aq_parent(method_name_to_acquire, argument_list);
-          });
-      };
-
-      // Allow chain
-      return this;
-    };
-  RenderJSGadget.declareAcquiredMethod("aq_reportServiceError",
-                                       "reportServiceError");
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSGadget.allowPublicAcquisition
-  /////////////////////////////////////////////////////////////////
-  RenderJSGadget.allowPublicAcquisition =
-    function (method_name, callback) {
-      this.prototype.__acquired_method_dict[method_name] = callback;
-
-      // Allow chain
-      return this;
-    };
-
-  // Set aq_parent on gadget_instance which call acquire on parent_gadget
-  function setAqParent(gadget_instance, parent_gadget) {
-    gadget_instance.__aq_parent = function (method_name, argument_list) {
-      return acquire.apply(parent_gadget, [gadget_instance, method_name,
-                                           argument_list]);
-    };
-  }
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSEmbeddedGadget
-  /////////////////////////////////////////////////////////////////
-  // Class inheritance
-  function RenderJSEmbeddedGadget() {
-    if (!(this instanceof RenderJSEmbeddedGadget)) {
-      return new RenderJSEmbeddedGadget();
-    }
-    RenderJSGadget.call(this);
-  }
-  RenderJSEmbeddedGadget.__ready_list = RenderJSGadget.__ready_list.slice();
-  RenderJSEmbeddedGadget.__service_list =
-    RenderJSGadget.__service_list.slice();
-  RenderJSEmbeddedGadget.ready =
-    RenderJSGadget.ready;
-  RenderJSEmbeddedGadget.declareService =
-    RenderJSGadget.declareService;
-  RenderJSEmbeddedGadget.prototype = new RenderJSGadget();
-  RenderJSEmbeddedGadget.prototype.constructor = RenderJSEmbeddedGadget;
-
-  /////////////////////////////////////////////////////////////////
-  // privateDeclarePublicGadget
-  /////////////////////////////////////////////////////////////////
-  function privateDeclarePublicGadget(url, options, parent_gadget) {
-    var gadget_instance;
-    if (options.element === undefined) {
-      options.element = document.createElement("div");
-    }
-
-    function loadDependency(method, url) {
-      return function () {
-        return method(url);
-      };
-    }
-
-    return new RSVP.Queue()
-      .push(function () {
-        return renderJS.declareGadgetKlass(url);
-      })
-      // Get the gadget class and instanciate it
-      .push(function (Klass) {
-        var i,
-          template_node_list = Klass.__template_element.body.childNodes;
-        gadget_loading_klass = Klass;
-        gadget_instance = new Klass();
-        gadget_instance.__element = options.element;
-        for (i = 0; i < template_node_list.length; i += 1) {
-          gadget_instance.__element.appendChild(
-            template_node_list[i].cloneNode(true)
-          );
-        }
-        setAqParent(gadget_instance, parent_gadget);
-        // Load dependencies if needed
-        return RSVP.all([
-          gadget_instance.getRequiredJSList(),
-          gadget_instance.getRequiredCSSList()
-        ]);
-      })
-      // Load all JS/CSS
-      .push(function (all_list) {
-        var q = new RSVP.Queue(),
-          i;
-        // Load JS
-        for (i = 0; i < all_list[0].length; i += 1) {
-          q.push(loadDependency(renderJS.declareJS, all_list[0][i]));
-        }
-        // Load CSS
-        for (i = 0; i < all_list[1].length; i += 1) {
-          q.push(loadDependency(renderJS.declareCSS, all_list[1][i]));
-        }
-        return q;
-      })
-      .push(function () {
-        return gadget_instance;
-      });
-  }
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSIframeGadget
-  /////////////////////////////////////////////////////////////////
-  function RenderJSIframeGadget() {
-    if (!(this instanceof RenderJSIframeGadget)) {
-      return new RenderJSIframeGadget();
-    }
-    RenderJSGadget.call(this);
-  }
-  RenderJSIframeGadget.__ready_list = RenderJSGadget.__ready_list.slice();
-  RenderJSIframeGadget.ready =
-    RenderJSGadget.ready;
-  RenderJSIframeGadget.__service_list = RenderJSGadget.__service_list.slice();
-  RenderJSIframeGadget.declareService =
-    RenderJSGadget.declareService;
-  RenderJSIframeGadget.prototype = new RenderJSGadget();
-  RenderJSIframeGadget.prototype.constructor = RenderJSIframeGadget;
-
-  /////////////////////////////////////////////////////////////////
-  // privateDeclareIframeGadget
-  /////////////////////////////////////////////////////////////////
-  function privateDeclareIframeGadget(url, options, parent_gadget) {
-    var gadget_instance,
-      iframe,
-      iframe_loading_deferred = RSVP.defer();
-    if (options.element === undefined) {
-      throw new Error("DOM element is required to create Iframe Gadget " +
-                      url);
-    }
-
-    // Check if the element is attached to the DOM
-    if (!document.contains(options.element)) {
-      throw new Error("The parent element is not attached to the DOM for " +
-                      url);
-    }
-
-    gadget_instance = new RenderJSIframeGadget();
-    setAqParent(gadget_instance, parent_gadget);
-    iframe = document.createElement("iframe");
-//    gadget_instance.element.setAttribute("seamless", "seamless");
-    iframe.setAttribute("src", url);
-    gadget_instance.__path = url;
-    gadget_instance.__element = options.element;
-    // Attach it to the DOM
-    options.element.appendChild(iframe);
-
-    // XXX Manage unbind when deleting the gadget
-
-    // Create the communication channel with the iframe
-    gadget_instance.__chan = Channel.build({
-      window: iframe.contentWindow,
-      origin: "*",
-      scope: "renderJS"
-    });
-
-    // Create new method from the declareMethod call inside the iframe
-    gadget_instance.__chan.bind("declareMethod",
-                                function (trans, method_name) {
-        gadget_instance[method_name] = function () {
-          var argument_list = arguments,
-            wait_promise = new RSVP.Promise(function (resolve, reject) {
-              gadget_instance.__chan.call({
-                method: "methodCall",
-                params: [
-                  method_name,
-                  Array.prototype.slice.call(argument_list, 0)],
-                success: function (s) {
-                  resolve(s);
-                },
-                error: function (e) {
-                  reject(e);
-                }
-              });
-            });
-          return new RSVP.Queue()
-            .push(function () {
-              return wait_promise;
-            });
-        };
-        return "OK";
-      });
-
-    // Wait for the iframe to be loaded before continuing
-    gadget_instance.__chan.bind("ready", function (trans) {
-      iframe_loading_deferred.resolve(gadget_instance);
-      return "OK";
-    });
-    gadget_instance.__chan.bind("failed", function (trans, params) {
-      iframe_loading_deferred.reject(params);
-      return "OK";
-    });
-    gadget_instance.__chan.bind("acquire", function (trans, params) {
-      gadget_instance.__aq_parent.apply(gadget_instance, params)
-        .then(function (g) {
-          trans.complete(g);
-        }).fail(function (e) {
-          trans.error(e.toString());
-        });
-      trans.delayReturn(true);
-    });
-
-    return RSVP.any([
-      iframe_loading_deferred.promise,
-      // Timeout to prevent non renderJS embeddable gadget
-      // XXX Maybe using iframe.onload/onerror would be safer?
-      RSVP.timeout(25000)
-    ]);
-  }
-
-  /////////////////////////////////////////////////////////////////
-  // privateDeclareDataUrlGadget
-  /////////////////////////////////////////////////////////////////
-  function privateDeclareDataUrlGadget(url, options, parent_gadget) {
-
-    return new RSVP.Queue()
-      .push(function () {
-        return ajax(url);
-      })
-      .push(function (xhr) {
-        // Insert a "base" element, in order to resolve all relative links
-        // which could get broken with a data url
-        var doc = (new DOMParser()).parseFromString(xhr.responseText,
-                                                    'text/html'),
-          base = doc.createElement('base'),
-          blob;
-        base.href = url;
-        doc.head.insertBefore(base, doc.head.firstChild);
-        blob = new Blob([doc.documentElement.outerHTML],
-                        {type: "text/html;charset=UTF-8"});
-        return readBlobAsDataURL(blob);
-      })
-      .push(function (data_url) {
-        return privateDeclareIframeGadget(data_url, options, parent_gadget);
-      });
-  }
-
-  /////////////////////////////////////////////////////////////////
-  // RenderJSGadget.declareGadget
-  /////////////////////////////////////////////////////////////////
-  RenderJSGadget
-    .declareMethod('declareGadget', function (url, options) {
-      var queue,
-        parent_gadget = this,
-        local_loading_klass_promise,
-        previous_loading_klass_promise = loading_klass_promise;
-
-      if (options === undefined) {
-        options = {};
-      }
-      if (options.sandbox === undefined) {
-        options.sandbox = "public";
-      }
-
-      // transform url to absolute url if it is relative
-      url = renderJS.getAbsoluteURL(url, this.__path);
-      // Change the global variable to update the loading queue
-      loading_klass_promise = new RSVP.Queue()
-        // Wait for previous gadget loading to finish first
-        .push(function () {
-          return previous_loading_klass_promise;
-        })
-        .push(undefined, function () {
-          // Forget previous declareGadget error
-          return;
-        })
-        .push(function () {
-          var method;
-          if (options.sandbox === "public") {
-            method = privateDeclarePublicGadget;
-          } else if (options.sandbox === "iframe") {
-            method = privateDeclareIframeGadget;
-          } else if (options.sandbox === "dataurl") {
-            method = privateDeclareDataUrlGadget;
-          } else {
-            throw new Error("Unsupported sandbox options '" +
-                            options.sandbox + "'");
-          }
-          return method(url, options, parent_gadget);
-        })
-        // Set the HTML context
-        .push(function (gadget_instance) {
-          // Drop the current loading klass info used by selector
-          gadget_loading_klass = undefined;
-          return gadget_instance;
-        })
-        .push(undefined, function (e) {
-          // Drop the current loading klass info used by selector
-          // even in case of error
-          gadget_loading_klass = undefined;
-          throw e;
-        });
-      local_loading_klass_promise = loading_klass_promise;
-
-      queue = new RSVP.Queue()
-        .push(function () {
-          return local_loading_klass_promise;
-        })
-        // Set the HTML context
-        .push(function (gadget_instance) {
-          var i,
-            scope;
-          // Trigger calling of all ready callback
-          function ready_wrapper() {
-            return gadget_instance;
-          }
-          for (i = 0; i < gadget_instance.constructor.__ready_list.length;
-               i += 1) {
-            // Put a timeout?
-            queue.push(gadget_instance.constructor.__ready_list[i]);
-            // Always return the gadget instance after ready function
-            queue.push(ready_wrapper);
-          }
-
-          // Store local reference to the gadget instance
-          scope = options.scope;
-          if (scope === undefined) {
-            scope = 'RJS_' + scope_increment;
-            scope_increment += 1;
-            while (parent_gadget.__sub_gadget_dict.hasOwnProperty(scope)) {
-              scope = 'RJS_' + scope_increment;
-              scope_increment += 1;
-            }
-          }
-          parent_gadget.__sub_gadget_dict[scope] = gadget_instance;
-          gadget_instance.__element.setAttribute("data-gadget-scope",
-                                                 scope);
-
-          // Put some attribute to ease page layout comprehension
-          gadget_instance.__element.setAttribute("data-gadget-url", url);
-          gadget_instance.__element.setAttribute("data-gadget-sandbox",
-                                                 options.sandbox);
-          gadget_instance.__element._gadget = gadget_instance;
-
-          if (document.contains(gadget_instance.__element)) {
-            // Put a timeout
-            queue.push(startService);
-          }
-          // Always return the gadget instance after ready function
-          queue.push(ready_wrapper);
-
-          return gadget_instance;
-        });
-      return queue;
-    })
-    .declareMethod('getDeclaredGadget', function (gadget_scope) {
-      if (!this.__sub_gadget_dict.hasOwnProperty(gadget_scope)) {
-        throw new Error("Gadget scope '" + gadget_scope + "' is not known.");
-      }
-      return this.__sub_gadget_dict[gadget_scope];
-    })
-    .declareMethod('dropGadget', function (gadget_scope) {
-      if (!this.__sub_gadget_dict.hasOwnProperty(gadget_scope)) {
-        throw new Error("Gadget scope '" + gadget_scope + "' is not known.");
-      }
-      // http://perfectionkills.com/understanding-delete/
-      delete this.__sub_gadget_dict[gadget_scope];
-    });
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS selector
-  /////////////////////////////////////////////////////////////////
-  renderJS = function (selector) {
-    var result;
-    if (selector === window) {
-      // window is the 'this' value when loading a javascript file
-      // In this case, use the current loading gadget constructor
-      result = gadget_loading_klass;
-    }
-    if (result === undefined) {
-      throw new Error("Unknown selector '" + selector + "'");
-    }
-    return result;
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.AcquisitionError
-  /////////////////////////////////////////////////////////////////
-  renderJS.AcquisitionError = function (message) {
-    this.name = "AcquisitionError";
-    if ((message !== undefined) && (typeof message !== "string")) {
-      throw new TypeError('You must pass a string.');
-    }
-    this.message = message || "Acquisition failed";
-  };
-  renderJS.AcquisitionError.prototype = new Error();
-  renderJS.AcquisitionError.prototype.constructor =
-    renderJS.AcquisitionError;
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.getAbsoluteURL
-  /////////////////////////////////////////////////////////////////
-  renderJS.getAbsoluteURL = function (url, base_url) {
-    var doc, base, link,
-      html = "<!doctype><html><head></head></html>";
-
-    if (url && base_url && !isAbsoluteOrDataURL.test(url)) {
-      doc = (new DOMParser()).parseFromString(html, 'text/html');
-      base = doc.createElement('base');
-      link = doc.createElement('link');
-      doc.head.appendChild(base);
-      doc.head.appendChild(link);
-      base.href = base_url;
-      link.href = url;
-      return link.href;
-    }
-    return url;
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.declareJS
-  /////////////////////////////////////////////////////////////////
-  renderJS.declareJS = function (url) {
-    // Prevent infinite recursion if loading render.js
-    // more than once
-    var result;
-    if (javascript_registration_dict.hasOwnProperty(url)) {
-      result = RSVP.resolve();
-    } else {
-      result = new RSVP.Promise(function (resolve, reject) {
-        var newScript;
-        newScript = document.createElement('script');
-        newScript.type = 'text/javascript';
-        newScript.src = url;
-        newScript.onload = function () {
-          javascript_registration_dict[url] = null;
-          resolve();
-        };
-        newScript.onerror = function (e) {
-          reject(e);
-        };
-        document.head.appendChild(newScript);
-      });
-    }
-    return result;
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.declareCSS
-  /////////////////////////////////////////////////////////////////
-  renderJS.declareCSS = function (url) {
-    // https://github.com/furf/jquery-getCSS/blob/master/jquery.getCSS.js
-    // No way to cleanly check if a css has been loaded
-    // So, always resolve the promise...
-    // http://requirejs.org/docs/faq-advanced.html#css
-    var result;
-    if (stylesheet_registration_dict.hasOwnProperty(url)) {
-      result = RSVP.resolve();
-    } else {
-      result = new RSVP.Promise(function (resolve, reject) {
-        var link;
-        link = document.createElement('link');
-        link.rel = 'stylesheet';
-        link.type = 'text/css';
-        link.href = url;
-        link.onload = function () {
-          stylesheet_registration_dict[url] = null;
-          resolve();
-        };
-        link.onerror = function (e) {
-          reject(e);
-        };
-        document.head.appendChild(link);
-      });
-    }
-    return result;
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.declareGadgetKlass
-  /////////////////////////////////////////////////////////////////
-  renderJS.declareGadgetKlass = function (url) {
-    var result;
-
-    function parse(xhr) {
-      var tmp_constructor,
-        key,
-        parsed_html;
-      if (!gadget_model_dict.hasOwnProperty(url)) {
-        // Class inheritance
-        tmp_constructor = function () {
-          RenderJSGadget.call(this);
-        };
-        tmp_constructor.__ready_list = RenderJSGadget.__ready_list.slice();
-        tmp_constructor.__service_list = RenderJSGadget.__service_list.slice();
-        tmp_constructor.declareMethod =
-          RenderJSGadget.declareMethod;
-        tmp_constructor.declareAcquiredMethod =
-          RenderJSGadget.declareAcquiredMethod;
-        tmp_constructor.allowPublicAcquisition =
-          RenderJSGadget.allowPublicAcquisition;
-        tmp_constructor.ready =
-          RenderJSGadget.ready;
-        tmp_constructor.declareService =
-          RenderJSGadget.declareService;
-        tmp_constructor.prototype = new RenderJSGadget();
-        tmp_constructor.prototype.constructor = tmp_constructor;
-        tmp_constructor.prototype.__path = url;
-        tmp_constructor.prototype.__acquired_method_dict = {};
-        // https://developer.mozilla.org/en-US/docs/HTML_in_XMLHttpRequest
-        // https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
-        // https://developer.mozilla.org/en-US/docs/Code_snippets/HTML_to_DOM
-        tmp_constructor.__template_element =
-          (new DOMParser()).parseFromString(xhr.responseText, "text/html");
-        parsed_html = renderJS.parseGadgetHTMLDocument(
-          tmp_constructor.__template_element,
-          url
-        );
-        for (key in parsed_html) {
-          if (parsed_html.hasOwnProperty(key)) {
-            tmp_constructor.prototype['__' + key] = parsed_html[key];
-          }
-        }
-
-        gadget_model_dict[url] = tmp_constructor;
-      }
-
-      return gadget_model_dict[url];
-    }
-
-    if (gadget_model_dict.hasOwnProperty(url)) {
-      // Return klass object if it already exists
-      result = RSVP.resolve(gadget_model_dict[url]);
-    } else {
-      // Fetch the HTML page and parse it
-      result = new RSVP.Queue()
-        .push(function () {
-          return ajax(url);
-        })
-        .push(function (xhr) {
-          return parse(xhr);
-        });
-    }
-    return result;
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.clearGadgetKlassList
-  /////////////////////////////////////////////////////////////////
-  // For test purpose only
-  renderJS.clearGadgetKlassList = function () {
-    gadget_model_dict = {};
-    javascript_registration_dict = {};
-    stylesheet_registration_dict = {};
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // renderJS.parseGadgetHTMLDocument
-  /////////////////////////////////////////////////////////////////
-  renderJS.parseGadgetHTMLDocument = function (document_element, url) {
-    var settings = {
-        title: "",
-        interface_list: [],
-        required_css_list: [],
-        required_js_list: []
-      },
-      i,
-      element;
-
-    if (!url || !isAbsoluteOrDataURL.test(url)) {
-      throw new Error("The url should be absolute: " + url);
-    }
-
-    if (document_element.nodeType === 9) {
-      settings.title = document_element.title;
-
-      if (document_element.head !== null) {
-        for (i = 0; i < document_element.head.children.length; i += 1) {
-          element = document_element.head.children[i];
-          if (element.href !== null) {
-            // XXX Manage relative URL during extraction of URLs
-            // element.href returns absolute URL in firefox but "" in chrome;
-            if (element.rel === "stylesheet") {
-              settings.required_css_list.push(
-                renderJS.getAbsoluteURL(element.getAttribute("href"), url)
-              );
-            } else if (element.nodeName === "SCRIPT" &&
-                       (element.type === "text/javascript" ||
-                        !element.type)) {
-              settings.required_js_list.push(
-                renderJS.getAbsoluteURL(element.getAttribute("src"), url)
-              );
-            } else if (element.rel ===
-                       "http://www.renderjs.org/rel/interface") {
-              settings.interface_list.push(
-                renderJS.getAbsoluteURL(element.getAttribute("href"), url)
-              );
-            }
-          }
-        }
-      }
-    } else {
-      throw new Error("The first parameter should be an HTMLDocument");
-    }
-    return settings;
-  };
-
-  /////////////////////////////////////////////////////////////////
-  // global
-  /////////////////////////////////////////////////////////////////
-  window.rJS = window.renderJS = renderJS;
-  window.__RenderJSGadget = RenderJSGadget;
-  window.__RenderJSEmbeddedGadget = RenderJSEmbeddedGadget;
-  window.__RenderJSIframeGadget = RenderJSIframeGadget;
-
-  ///////////////////////////////////////////////////
-  // Bootstrap process. Register the self gadget.
-  ///////////////////////////////////////////////////
-
-  function bootstrap() {
-    var url = removeHash(window.location.href),
-      tmp_constructor,
-      root_gadget,
-      loading_gadget_promise = new RSVP.Queue(),
-      declare_method_count = 0,
-      embedded_channel,
-      notifyReady,
-      notifyDeclareMethod,
-      gadget_ready = false,
-      iframe_top_gadget,
-      last_acquisition_gadget,
-      declare_method_list_waiting = [],
-      gadget_failed = false,
-      gadget_error,
-      connection_ready = false;
-
-    // Create the gadget class for the current url
-    if (gadget_model_dict.hasOwnProperty(url)) {
-      throw new Error("bootstrap should not be called twice");
-    }
-    loading_klass_promise = new RSVP.Promise(function (resolve, reject) {
-
-      last_acquisition_gadget = new RenderJSGadget();
-      last_acquisition_gadget.__acquired_method_dict = {
-        getTopURL: function () {
-          return url;
-        },
-        reportServiceError: function (param_list) {
-          letsCrash(param_list[0]);
-        }
-      };
-      // Stop acquisition on the last acquisition gadget
-      // Do not put this on the klass, as their could be multiple instances
-      last_acquisition_gadget.__aq_parent = function (method_name) {
-        throw new renderJS.AcquisitionError(
-          "No gadget provides " + method_name
-        );
-      };
-
-      //we need to determine tmp_constructor's value before exit bootstrap
-      //because of function : renderJS
-      //but since the channel checking is async,
-      //we can't use code structure like:
-      // if channel communication is ok
-      //    tmp_constructor = RenderJSGadget
-      // else
-      //    tmp_constructor = RenderJSEmbeddedGadget
-      if (window.self === window.top) {
-        // XXX Copy/Paste from declareGadgetKlass
-        tmp_constructor = function () {
-          RenderJSGadget.call(this);
-        };
-        tmp_constructor.declareMethod = RenderJSGadget.declareMethod;
-        tmp_constructor.declareAcquiredMethod =
-          RenderJSGadget.declareAcquiredMethod;
-        tmp_constructor.allowPublicAcquisition =
-          RenderJSGadget.allowPublicAcquisition;
-        tmp_constructor.__ready_list = RenderJSGadget.__ready_list.slice();
-        tmp_constructor.ready = RenderJSGadget.ready;
-        tmp_constructor.__service_list = RenderJSGadget.__service_list.slice();
-        tmp_constructor.declareService =
-          RenderJSGadget.declareService;
-        tmp_constructor.prototype = new RenderJSGadget();
-        tmp_constructor.prototype.constructor = tmp_constructor;
-        tmp_constructor.prototype.__path = url;
-        gadget_model_dict[url] = tmp_constructor;
-
-        // Create the root gadget instance and put it in the loading stack
-        root_gadget = new gadget_model_dict[url]();
-
-        setAqParent(root_gadget, last_acquisition_gadget);
-
-      } else {
-        // Create the root gadget instance and put it in the loading stack
-        tmp_constructor = RenderJSEmbeddedGadget;
-        tmp_constructor.__ready_list = RenderJSGadget.__ready_list.slice();
-        tmp_constructor.__service_list = RenderJSGadget.__service_list.slice();
-        tmp_constructor.prototype.__path = url;
-        root_gadget = new RenderJSEmbeddedGadget();
-        setAqParent(root_gadget, last_acquisition_gadget);
-
-        // Create the communication channel
-        embedded_channel = Channel.build({
-          window: window.parent,
-          origin: "*",
-          scope: "renderJS",
-          onReady: function () {
-            var k;
-            iframe_top_gadget = false;
-            //Default: Define __aq_parent to inform parent window
-            root_gadget.__aq_parent =
-              tmp_constructor.prototype.__aq_parent = function (method_name,
-                argument_list, time_out) {
-                return new RSVP.Promise(function (resolve, reject) {
-                  embedded_channel.call({
-                    method: "acquire",
-                    params: [
-                      method_name,
-                      argument_list
-                    ],
-                    success: function (s) {
-                      resolve(s);
-                    },
-                    error: function (e) {
-                      reject(e);
-                    },
-                    timeout: time_out
-                  });
-                });
-              };
-
-            // Channel is ready, so now declare Function
-            notifyDeclareMethod = function (name) {
-              declare_method_count += 1;
-              embedded_channel.call({
-                method: "declareMethod",
-                params: name,
-                success: function () {
-                  declare_method_count -= 1;
-                  notifyReady();
-                },
-                error: function () {
-                  declare_method_count -= 1;
-                }
-              });
-            };
-            for (k = 0; k < declare_method_list_waiting.length; k += 1) {
-              notifyDeclareMethod(declare_method_list_waiting[k]);
-            }
-            declare_method_list_waiting = [];
-            // If Gadget Failed Notify Parent
-            if (gadget_failed) {
-              embedded_channel.notify({
-                method: "failed",
-                params: gadget_error
-              });
-              return;
-            }
-            // Get Top URL
-            return tmp_constructor.prototype.__aq_parent('getTopURL', [])
-              .then(function (topURL) {
-                var base = document.createElement('base');
-                base.href = topURL;
-                base.target = "_top";
-                document.head.appendChild(base);
-                connection_ready = true;
-                notifyReady();
-                //the channel is ok
-                //so bind calls to renderJS method on the instance
-                embedded_channel.bind("methodCall", function (trans, v) {
-                  root_gadget[v[0]].apply(root_gadget, v[1])
-                    .then(function (g) {
-                      trans.complete(g);
-                    }).fail(function (e) {
-                      trans.error(e.toString());
-                    });
-                  trans.delayReturn(true);
-                });
-              })
-              .fail(function (error) {
-                throw error;
-              });
-          }
-        });
-
-        // Notify parent about gadget instanciation
-        notifyReady = function () {
-          if ((declare_method_count === 0) && (gadget_ready === true)) {
-            embedded_channel.notify({method: "ready"});
-          }
-        };
-
-        // Inform parent gadget about declareMethod calls here.
-        notifyDeclareMethod = function (name) {
-          declare_method_list_waiting.push(name);
-        };
-
-        notifyDeclareMethod("getInterfaceList");
-        notifyDeclareMethod("getRequiredCSSList");
-        notifyDeclareMethod("getRequiredJSList");
-        notifyDeclareMethod("getPath");
-        notifyDeclareMethod("getTitle");
-
-        // Surcharge declareMethod to inform parent window
-        tmp_constructor.declareMethod = function (name, callback) {
-          var result = RenderJSGadget.declareMethod.apply(
-              this,
-              [name, callback]
-            );
-          notifyDeclareMethod(name);
-          return result;
-        };
-
-        tmp_constructor.declareService =
-          RenderJSGadget.declareService;
-        tmp_constructor.declareAcquiredMethod =
-          RenderJSGadget.declareAcquiredMethod;
-        tmp_constructor.allowPublicAcquisition =
-          RenderJSGadget.allowPublicAcquisition;
-
-        iframe_top_gadget = true;
-      }
-
-      tmp_constructor.prototype.__acquired_method_dict = {};
-      gadget_loading_klass = tmp_constructor;
-
-      function init() {
-        // XXX HTML properties can only be set when the DOM is fully loaded
-        var settings = renderJS.parseGadgetHTMLDocument(document, url),
-          j,
-          key;
-        for (key in settings) {
-          if (settings.hasOwnProperty(key)) {
-            tmp_constructor.prototype['__' + key] = settings[key];
-          }
-        }
-        tmp_constructor.__template_element = document.createElement("div");
-        root_gadget.__element = document.body;
-        for (j = 0; j < root_gadget.__element.childNodes.length; j += 1) {
-          tmp_constructor.__template_element.appendChild(
-            root_gadget.__element.childNodes[j].cloneNode(true)
-          );
-        }
-        RSVP.all([root_gadget.getRequiredJSList(),
-                  root_gadget.getRequiredCSSList()])
-          .then(function (all_list) {
-            var i,
-              js_list = all_list[0],
-              css_list = all_list[1];
-            for (i = 0; i < js_list.length; i += 1) {
-              javascript_registration_dict[js_list[i]] = null;
-            }
-            for (i = 0; i < css_list.length; i += 1) {
-              stylesheet_registration_dict[css_list[i]] = null;
-            }
-            gadget_loading_klass = undefined;
-          }).then(function () {
-
-            // select the target node
-            var target = document.querySelector('body'),
-              // create an observer instance
-              observer = new MutationObserver(function (mutations) {
-                var i, k, len, len2, node, added_list;
-                mutations.forEach(function (mutation) {
-                  if (mutation.type === 'childList') {
-
-                    len = mutation.removedNodes.length;
-                    for (i = 0; i < len; i += 1) {
-                      node = mutation.removedNodes[i];
-                      if (node.nodeType === Node.ELEMENT_NODE) {
-                        if (node.hasAttribute("data-gadget-url") &&
-                            (node._gadget !== undefined)) {
-                          createMonitor(node._gadget);
-                        }
-                        added_list =
-                          node.querySelectorAll("[data-gadget-url]");
-                        len2 = added_list.length;
-                        for (k = 0; k < len2; k += 1) {
-                          node = added_list[k];
-                          if (node._gadget !== undefined) {
-                            createMonitor(node._gadget);
-                          }
-                        }
-                      }
-                    }
-
-                    len = mutation.addedNodes.length;
-                    for (i = 0; i < len; i += 1) {
-                      node = mutation.addedNodes[i];
-                      if (node.nodeType === Node.ELEMENT_NODE) {
-                        if (node.hasAttribute("data-gadget-url") &&
-                            (node._gadget !== undefined)) {
-                          if (document.contains(node)) {
-                            startService(node._gadget);
-                          }
-                        }
-                        added_list =
-                          node.querySelectorAll("[data-gadget-url]");
-                        len2 = added_list.length;
-                        for (k = 0; k < len2; k += 1) {
-                          node = added_list[k];
-                          if (document.contains(node)) {
-                            if (node._gadget !== undefined) {
-                              startService(node._gadget);
-                            }
-                          }
-                        }
-                      }
-                    }
-
-                  }
-                });
-              }),
-              // configuration of the observer:
-              config = {
-                childList: true,
-                subtree: true,
-                attributes: false,
-                characterData: false
-              };
-
-            // pass in the target node, as well as the observer options
-            observer.observe(target, config);
-
-            return root_gadget;
-          }).then(resolve, function (e) {
-            reject(e);
-            console.error(e);
-            throw e;
-          });
-      }
-      document.addEventListener('DOMContentLoaded', init, false);
-    });
-
-    loading_gadget_promise
-      .push(function () {
-        return loading_klass_promise;
-      })
-      .push(function (root_gadget) {
-        var i;
-
-        function ready_wrapper() {
-          return root_gadget;
-        }
-
-        tmp_constructor.ready(function (g) {
-          return startService(g);
-        });
-
-        loading_gadget_promise.push(ready_wrapper);
-        for (i = 0; i < tmp_constructor.__ready_list.length; i += 1) {
-          // Put a timeout?
-          loading_gadget_promise
-            .push(tmp_constructor.__ready_list[i])
-            // Always return the gadget instance after ready function
-            .push(ready_wrapper);
-        }
-      });
-    if (window.self === window.top) {
-      loading_gadget_promise
-        .fail(function (e) {
-          letsCrash(e);
-          throw e;
-        });
-    } else {
-      // Inform parent window that gadget is correctly loaded
-      loading_gadget_promise
-        .then(function () {
-          gadget_ready = true;
-          if (connection_ready) {
-            notifyReady();
-          }
-        })
-        .fail(function (e) {
-          //top gadget in iframe
-          if (iframe_top_gadget) {
-            gadget_failed = true;
-            gadget_error = e.toString();
-            letsCrash(e);
-          } else {
-            embedded_channel.notify({method: "failed", params: e.toString()});
-          }
-          throw e;
-        });
-    }
-
-  }
-  bootstrap();
-
-}(document, window, RSVP, DOMParser, Channel, MutationObserver, Node,
-  FileReader, Blob));
\ No newline at end of file
diff --git a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/renderjs.js.xml b/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/renderjs.js.xml
deleted file mode 100644
index aaba071d2e887770bac49a803c656b983c6e9021..0000000000000000000000000000000000000000
--- a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/renderjs.js.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0"?>
-<ZopeData>
-  <record id="1" aka="AAAAAAAAAAE=">
-    <pickle>
-      <global name="File" module="OFS.Image"/>
-    </pickle>
-    <pickle>
-      <dictionary>
-        <item>
-            <key> <string>__name__</string> </key>
-            <value> <string>renderjs.js</string> </value>
-        </item>
-        <item>
-            <key> <string>content_type</string> </key>
-            <value> <string>application/javascript</string> </value>
-        </item>
-        <item>
-            <key> <string>precondition</string> </key>
-            <value> <string></string> </value>
-        </item>
-        <item>
-            <key> <string>title</string> </key>
-            <value> <string>renderjs.js</string> </value>
-        </item>
-      </dictionary>
-    </pickle>
-  </record>
-</ZopeData>
diff --git a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/rsvp.js.js b/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/rsvp.js.js
deleted file mode 100644
index 13e2f3b6c6e9735c24579d49cfd385553dc354b9..0000000000000000000000000000000000000000
--- a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/rsvp.js.js
+++ /dev/null
@@ -1,1001 +0,0 @@
-(function(globals) {
-var define, requireModule;
-
-(function() {
-  var registry = {}, seen = {};
-
-  define = function(name, deps, callback) {
-    registry[name] = { deps: deps, callback: callback };
-  };
-
-  requireModule = function(name) {
-    if (seen[name]) { return seen[name]; }
-    seen[name] = {};
-
-    var mod = registry[name];
-    if (!mod) {
-      throw new Error("Module '" + name + "' not found.");
-    }
-
-    var deps = mod.deps,
-        callback = mod.callback,
-        reified = [],
-        exports;
-
-    for (var i=0, l=deps.length; i<l; i++) {
-      if (deps[i] === 'exports') {
-        reified.push(exports = {});
-      } else {
-        reified.push(requireModule(deps[i]));
-      }
-    }
-
-    var value = callback.apply(this, reified);
-    return seen[name] = exports || value;
-  };
-})();
-
-define("rsvp/all",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    /* global toString */
-
-
-    function promiseAtLeast(expected_count, promises) {
-      if (Object.prototype.toString.call(promises) !== "[object Array]") {
-        throw new TypeError('You must pass an array to all.');
-      }
-
-      function canceller() {
-        var promise;
-        for (var i = 0; i < promises.length; i++) {
-          promise = promises[i];
-
-          if (promise && typeof promise.then === 'function' &&
-              typeof promise.cancel === 'function') {
-            promise.cancel();
-          }
-        }
-      }
-
-      return new Promise(function(resolve, reject, notify) {
-        var results = [], remaining = promises.length,
-        promise, remaining_count = promises.length - expected_count;
-
-        if (remaining === 0) {
-          if (expected_count === 1) {
-            resolve();
-          } else {
-            resolve([]);
-          }
-        }
-
-        function resolver(index) {
-          return function(value) {
-            resolveAll(index, value);
-          };
-        }
-
-        function resolveAll(index, value) {
-          results[index] = value;
-          if (--remaining === remaining_count) {
-            if (remaining_count === 0) {
-              resolve(results);
-            } else {
-              resolve(value);
-              canceller();
-            }
-          }
-        }
-
-        function notifier(index) {
-          return function(value) {
-            notify({"index": index, "value": value});
-          };
-        }
-
-        function cancelAll(rejectionValue) {
-          reject(rejectionValue);
-          canceller();
-        }
-
-        for (var i = 0; i < promises.length; i++) {
-          promise = promises[i];
-
-          if (promise && typeof promise.then === 'function') {
-            promise.then(resolver(i), cancelAll, notifier(i));
-          } else {
-            resolveAll(i, promise);
-          }
-        }
-      }, canceller
-      );
-    }
-
-    function all(promises) {
-      return promiseAtLeast(promises.length, promises);
-    }
-
-    function any(promises) {
-      return promiseAtLeast(1, promises);
-    }
-
-
-    __exports__.all = all;
-    __exports__.any = any;
-  });
-define("rsvp/async",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var browserGlobal = (typeof window !== 'undefined') ? window : {};
-    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-    var async;
-    var local = (typeof global !== 'undefined') ? global : this;
-
-    // old node
-    function useNextTick() {
-      return function(callback, arg) {
-        process.nextTick(function() {
-          callback(arg);
-        });
-      };
-    }
-
-    // node >= 0.10.x
-    function useSetImmediate() {
-      return function(callback, arg) {
-        /* global  setImmediate */
-        setImmediate(function(){
-          callback(arg);
-        });
-      };
-    }
-
-    function useMutationObserver() {
-      var queue = [];
-
-      var observer = new BrowserMutationObserver(function() {
-        var toProcess = queue.slice();
-        queue = [];
-
-        toProcess.forEach(function(tuple) {
-          var callback = tuple[0], arg= tuple[1];
-          callback(arg);
-        });
-      });
-
-      var element = document.createElement('div');
-      observer.observe(element, { attributes: true });
-
-      // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
-      window.addEventListener('unload', function(){
-        observer.disconnect();
-        observer = null;
-      }, false);
-
-      return function(callback, arg) {
-        queue.push([callback, arg]);
-        element.setAttribute('drainQueue', 'drainQueue');
-      };
-    }
-
-    function useSetTimeout() {
-      return function(callback, arg) {
-        local.setTimeout(function() {
-          callback(arg);
-        }, 1);
-      };
-    }
-
-    if (typeof setImmediate === 'function') {
-      async = useSetImmediate();
-    } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
-      async = useNextTick();
-    } else if (BrowserMutationObserver) {
-      async = useMutationObserver();
-    } else {
-      async = useSetTimeout();
-    }
-
-
-    __exports__.async = async;
-  });
-define("rsvp/cancellation_error",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
-    function CancellationError(message) {
-      this.name = "cancel";
-      if ((message !== undefined) && (typeof message !== "string")) {
-        throw new TypeError('You must pass a string.');
-      }
-      this.message = message || "Default Message";
-    }
-    CancellationError.prototype = new Error();
-    CancellationError.prototype.constructor = CancellationError;
-
-
-    __exports__.CancellationError = CancellationError;
-  });
-define("rsvp/config",
-  ["rsvp/async","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var async = __dependency1__.async;
-
-    var config = {};
-    config.async = async;
-
-
-    __exports__.config = config;
-  });
-define("rsvp/defer",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function defer() {
-      var deferred = {
-        // pre-allocate shape
-        resolve: undefined,
-        reject:  undefined,
-        promise: undefined
-      };
-
-      deferred.promise = new Promise(function(resolve, reject) {
-        deferred.resolve = resolve;
-        deferred.reject = reject;
-      });
-
-      return deferred;
-    }
-
-
-    __exports__.defer = defer;
-  });
-define("rsvp/events",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var Event = function(type, options) {
-      this.type = type;
-
-      for (var option in options) {
-        if (!options.hasOwnProperty(option)) { continue; }
-
-        this[option] = options[option];
-      }
-    };
-
-    var indexOf = function(callbacks, callback) {
-      for (var i=0, l=callbacks.length; i<l; i++) {
-        if (callbacks[i][0] === callback) { return i; }
-      }
-
-      return -1;
-    };
-
-    var callbacksFor = function(object) {
-      var callbacks = object._promiseCallbacks;
-
-      if (!callbacks) {
-        callbacks = object._promiseCallbacks = {};
-      }
-
-      return callbacks;
-    };
-
-    var EventTarget = {
-      mixin: function(object) {
-        object.on = this.on;
-        object.off = this.off;
-        object.trigger = this.trigger;
-        return object;
-      },
-
-      on: function(eventNames, callback, binding) {
-        var allCallbacks = callbacksFor(this), callbacks, eventName;
-        eventNames = eventNames.split(/\s+/);
-        binding = binding || this;
-
-        while (eventName = eventNames.shift()) {
-          callbacks = allCallbacks[eventName];
-
-          if (!callbacks) {
-            callbacks = allCallbacks[eventName] = [];
-          }
-
-          if (indexOf(callbacks, callback) === -1) {
-            callbacks.push([callback, binding]);
-          }
-        }
-      },
-
-      off: function(eventNames, callback) {
-        var allCallbacks = callbacksFor(this), callbacks, eventName, index;
-        eventNames = eventNames.split(/\s+/);
-
-        while (eventName = eventNames.shift()) {
-          if (!callback) {
-            allCallbacks[eventName] = [];
-            continue;
-          }
-
-          callbacks = allCallbacks[eventName];
-
-          index = indexOf(callbacks, callback);
-
-          if (index !== -1) { callbacks.splice(index, 1); }
-        }
-      },
-
-      trigger: function(eventName, options) {
-        var allCallbacks = callbacksFor(this),
-            callbacks, callbackTuple, callback, binding, event;
-
-        if (callbacks = allCallbacks[eventName]) {
-          // Don't cache the callbacks.length since it may grow
-          for (var i=0; i<callbacks.length; i++) {
-            callbackTuple = callbacks[i];
-            callback = callbackTuple[0];
-            binding = callbackTuple[1];
-
-            if (typeof options !== 'object') {
-              options = { detail: options };
-            }
-
-            event = new Event(eventName, options);
-            callback.call(binding, event);
-          }
-        }
-      }
-    };
-
-
-    __exports__.EventTarget = EventTarget;
-  });
-define("rsvp/hash",
-  ["rsvp/defer","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var defer = __dependency1__.defer;
-
-    function size(object) {
-      var s = 0;
-
-      for (var prop in object) {
-        s++;
-      }
-
-      return s;
-    }
-
-    function hash(promises) {
-      var results = {}, deferred = defer(), remaining = size(promises);
-
-      if (remaining === 0) {
-        deferred.resolve({});
-      }
-
-      var resolver = function(prop) {
-        return function(value) {
-          resolveAll(prop, value);
-        };
-      };
-
-      var resolveAll = function(prop, value) {
-        results[prop] = value;
-        if (--remaining === 0) {
-          deferred.resolve(results);
-        }
-      };
-
-      var rejectAll = function(error) {
-        deferred.reject(error);
-      };
-
-      for (var prop in promises) {
-        if (promises[prop] && typeof promises[prop].then === 'function') {
-          promises[prop].then(resolver(prop), rejectAll);
-        } else {
-          resolveAll(prop, promises[prop]);
-        }
-      }
-
-      return deferred.promise;
-    }
-
-
-    __exports__.hash = hash;
-  });
-define("rsvp/node",
-  ["rsvp/promise","rsvp/all","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    var all = __dependency2__.all;
-
-    function makeNodeCallbackFor(resolve, reject) {
-      return function (error, value) {
-        if (error) {
-          reject(error);
-        } else if (arguments.length > 2) {
-          resolve(Array.prototype.slice.call(arguments, 1));
-        } else {
-          resolve(value);
-        }
-      };
-    }
-
-    function denodeify(nodeFunc) {
-      return function()  {
-        var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
-        var thisArg = this;
-
-        var promise = new Promise(function(nodeResolve, nodeReject) {
-          resolve = nodeResolve;
-          reject = nodeReject;
-        });
-
-        all(nodeArgs).then(function(nodeArgs) {
-          nodeArgs.push(makeNodeCallbackFor(resolve, reject));
-
-          try {
-            nodeFunc.apply(thisArg, nodeArgs);
-          } catch(e) {
-            reject(e);
-          }
-        });
-
-        return promise;
-      };
-    }
-
-
-    __exports__.denodeify = denodeify;
-  });
-define("rsvp/promise",
-  ["rsvp/config","rsvp/events","rsvp/cancellation_error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var config = __dependency1__.config;
-    var EventTarget = __dependency2__.EventTarget;
-    var CancellationError = __dependency3__.CancellationError;
-
-    function objectOrFunction(x) {
-      return isFunction(x) || (typeof x === "object" && x !== null);
-    }
-
-    function isFunction(x){
-      return typeof x === "function";
-    }
-
-    var Promise = function(resolver, canceller) {
-      var promise = this,
-      resolved = false;
-
-      if (typeof resolver !== 'function') {
-        throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
-      }
-
-      if ((canceller !== undefined) && (typeof canceller !== 'function')) {
-        throw new TypeError('You can only pass a canceller function' +
-          ' as the second argument to the promise constructor');
-      }
-
-      if (!(promise instanceof Promise)) {
-        return new Promise(resolver, canceller);
-      }
-
-      var resolvePromise = function(value) {
-        if (resolved) { return; }
-        resolved = true;
-        resolve(promise, value);
-      };
-
-      var rejectPromise = function(value) {
-        if (resolved) { return; }
-        resolved = true;
-        reject(promise, value);
-      };
-
-      var notifyPromise = function(value) {
-        if (resolved) { return; }
-        notify(promise, value);
-      };
-
-      this.on('promise:failed', function(event) {
-        this.trigger('error', { detail: event.detail });
-      }, this);
-
-      this.on('error', onerror);
-
-      this.cancel = function () {
-        // For now, simply reject the promise and does not propagate the cancel
-        // to parent or children
-        if (resolved) { return; }
-        if (canceller !== undefined) {
-          try {
-            canceller();
-          } catch (e) {
-            rejectPromise(e);
-            return;
-          }
-        }
-        // Trigger cancel?
-        rejectPromise(new CancellationError());
-      };
-
-      try {
-        resolver(resolvePromise, rejectPromise, notifyPromise);
-      } catch(e) {
-        rejectPromise(e);
-      }
-    };
-
-    function onerror(event) {
-      if (config.onerror) {
-        config.onerror(event.detail);
-      }
-    }
-
-    var invokeCallback = function(type, promise, callback, event) {
-      var hasCallback = isFunction(callback),
-          value, error, succeeded, failed;
-
-      if (promise.isFulfilled) { return; }
-      if (promise.isRejected) { return; }
-
-      if (hasCallback) {
-        try {
-          value = callback(event.detail);
-          succeeded = true;
-        } catch(e) {
-          failed = true;
-          error = e;
-        }
-      } else {
-        value = event.detail;
-        succeeded = true;
-      }
-
-      if (handleThenable(promise, value)) {
-        return;
-      } else if (hasCallback && succeeded) {
-        resolve(promise, value);
-      } else if (failed) {
-        reject(promise, error);
-      } else if (type === 'resolve') {
-        resolve(promise, value);
-      } else if (type === 'reject') {
-        reject(promise, value);
-      }
-    };
-
-
-    var invokeNotifyCallback = function(promise, callback, event) {
-      var value;
-      if (typeof callback === 'function') {
-        try {
-          value = callback(event.detail);
-        } catch (e) {
-          // stop propagating
-          return;
-        }
-        notify(promise, value);
-      } else {
-        notify(promise, event.detail);
-      }
-    };
-
-    Promise.prototype = {
-      constructor: Promise,
-
-      isRejected: undefined,
-      isFulfilled: undefined,
-      rejectedReason: undefined,
-      fulfillmentValue: undefined,
-
-      then: function(done, fail, progress) {
-        this.off('error', onerror);
-
-        var thenPromise = new this.constructor(function() {},
-            function () {
-              thenPromise.trigger('promise:cancelled', {});
-            });
-
-        if (this.isFulfilled) {
-          config.async(function(promise) {
-            invokeCallback('resolve', thenPromise, done, { detail: promise.fulfillmentValue });
-          }, this);
-        }
-
-        if (this.isRejected) {
-          config.async(function(promise) {
-            invokeCallback('reject', thenPromise, fail, { detail: promise.rejectedReason });
-          }, this);
-        }
-
-        this.on('promise:resolved', function(event) {
-          invokeCallback('resolve', thenPromise, done, event);
-        });
-
-        this.on('promise:failed', function(event) {
-          invokeCallback('reject', thenPromise, fail, event);
-        });
-
-        this.on('promise:notified', function (event) {
-          invokeNotifyCallback(thenPromise, progress, event);
-        });
-
-        return thenPromise;
-      },
-
-      fail: function(fail) {
-        return this.then(null, fail);
-      },
-
-      always: function(fail) {
-        return this.then(fail, fail);
-      }
-    };
-
-    EventTarget.mixin(Promise.prototype);
-
-    function resolve(promise, value) {
-      if (promise === value) {
-        fulfill(promise, value);
-      } else if (!handleThenable(promise, value)) {
-        fulfill(promise, value);
-      }
-    }
-
-    function handleThenable(promise, value) {
-      var then = null,
-      resolved;
-
-      try {
-        if (promise === value) {
-          throw new TypeError("A promises callback cannot return that same promise.");
-        }
-
-        if (objectOrFunction(value)) {
-          then = value.then;
-
-          if (isFunction(then)) {
-            if (isFunction(value.on)) {
-              value.on('promise:notified', function (event) {
-                notify(promise, event.detail);
-              });
-            }
-            promise.on('promise:cancelled', function(event) {
-              if (isFunction(value.cancel)) {
-                value.cancel();
-              }
-            });
-            then.call(value, function(val) {
-              if (resolved) { return true; }
-              resolved = true;
-
-              if (value !== val) {
-                resolve(promise, val);
-              } else {
-                fulfill(promise, val);
-              }
-            }, function(val) {
-              if (resolved) { return true; }
-              resolved = true;
-
-              reject(promise, val);
-            });
-
-            return true;
-          }
-        }
-      } catch (error) {
-        reject(promise, error);
-        return true;
-      }
-
-      return false;
-    }
-
-    function fulfill(promise, value) {
-      config.async(function() {
-        if (promise.isFulfilled) { return; }
-        if (promise.isRejected) { return; }
-        promise.trigger('promise:resolved', { detail: value });
-        promise.isFulfilled = true;
-        promise.fulfillmentValue = value;
-      });
-    }
-
-    function reject(promise, value) {
-      config.async(function() {
-        if (promise.isFulfilled) { return; }
-        if (promise.isRejected) { return; }
-        promise.trigger('promise:failed', { detail: value });
-        promise.isRejected = true;
-        promise.rejectedReason = value;
-      });
-    }
-
-    function notify(promise, value) {
-      config.async(function() {
-        promise.trigger('promise:notified', { detail: value });
-      });
-    }
-
-
-    __exports__.Promise = Promise;
-  });
-define("rsvp/queue",
-  ["rsvp/promise","rsvp/resolve","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    var resolve = __dependency2__.resolve;
-
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
-    function ResolvedQueueError(message) {
-      this.name = "resolved";
-      if ((message !== undefined) && (typeof message !== "string")) {
-        throw new TypeError('You must pass a string.');
-      }
-      this.message = message || "Default Message";
-    }
-    ResolvedQueueError.prototype = new Error();
-    ResolvedQueueError.prototype.constructor = ResolvedQueueError;
-
-    var Queue = function() {
-      var queue = this,
-        promise_list = [],
-        promise,
-        fulfill,
-        reject,
-        notify,
-        resolved;
-
-      if (!(this instanceof Queue)) {
-        return new Queue();
-      }
-
-      function canceller() {
-        for (var i = 0; i < 2; i++) {
-          promise_list[i].cancel();
-        }
-      }
-
-      promise = new Promise(function(done, fail, progress) {
-        fulfill = function (fulfillmentValue) {
-          if (resolved) {return;}
-          queue.isFulfilled = true;
-          queue.fulfillmentValue = fulfillmentValue;
-          resolved = true;
-          return done(fulfillmentValue);
-        };
-        reject = function (rejectedReason) {
-          if (resolved) {return;}
-          queue.isRejected = true;
-          queue.rejectedReason = rejectedReason ;
-          resolved = true;
-          return fail(rejectedReason);
-        };
-        notify = progress;
-      }, canceller);
-
-      promise_list.push(resolve());
-      promise_list.push(promise_list[0].then(function () {
-        promise_list.splice(0, 2);
-        if (promise_list.length === 0) {
-          fulfill();
-        }
-      }));
-
-      queue.cancel = function () {
-        if (resolved) {return;}
-        resolved = true;
-        promise.cancel();
-        promise.fail(function (rejectedReason) {
-          queue.isRejected = true;
-          queue.rejectedReason = rejectedReason;
-        });
-      };
-      queue.then = function () {
-        return promise.then.apply(promise, arguments);
-      };
-
-      queue.push = function(done, fail, progress) {
-        var last_promise = promise_list[promise_list.length - 1],
-          next_promise;
-
-        if (resolved) {
-          throw new ResolvedQueueError();
-        }
-
-        next_promise = last_promise.then(done, fail, progress);
-        promise_list.push(next_promise);
-
-        // Handle pop
-        last_promise = next_promise.then(function (fulfillmentValue) {
-          promise_list.splice(0, 2);
-          if (promise_list.length === 0) {
-            fulfill(fulfillmentValue);
-          } else {
-            return fulfillmentValue;
-          }
-        }, function (rejectedReason) {
-          promise_list.splice(0, 2);
-          if (promise_list.length === 0) {
-            reject(rejectedReason);
-          } else {
-            throw rejectedReason;
-          }
-        }, function (notificationValue) {
-          if (promise_list[promise_list.length - 1] === last_promise) {
-            notify(notificationValue);
-          }
-          return notificationValue;
-        });
-        promise_list.push(last_promise);
-
-        return this;
-      };
-    };
-
-    Queue.prototype = Object.create(Promise.prototype);
-    Queue.prototype.constructor = Queue;
-
-
-    __exports__.Queue = Queue;
-    __exports__.ResolvedQueueError = ResolvedQueueError;
-  });
-define("rsvp/reject",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function reject(reason) {
-      return new Promise(function (resolve, reject) {
-        reject(reason);
-      });
-    }
-
-
-    __exports__.reject = reject;
-  });
-define("rsvp/resolve",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function resolve(thenable) {
-      return new Promise(function(resolve, reject) {
-        if (typeof thenable === "object" && thenable !== null) {
-          var then = thenable.then;
-          if ((then !== undefined) && (typeof then === "function")) {
-            return then.apply(thenable, [resolve, reject]);
-          }
-        }
-        return resolve(thenable);
-      }, function () {
-        if ((thenable !== undefined) && (thenable.cancel !== undefined)) {
-          thenable.cancel();
-        }
-      });
-    }
-
-
-    __exports__.resolve = resolve;
-  });
-define("rsvp/rethrow",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var local = (typeof global === "undefined") ? this : global;
-
-    function rethrow(reason) {
-      local.setTimeout(function() {
-        throw reason;
-      });
-      throw reason;
-    }
-
-
-    __exports__.rethrow = rethrow;
-  });
-define("rsvp/timeout",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function promiseSetTimeout(millisecond, should_reject, message) {
-      var timeout_id;
-
-      function resolver(resolve, reject) {
-        timeout_id = setTimeout(function () {
-          if (should_reject) {
-            reject(message);
-          } else {
-            resolve(message);
-          }
-        }, millisecond);
-      }
-      function canceller() {
-        clearTimeout(timeout_id);
-      }
-      return new Promise(resolver, canceller);
-    }
-
-    function delay(millisecond, message) {
-      return promiseSetTimeout(millisecond, false, message);
-    }
-
-    function timeout(millisecond) {
-      return promiseSetTimeout(millisecond, true,
-                               "Timed out after " + millisecond + " ms");
-    }
-
-    Promise.prototype.delay = function(millisecond) {
-      return this.then(function (fulfillmentValue) {
-        return delay(millisecond, fulfillmentValue);
-      });
-    };
-
-
-    __exports__.delay = delay;
-    __exports__.timeout = timeout;
-  });
-define("rsvp",
-  ["rsvp/events","rsvp/cancellation_error","rsvp/promise","rsvp/node","rsvp/all","rsvp/queue","rsvp/timeout","rsvp/hash","rsvp/rethrow","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
-    "use strict";
-    var EventTarget = __dependency1__.EventTarget;
-    var CancellationError = __dependency2__.CancellationError;
-    var Promise = __dependency3__.Promise;
-    var denodeify = __dependency4__.denodeify;
-    var all = __dependency5__.all;
-    var any = __dependency5__.any;
-    var Queue = __dependency6__.Queue;
-    var ResolvedQueueError = __dependency6__.ResolvedQueueError;
-    var delay = __dependency7__.delay;
-    var timeout = __dependency7__.timeout;
-    var hash = __dependency8__.hash;
-    var rethrow = __dependency9__.rethrow;
-    var defer = __dependency10__.defer;
-    var config = __dependency11__.config;
-    var resolve = __dependency12__.resolve;
-    var reject = __dependency13__.reject;
-
-    function configure(name, value) {
-      config[name] = value;
-    }
-
-
-    __exports__.CancellationError = CancellationError;
-    __exports__.Promise = Promise;
-    __exports__.EventTarget = EventTarget;
-    __exports__.all = all;
-    __exports__.any = any;
-    __exports__.Queue = Queue;
-    __exports__.ResolvedQueueError = ResolvedQueueError;
-    __exports__.delay = delay;
-    __exports__.timeout = timeout;
-    __exports__.hash = hash;
-    __exports__.rethrow = rethrow;
-    __exports__.defer = defer;
-    __exports__.denodeify = denodeify;
-    __exports__.configure = configure;
-    __exports__.resolve = resolve;
-    __exports__.reject = reject;
-  });
-window.RSVP = requireModule("rsvp");
-})(window);
\ No newline at end of file
diff --git a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/rsvp.js.xml b/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/rsvp.js.xml
deleted file mode 100644
index a58a7c1d3b4b8962bd38bcf0dcd579d4c3286d69..0000000000000000000000000000000000000000
--- a/bt5/erp5_dms/SkinTemplateItem/portal_skins/erp5_dms/pdf_js/rsvp.js.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0"?>
-<ZopeData>
-  <record id="1" aka="AAAAAAAAAAE=">
-    <pickle>
-      <global name="File" module="OFS.Image"/>
-    </pickle>
-    <pickle>
-      <dictionary>
-        <item>
-            <key> <string>__name__</string> </key>
-            <value> <string>rsvp.js</string> </value>
-        </item>
-        <item>
-            <key> <string>content_type</string> </key>
-            <value> <string>application/javascript</string> </value>
-        </item>
-        <item>
-            <key> <string>precondition</string> </key>
-            <value> <string></string> </value>
-        </item>
-        <item>
-            <key> <string>title</string> </key>
-            <value> <string>rsvp.js</string> </value>
-        </item>
-      </dictionary>
-    </pickle>
-  </record>
-</ZopeData>