☰

soup.io: EmbedFix

Repairs embeds in your own and your friend soup. Fixes embeds everywhere if there is a link in the description

当前为 2017-10-23 提交的版本，查看 最新版本。

  1. // ==UserScript==
  2. // @name soup.io: EmbedFix
  3. // @namespace    http://xcvbnm.org/
  4. // @author Nordern
  5. // @description Repairs embeds in your own and your friend soup. Fixes embeds everywhere if there is a link in the description
  6. // @version 0.2
  7. // @match http://*.soup.io/*
  8. // @match https://*.soup.io/*
  9. // @exclude     http://www.soup.io/frames/*
  10. // @exclude     http://www.soup.io/remote/*
  11. // @license public domain, MediaEmbed has MIT Licence
  12. // @run-at document-end
  13. // ==/UserScript==
  14. // Available on github under: https://github.com/edave64/souplements/blob/master/youtube-fix/
  15. (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
  16.     /**
  17.      * This code snippet allows you to intercept the loading of new elements and modify the loaded posts.
  18.      * The basic idea is to allow filtering out posts before they are inserted into the dom, and thus before their assets
  19.      * are loaded. This reduces stress on both the client and the asset servers.
  20.      *
  21.      * To use the filter, register the event "processBatch" in SOUP.Endless.
  22.      * Example:
  23.      *
  24.      *     SOUP.Endless.on("processBatch", function (doc) {
  25.      *         // your code here
  26.      *     });
  27.      *
  28.      * The doc argument represents a temporary HTMLDocument node, storing the new loaded posts. You can work with it
  29.      * like you can work with ''document''.
  30.      *
  31.      * Be careful to never remove all posts, otherwise Soup will assume you reached the end.
  32.      *
  33.      * Please keep in mind that soup already has some filters build in: http://faq.soup.io/post/4328678
  34.      * These are probably easier on the servers.
  35.      *
  36.      * Licence: Public domain
  37.      *
  38.      * UPDATE 1.1:
  39.      * The soup event-api was used! I just used it wrong. It is supposed to be a template. The event is now fired on
  40.      * SOUP.Endless instead of SOUP.Events
  41.      *
  42.      * UPDATE 1.2:
  43.      * Also trigger for loaded in reactions
  44.      */
  45.     (function () {
  46.         // Add events to SOUP.Endless
  47.         if (!SOUP.Endless.trigger) {
  48.             SOUP.tools.extend(SOUP.Endless, SOUP.Events);
  49.         }
  50.     
  51.         if (Ajax.Request._EndlessFilter) return;
  52.     
  53.         var oldRequest = Ajax.Request;
  54.     
  55.         function getLoadAboveURL() {
  56.             var url = $("endless_top_post").href;
  57.             return url.match(/[&?]newer=1/) ? url : url + (url.indexOf("?") >= 0 ? "&" : "?") + "newer=1";
  58.         }
  59.     
  60.         function getLoadBelowURL() {
  61.             return SOUP.Endless.next_url.replace(/&?newer=1&?/g, "");
  62.         }
  63.     
  64.         function catchBatchLoad (path, options) {
  65.             var oldSuccess = options.onSuccess;
  66.             options.onSuccess = function (response) {
  67.                 var text = response.responseText,
  68.                     pipePosition = text.indexOf("|"),
  69.                     nextPath = text.substring(0, pipePosition),
  70.                     content = text.substring(pipePosition + 1),
  71.                     parser = new DOMParser(),
  72.                     xmlDoc = parser.parseFromString(content, "text/html"),
  73.                     root = xmlDoc.body;
  74.     
  75.                 root.setAttribute("id", "posts");
  76.                 SOUP.Endless.trigger("processBatch", xmlDoc);
  77.     
  78.                 response.responseText = nextPath + "|" + root.innerHTML;
  79.     
  80.                 return oldSuccess.apply(this, arguments);
  81.             };
  82.     
  83.             return oldRequest.apply(this, arguments);
  84.         }
  85.     
  86.         function catchPreviewLoad (path, options) {
  87.             var oldSuccess = options.onSuccess;
  88.             options.onSuccess = function (response) {
  89.                 var content = response.responseText,
  90.                     parser = new DOMParser(),
  91.                     xmlDoc = parser.parseFromString(content, "text/html"),
  92.                     root = xmlDoc.body;
  93.     
  94.                 root.setAttribute("id", "posts");
  95.                 SOUP.Endless.trigger("processBatch", xmlDoc);
  96.     
  97.                 response.responseText = root.innerHTML;
  98.     
  99.                 return oldSuccess.apply(this, arguments);
  100.             };
  101.     
  102.             return oldRequest.apply(this, arguments);
  103.         }
  104.     
  105.         Ajax.Request = function (path, options) {
  106.             var aboveURL = getLoadAboveURL();
  107.             var belowURL = getLoadBelowURL();
  108.     
  109.             if (path === aboveURL || path === belowURL) {
  110.                 return catchBatchLoad.apply(this, arguments);
  111.             }
  112.             if (path.startsWith("http://" + document.location.host + "/preview/")) {
  113.                 return catchPreviewLoad.apply(this, arguments);
  114.             }
  115.             return oldRequest.apply(this, arguments);
  116.         };
  117.         Ajax.Request._EndlessFilter = true;
  118.         Ajax.Request.Events = oldRequest.Events;
  119.         Ajax.Request.prototype = oldRequest.prototype;
  120.     }());
  121.     
  122.     },{}],2:[function(require,module,exports){
  123.     require("../endlessFilter");
  124.     const MediaEmbedder = require("media-embedder");
  125.     
  126.     if (!SOUP.EmbedFix) {
  127.         SOUP.EmbedFix = true;
  128.     
  129.         function fixAll (doc) {
  130.             var video_posts = [].slice.call(doc.getElementsByClassName("post_video"));
  131.             
  132.             const firstPost = document.querySelector(".post .content");
  133.             let width = 500;
  134.     
  135.             if (firstPost) {
  136.                 width = parseInt(window.getComputedStyle(firstPost).width);
  137.             }
  138.     
  139.             const height = (width / 16 * 9)|0;
  140.             
  141.             for (const video_post of video_posts) {
  142.                 const embed = video_post.getElementsByClassName("embed")[0];
  143.                 if (embed.children.length === 0) {
  144.                     const textarea = video_post.querySelector("[name='post[embedcode_or_url]']");
  145.                     // Turns out: Edge doesn't support innerText on DomParser elements. or something
  146.                     let mediaData = MediaEmbedder.detect(textarea.childNodes[0] ? textarea.childNodes[0].nodeValue : "");
  147.     
  148.                     if (!mediaData) {
  149.                         const description = video_post.getElementsByClassName("body")[0];
  150.                         if (description) {
  151.                             mediaData = MediaEmbedder.detect(description.innerHTML);
  152.                         }
  153.                     }
  154.     
  155.                     if (mediaData) {
  156.                         mediaData.width = width;
  157.                         mediaData.height = height;
  158.                         embed.innerHTML = MediaEmbedder.buildIframe(mediaData);
  159.                     }
  160.                 }
  161.             }
  162.         }
  163.     
  164.         SOUP.Endless.on("processBatch", function (doc) {
  165.             fixAll(doc);
  166.         });
  167.     
  168.         fixAll(document);
  169.     }
  170.     
  171.     },{"../endlessFilter":1,"media-embedder":4}],3:[function(require,module,exports){
  172.     module.exports = {
  173.         parse: function (text) {
  174.             const a = document.createElement("a");
  175.             a.href = text;
  176.             a.query = a.search.substring(1);
  177.             return a;
  178.         }
  179.     };
  180.     
  181.     },{}],4:[function(require,module,exports){
  182.     (function (global){
  183.     "use strict";
  184.     
  185.     /**
  186.      * @typedef MediaInfo
  187.      * @name MediaInfo
  188.      * @type {object}
  189.      * @property {string} platform - The name of the media platfrom.
  190.      * @property {string} mediaid - A string uniquely identifying on piece of media on the platform
  191.      * @property {number} [height] - The height of the embeded player
  192.      * @property {number} [width] - The width of the embeded player
  193.      * @property {boolean} [allowFullscreen] - True if the player can enter fullscreen
  194.      * @property {boolean} [loop] - True if the player will start over at the end
  195.      * @property {number} [timestamp] - The number of seconds at the begining that will be skiped
  196.      */
  197.     
  198.     /**
  199.      * @typedef MediaPlatform
  200.      * @name MediaPlatform
  201.      */
  202.     
  203.     /**
  204.      * Parses a text can either be a url to a video on a platform, or an html
  205.      * snipplet containing an embedding code for one of these platforms.
  206.      * 
  207.      * It attemps to extract as much information as possible from this text.
  208.      * 
  209.      * @method MediaPlatform~detect
  210.      * @param {string} test - A URL or an html snipplet containing an embed code
  211.      * @returns {MediaInfo|undefined} Information found in the string, undefined if none where found.
  212.      */
  213.     
  214.     /**
  215.      * Generates a iframe embed html snipplet from a descriptor
  216.      * 
  217.      * @method MediaPlatform~buildIframe
  218.      * @param {MediaInfo} descriptor
  219.      * @returns {string} An html snipplet
  220.      */
  221.     
  222.     /**
  223.      * Generates a link url from a descriptor
  224.      * 
  225.      * @method MediaPlatform~buildLink
  226.      * @param {MediaInfo} descriptor
  227.      * @returns {string} A url
  228.      */
  229.     
  230.     /** @type {Object.<string, MediaPlatform>} */
  231.     const platforms = {
  232.         youtube: require("./platforms/youtube"),
  233.         dailymotion: require("./platforms/dailymotion"),
  234.         vimeo: require("./platforms/vimeo")
  235.     };
  236.     
  237.     /** @type {MediaPlatform} */
  238.     global.test = module.exports = {
  239.         detect: function(text) {
  240.             for (const platform in platforms) {
  241.                 const ret = platforms[platform].detect(text);
  242.                 if (ret) {
  243.                     ret.platform = platform;
  244.                     return ret;
  245.                 }
  246.             }
  247.         },
  248.         buildIframe: function (descriptor) {
  249.             const platform = platforms[descriptor.platform];
  250.             return platform.buildIframe(descriptor);
  251.         },
  252.         buildLink: function (descriptor) {
  253.             const platform = platforms[descriptor.platform];
  254.             return platform.buildLink(descriptor);
  255.         }
  256.     };
  257.     
  258.     }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  259.     },{"./platforms/dailymotion":6,"./platforms/vimeo":7,"./platforms/youtube":8}],5:[function(require,module,exports){
  260.     "use strict";
  261.     
  262.     const querystring = require("querystring");
  263.     const UrlHelper = require("./utils/url_helper");
  264.     const DocHelper = require("./utils/doc_helper");
  265.     
  266.     /**
  267.      * @callback processor
  268.      * @param {UrlObject} url
  269.      * @param {Object} queryObject
  270.      * @return {MediaInfo}
  271.      */
  272.     
  273.     /**
  274.      * @callback generator
  275.      * @param {MediaInfo} mediaInfo
  276.      * @param {boolean} embedded
  277.      * @param {string[]} queryParts
  278.      * @returns {string} Url
  279.      */
  280.     
  281.     /**
  282.      * @param {processor} urlProcessor
  283.      * @param {generator} urlGenerator
  284.      * @returns {MediaPlatform}
  285.      */
  286.     module.exports = function (urlProcessor, urlGenerator) {
  287.         function wrappedProcessor (text) {
  288.             try {
  289.                 const urlData = UrlHelper.parse(text);
  290.                 const qs = querystring.parse(urlData.query);
  291.     
  292.                 return urlProcessor(urlData, qs);
  293.             } catch (e) {
  294.                 console.error(e);
  295.             }
  296.         }
  297.     
  298.         function wrappedGenerator (data, embed) {
  299.             const queryData = [];
  300.             queryData.when = function (condition, val) { if (condition) this.push(val); };
  301.             let url = urlGenerator(data, embed, queryData);
  302.             
  303.             if (queryData.length > 0) {
  304.                 url += "?" + queryData.join("&");
  305.             }
  306.             return url;
  307.         }
  308.         
  309.         return {
  310.             detect: (text) => {
  311.                 // is entire text a url?
  312.                 let entire = wrappedProcessor(text),
  313.                     ret;
  314.                 if (entire) {
  315.                     return entire;
  316.                 }
  317.                 
  318.                 for (const tag of DocHelper.get_nodes(text, "iframe", "embed", "a")) {
  319.                     switch (tag.nodeName.toLowerCase()) {
  320.                         case "iframe":
  321.                         case "embed":
  322.                             ret = DocHelper.processIframe(tag, wrappedProcessor);
  323.                             if (ret) {
  324.                                 return ret;
  325.                             }
  326.                             break;
  327.                         case "a":
  328.                             ret = wrappedProcessor(tag.getAttribute("href"));
  329.                             if (ret) {
  330.                                 return ret;
  331.                             }
  332.                             break;
  333.                     }
  334.                 }
  335.             },
  336.             buildIframe: (data) => {
  337.                 return DocHelper.buildIframe(wrappedGenerator(data, true), data.height, data.width, data.allowFullscreen);
  338.             },
  339.             buildLink: (data) => {
  340.                 return wrappedGenerator(data, false);
  341.             }
  342.         };
  343.     };
  344.     
  345.     },{"./utils/doc_helper":9,"./utils/url_helper":10,"querystring":13}],6:[function(require,module,exports){
  346.     "use strict";
  347.     const urlParse = /^\/(embed\/video|video|swf)\/([0-9a-zA-Z]*)/
  348.     
  349.     module.exports = require("../platform_base")(
  350.         function (urlData, qs) {
  351.             if (urlData.normalizedHost === "dailymotion.com") {
  352.                 const urlMatch = urlData.pathname.match(urlParse);
  353.                 if (urlMatch) {
  354.                     return {
  355.                         mediaid: urlMatch[2],
  356.                         height: null,
  357.                         width: null,
  358.                         allowFullscreen: null,
  359.                         loop: null,
  360.                         timestamp: qs.start || null,
  361.                         autoplay: qs.autoplay === "1" || qs.autoPlay === "1"
  362.                     }
  363.                 }
  364.             }
  365.         },
  366.         function (data, embed, query) {
  367.             let url = embed ? "https://www.dailymotion.com/embed/video/" : "https://www.dailymotion.com/video/";
  368.             url += data.mediaid.replace(/[^0-9a-zA-Z]/g, ""); // sanitize mediaid
  369.         
  370.             query.when(data.allowFullscreen === false, "fullscreen=1");
  371.             query.when(data.autoplay                 , "autoplay=1");
  372.             query.when(data.timestamp                , "start=" + parseInt(data.timestamp));
  373.             
  374.             return url;
  375.         }
  376.     );
  377.     
  378.     },{"../platform_base":5}],7:[function(require,module,exports){
  379.     "use strict";
  380.     const urlParse = /^\/(video\/)?([0-9]*)$/;
  381.     
  382.     /**
  383.      * @param {string} videoId 
  384.      * @param {object} param
  385.      * @returns {MediaInfo}
  386.      */
  387.     function generate (videoId, param) {
  388.         return {
  389.             mediaid: videoId,
  390.             height: null, width: null, timestamp: null,
  391.             allowFullscreen: null,
  392.             loop: param.loop === "1",
  393.             autoplay: param.autoplay === "1"
  394.         }
  395.     }
  396.     
  397.     module.exports = require("../platform_base")(
  398.         function (urlData, qs) {
  399.             if (urlData.normalizedHost === "vimeo.com" || urlData.normalizedHost === "player.vimeo.com") {
  400.                 if (urlData.pathname === "/moogaloop.swf") {
  401.                     return generate(qs.clip_id, qs);
  402.                 }
  403.                 const urlMatch = urlData.pathname.match(urlParse);
  404.                 if (urlMatch) {
  405.                     return generate(urlMatch[2], qs);
  406.                 }
  407.             }
  408.         },
  409.         function (data, embed, query) {
  410.             let url = embed ? "https://player.vimeo.com/video/" : "https://vimeo.com/";
  411.             url += data.mediaid.replace(/[^0-9]/g, ""); // sanitize mediaid
  412.         
  413.             query.when(data.loop,     "loop=1");
  414.             query.when(data.autoplay, "autoplay=1");
  415.     
  416.             return url;
  417.         }
  418.     );
  419.     
  420.     },{"../platform_base":5}],8:[function(require,module,exports){
  421.     "use strict";
  422.     const querystring = require("querystring");
  423.     const embedUrlParse = /^\/(embed|v)\/([0-9a-zA-Z\-_]*)(.*)/;
  424.     
  425.     /**
  426.      * @param {string} videoId
  427.      * @param {object} param
  428.      * @returns {MediaInfo}
  429.      */
  430.     function generate (videoId, param) {
  431.         return {
  432.             mediaid: videoId,
  433.             height: null, width: null,
  434.             allowFullscreen: param.fs !== "0",
  435.             timestamp: param.t || param.time || param.start || null,
  436.             loop: param.loop === "1",
  437.             autoplay: param.autoplay === "1"
  438.         }
  439.     }
  440.     
  441.     module.exports = require("../platform_base")(
  442.         function (urlData, qs) {
  443.             if (urlData.normalizedHost === "youtube.com") {
  444.                 if (qs.v) {
  445.                     return generate(qs.v, qs);
  446.                 }
  447.                 const embedUrlMatch = urlData.pathname.match(embedUrlParse);
  448.                 if (embedUrlMatch) {
  449.                     // youtube /v/ urls can be kind of odd and and append the query with & to the path
  450.                     const vUrlQs = querystring.parse(embedUrlMatch[3]);
  451.                     return generate(embedUrlMatch[2], Object.assign({}, qs, vUrlQs));
  452.                 }
  453.             } else if (urlData.normalizedHost === "youtu.be") {
  454.                 const qs = querystring.parse(urlData.query);
  455.                 return generate(urlData.pathname.slice(1), qs);
  456.             }
  457.         },
  458.         function (data, embed, query) {
  459.             let url = embed ? "https://www.youtube.com/embed/" : "https://www.youtube.com/watch";
  460.             const mediaid = data.mediaid.replace(/[^0-9a-zA-Z\-_]/g, ""); // sanitize mediaid
  461.         
  462.             query.when(data.allowFullscreen === false, "fs=1");
  463.             query.when(data.loop,                      "loop=1");
  464.             query.when(data.autoplay,                  "autoplay=1");
  465.             if (data.timestamp) {
  466.                 query.push("start=" + data.timestamp.replace(/[^0-9hms]/g, ""));
  467.             }
  468.     
  469.             if (embed) {
  470.                 url += mediaid;
  471.             } else {
  472.                 query.push("v=" + mediaid)
  473.             }
  474.     
  475.             return url;
  476.         }
  477.     );
  478.     
  479.     },{"../platform_base":5,"querystring":13}],9:[function(require,module,exports){
  480.     const DOMParser = (window.window).DOMParser;
  481.     
  482.     module.exports = {
  483.         get_nodes: function (text, ...node_types) {
  484.             let parser = (new DOMParser ()).parseFromString("<html><body>" + text + "</body></html>", "text/html");
  485.             var tags = [];
  486.             for (const node_type of node_types) {
  487.                 tags.push.apply(tags, parser.getElementsByTagName(node_type));
  488.             }
  489.             return tags;
  490.         },
  491.     
  492.         processIframe: function (iframe, urlProcessor) {
  493.             const ret = urlProcessor(iframe.getAttribute("src"));
  494.             if (ret) {
  495.                 ret.allowFullscreen = iframe.getAttribute("allowfullscreen") != null;
  496.                 ret.height = iframe.getAttribute("height");
  497.                 ret.width = iframe.getAttribute("width");
  498.                 return ret;
  499.             }
  500.         },
  501.     
  502.         buildIframe: function (src, height, width, allowFullscreen) {
  503.             let ret = "<iframe "
  504.             if (height != null) {
  505.                 ret += 'height="' + parseInt(height) + '" '
  506.             }
  507.             if (width != null) {
  508.                 ret += 'width="' + parseInt(width) + '" '
  509.             }
  510.             if (allowFullscreen === true) {
  511.                 ret += 'allowfullscreen webkitallowfullscreen mozallowfullscreen '
  512.             }
  513.             ret += 'frameborder="0" src="' + src + '"></iframe>'
  514.             return ret;
  515.         }
  516.     };
  517.     
  518.     },{}],10:[function(require,module,exports){
  519.     const url = require("url");
  520.     const querystring = require("querystring");
  521.     
  522.     module.exports = {
  523.         parse: function (text) {
  524.             let fullUrl = url.parse(text);
  525.         
  526.             if (fullUrl.protocol === null) {
  527.                 fullUrl = url.parse("test:" + (text.startsWith("//") ? "" : "//") + text);
  528.             }
  529.     
  530.             if (fullUrl.host) {
  531.                 fullUrl.normalizedHost = fullUrl.host.startsWith("www.") ? fullUrl.host.substring(4) : fullUrl.host;
  532.             }
  533.     
  534.             return fullUrl;
  535.         }
  536.     };
  537.     
  538.     },{"querystring":13,"url":3}],11:[function(require,module,exports){
  539.     // Copyright Joyent, Inc. and other Node contributors.
  540.     //
  541.     // Permission is hereby granted, free of charge, to any person obtaining a
  542.     // copy of this software and associated documentation files (the
  543.     // "Software"), to deal in the Software without restriction, including
  544.     // without limitation the rights to use, copy, modify, merge, publish,
  545.     // distribute, sublicense, and/or sell copies of the Software, and to permit
  546.     // persons to whom the Software is furnished to do so, subject to the
  547.     // following conditions:
  548.     //
  549.     // The above copyright notice and this permission notice shall be included
  550.     // in all copies or substantial portions of the Software.
  551.     //
  552.     // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  553.     // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  554.     // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  555.     // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  556.     // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  557.     // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  558.     // USE OR OTHER DEALINGS IN THE SOFTWARE.
  559.     
  560.     'use strict';
  561.     
  562.     // If obj.hasOwnProperty has been overridden, then calling
  563.     // obj.hasOwnProperty(prop) will break.
  564.     // See: https://github.com/joyent/node/issues/1707
  565.     function hasOwnProperty(obj, prop) {
  566.       return Object.prototype.hasOwnProperty.call(obj, prop);
  567.     }
  568.     
  569.     module.exports = function(qs, sep, eq, options) {
  570.       sep = sep || '&';
  571.       eq = eq || '=';
  572.       var obj = {};
  573.     
  574.       if (typeof qs !== 'string' || qs.length === 0) {
  575.         return obj;
  576.       }
  577.     
  578.       var regexp = /\+/g;
  579.       qs = qs.split(sep);
  580.     
  581.       var maxKeys = 1000;
  582.       if (options && typeof options.maxKeys === 'number') {
  583.         maxKeys = options.maxKeys;
  584.       }
  585.     
  586.       var len = qs.length;
  587.       // maxKeys <= 0 means that we should not limit keys count
  588.       if (maxKeys > 0 && len > maxKeys) {
  589.         len = maxKeys;
  590.       }
  591.     
  592.       for (var i = 0; i < len; ++i) {
  593.         var x = qs[i].replace(regexp, '%20'),
  594.             idx = x.indexOf(eq),
  595.             kstr, vstr, k, v;
  596.     
  597.         if (idx >= 0) {
  598.           kstr = x.substr(0, idx);
  599.           vstr = x.substr(idx + 1);
  600.         } else {
  601.           kstr = x;
  602.           vstr = '';
  603.         }
  604.     
  605.         k = decodeURIComponent(kstr);
  606.         v = decodeURIComponent(vstr);
  607.     
  608.         if (!hasOwnProperty(obj, k)) {
  609.           obj[k] = v;
  610.         } else if (isArray(obj[k])) {
  611.           obj[k].push(v);
  612.         } else {
  613.           obj[k] = [obj[k], v];
  614.         }
  615.       }
  616.     
  617.       return obj;
  618.     };
  619.     
  620.     var isArray = Array.isArray || function (xs) {
  621.       return Object.prototype.toString.call(xs) === '[object Array]';
  622.     };
  623.     
  624.     },{}],12:[function(require,module,exports){
  625.     // Copyright Joyent, Inc. and other Node contributors.
  626.     //
  627.     // Permission is hereby granted, free of charge, to any person obtaining a
  628.     // copy of this software and associated documentation files (the
  629.     // "Software"), to deal in the Software without restriction, including
  630.     // without limitation the rights to use, copy, modify, merge, publish,
  631.     // distribute, sublicense, and/or sell copies of the Software, and to permit
  632.     // persons to whom the Software is furnished to do so, subject to the
  633.     // following conditions:
  634.     //
  635.     // The above copyright notice and this permission notice shall be included
  636.     // in all copies or substantial portions of the Software.
  637.     //
  638.     // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  639.     // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  640.     // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  641.     // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  642.     // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  643.     // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  644.     // USE OR OTHER DEALINGS IN THE SOFTWARE.
  645.     
  646.     'use strict';
  647.     
  648.     var stringifyPrimitive = function(v) {
  649.       switch (typeof v) {
  650.         case 'string':
  651.           return v;
  652.     
  653.         case 'boolean':
  654.           return v ? 'true' : 'false';
  655.     
  656.         case 'number':
  657.           return isFinite(v) ? v : '';
  658.     
  659.         default:
  660.           return '';
  661.       }
  662.     };
  663.     
  664.     module.exports = function(obj, sep, eq, name) {
  665.       sep = sep || '&';
  666.       eq = eq || '=';
  667.       if (obj === null) {
  668.         obj = undefined;
  669.       }
  670.     
  671.       if (typeof obj === 'object') {
  672.         return map(objectKeys(obj), function(k) {
  673.           var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
  674.           if (isArray(obj[k])) {
  675.             return map(obj[k], function(v) {
  676.               return ks + encodeURIComponent(stringifyPrimitive(v));
  677.             }).join(sep);
  678.           } else {
  679.             return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
  680.           }
  681.         }).join(sep);
  682.     
  683.       }
  684.     
  685.       if (!name) return '';
  686.       return encodeURIComponent(stringifyPrimitive(name)) + eq +
  687.              encodeURIComponent(stringifyPrimitive(obj));
  688.     };
  689.     
  690.     var isArray = Array.isArray || function (xs) {
  691.       return Object.prototype.toString.call(xs) === '[object Array]';
  692.     };
  693.     
  694.     function map (xs, f) {
  695.       if (xs.map) return xs.map(f);
  696.       var res = [];
  697.       for (var i = 0; i < xs.length; i++) {
  698.         res.push(f(xs[i], i));
  699.       }
  700.       return res;
  701.     }
  702.     
  703.     var objectKeys = Object.keys || function (obj) {
  704.       var res = [];
  705.       for (var key in obj) {
  706.         if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
  707.       }
  708.       return res;
  709.     };
  710.     
  711.     },{}],13:[function(require,module,exports){
  712.     'use strict';
  713.     
  714.     exports.decode = exports.parse = require('./decode');
  715.     exports.encode = exports.stringify = require('./encode');
  716.     
  717.     },{"./decode":11,"./encode":12}]},{},[2]);