☰

soup.io: EmbedFix

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

  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.1
  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.                 let mediaData;
  145.  
  146.                 const textarea = video_post.querySelector("[name='post[embedcode_or_url]']");
  147.                 if (textarea) {
  148.                     mediaData = MediaEmbedder.detect(textarea.childNodes[0] ? textarea.childNodes[0].nodeValue : "");
  149.                 }
  150.  
  151.                 if (!mediaData) {
  152.                     const description = video_post.getElementsByClassName("body")[0];
  153.                     if (description) {
  154.                         mediaData = MediaEmbedder.detect(description.innerHTML);
  155.                     }
  156.                 }
  157.  
  158.                 if (mediaData) {
  159.                     mediaData.width = width;
  160.                     mediaData.height = height;
  161.                     embed.innerHTML = MediaEmbedder.buildIframe(mediaData);
  162.                 }
  163.             }
  164.         }
  165.     }
  166.  
  167.     SOUP.Endless.on("processBatch", function (doc) {
  168.         fixAll(doc);
  169.     });
  170.  
  171.     fixAll(document);
  172. }
  173.  
  174. },{"../endlessFilter":1,"media-embedder":4}],3:[function(require,module,exports){
  175. module.exports = {
  176.     parse: function (text) {
  177.         const a = document.createElement("a");
  178.         a.href = text;
  179.         a.query = a.search.substring(1);
  180.         return a;
  181.     }
  182. };
  183.  
  184. },{}],4:[function(require,module,exports){
  185. (function (global){
  186. "use strict";
  187.  
  188. /**
  189.  * @typedef MediaInfo
  190.  * @name MediaInfo
  191.  * @type {object}
  192.  * @property {string} platform - The name of the media platfrom.
  193.  * @property {string} mediaid - A string uniquely identifying on piece of media on the platform
  194.  * @property {number} [height] - The height of the embeded player
  195.  * @property {number} [width] - The width of the embeded player
  196.  * @property {boolean} [allowFullscreen] - True if the player can enter fullscreen
  197.  * @property {boolean} [loop] - True if the player will start over at the end
  198.  * @property {number} [timestamp] - The number of seconds at the begining that will be skiped
  199.  */
  200.  
  201. /**
  202.  * @typedef MediaPlatform
  203.  * @name MediaPlatform
  204.  */
  205.  
  206. /**
  207.  * Parses a text can either be a url to a video on a platform, or an html
  208.  * snipplet containing an embedding code for one of these platforms.
  209.  * 
  210.  * It attemps to extract as much information as possible from this text.
  211.  * 
  212.  * @method MediaPlatform~detect
  213.  * @param {string} test - A URL or an html snipplet containing an embed code
  214.  * @returns {MediaInfo|undefined} Information found in the string, undefined if none where found.
  215.  */
  216.  
  217. /**
  218.  * Generates a iframe embed html snipplet from a descriptor
  219.  * 
  220.  * @method MediaPlatform~buildIframe
  221.  * @param {MediaInfo} descriptor
  222.  * @returns {string} An html snipplet
  223.  */
  224.  
  225. /**
  226.  * Generates a link url from a descriptor
  227.  * 
  228.  * @method MediaPlatform~buildLink
  229.  * @param {MediaInfo} descriptor
  230.  * @returns {string} A url
  231.  */
  232.  
  233. /** @type {Object.<string, MediaPlatform>} */
  234. const platforms = {
  235.     youtube: require("./platforms/youtube"),
  236.     dailymotion: require("./platforms/dailymotion"),
  237.     vimeo: require("./platforms/vimeo")
  238. };
  239.  
  240. /** @type {MediaPlatform} */
  241. global.test = module.exports = {
  242.     detect: function(text) {
  243.         for (const platform in platforms) {
  244.             const ret = platforms[platform].detect(text);
  245.             if (ret) {
  246.                 ret.platform = platform;
  247.                 return ret;
  248.             }
  249.         }
  250.     },
  251.     buildIframe: function (descriptor) {
  252.         const platform = platforms[descriptor.platform];
  253.         return platform.buildIframe(descriptor);
  254.     },
  255.     buildLink: function (descriptor) {
  256.         const platform = platforms[descriptor.platform];
  257.         return platform.buildLink(descriptor);
  258.     }
  259. };
  260.  
  261. }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  262. },{"./platforms/dailymotion":6,"./platforms/vimeo":7,"./platforms/youtube":8}],5:[function(require,module,exports){
  263. "use strict";
  264.  
  265. const querystring = require("querystring");
  266. const UrlHelper = require("./utils/url_helper");
  267. const DocHelper = require("./utils/doc_helper");
  268.  
  269. /**
  270.  * @callback processor
  271.  * @param {UrlObject} url
  272.  * @param {Object} queryObject
  273.  * @return {MediaInfo}
  274.  */
  275.  
  276. /**
  277.  * @callback generator
  278.  * @param {MediaInfo} mediaInfo
  279.  * @param {boolean} embedded
  280.  * @param {string[]} queryParts
  281.  * @returns {string} Url
  282.  */
  283.  
  284. /**
  285.  * @param {processor} urlProcessor
  286.  * @param {generator} urlGenerator
  287.  * @returns {MediaPlatform}
  288.  */
  289. module.exports = function (urlProcessor, urlGenerator) {
  290.     function wrappedProcessor (text) {
  291.         try {
  292.             const urlData = UrlHelper.parse(text);
  293.             const qs = querystring.parse(urlData.query);
  294.  
  295.             return urlProcessor(urlData, qs);
  296.         } catch (e) {
  297.             console.error(e);
  298.         }
  299.     }
  300.  
  301.     function wrappedGenerator (data, embed) {
  302.         const queryData = [];
  303.         queryData.when = function (condition, val) { if (condition) this.push(val); };
  304.         let url = urlGenerator(data, embed, queryData);
  305.         
  306.         if (queryData.length > 0) {
  307.             url += "?" + queryData.join("&");
  308.         }
  309.         return url;
  310.     }
  311.     
  312.     return {
  313.         detect: (text) => {
  314.             // is entire text a url?
  315.             let entire = wrappedProcessor(text),
  316.                 ret;
  317.             if (entire) {
  318.                 return entire;
  319.             }
  320.             
  321.             for (const tag of DocHelper.get_nodes(text, "iframe", "embed", "a")) {
  322.                 switch (tag.nodeName.toLowerCase()) {
  323.                     case "iframe":
  324.                     case "embed":
  325.                         ret = DocHelper.processIframe(tag, wrappedProcessor);
  326.                         if (ret) {
  327.                             return ret;
  328.                         }
  329.                         break;
  330.                     case "a":
  331.                         ret = wrappedProcessor(tag.getAttribute("href"));
  332.                         if (ret) {
  333.                             return ret;
  334.                         }
  335.                         break;
  336.                 }
  337.             }
  338.         },
  339.         buildIframe: (data) => {
  340.             return DocHelper.buildIframe(wrappedGenerator(data, true), data.height, data.width, data.allowFullscreen);
  341.         },
  342.         buildLink: (data) => {
  343.             return wrappedGenerator(data, false);
  344.         }
  345.     };
  346. };
  347.  
  348. },{"./utils/doc_helper":9,"./utils/url_helper":10,"querystring":13}],6:[function(require,module,exports){
  349. "use strict";
  350. const urlParse = /^\/(embed\/video|video|swf)\/([0-9a-zA-Z]*)/
  351.  
  352. module.exports = require("../platform_base")(
  353.     function (urlData, qs) {
  354.         if (urlData.normalizedHost === "dailymotion.com") {
  355.             const urlMatch = urlData.pathname.match(urlParse);
  356.             if (urlMatch) {
  357.                 return {
  358.                     mediaid: urlMatch[2],
  359.                     height: null,
  360.                     width: null,
  361.                     allowFullscreen: null,
  362.                     loop: null,
  363.                     timestamp: qs.start || null,
  364.                     autoplay: qs.autoplay === "1" || qs.autoPlay === "1"
  365.                 }
  366.             }
  367.         }
  368.     },
  369.     function (data, embed, query) {
  370.         let url = embed ? "https://www.dailymotion.com/embed/video/" : "https://www.dailymotion.com/video/";
  371.         url += data.mediaid.replace(/[^0-9a-zA-Z]/g, ""); // sanitize mediaid
  372.     
  373.         query.when(data.allowFullscreen === false, "fullscreen=1");
  374.         query.when(data.autoplay                 , "autoplay=1");
  375.         query.when(data.timestamp                , "start=" + parseInt(data.timestamp));
  376.         
  377.         return url;
  378.     }
  379. );
  380.  
  381. },{"../platform_base":5}],7:[function(require,module,exports){
  382. "use strict";
  383. const urlParse = /^\/(video\/)?([0-9]*)$/;
  384.  
  385. /**
  386.  * @param {string} videoId 
  387.  * @param {object} param
  388.  * @returns {MediaInfo}
  389.  */
  390. function generate (videoId, param) {
  391.     return {
  392.         mediaid: videoId,
  393.         height: null, width: null, timestamp: null,
  394.         allowFullscreen: null,
  395.         loop: param.loop === "1",
  396.         autoplay: param.autoplay === "1"
  397.     }
  398. }
  399.  
  400. module.exports = require("../platform_base")(
  401.     function (urlData, qs) {
  402.         if (urlData.normalizedHost === "vimeo.com" || urlData.normalizedHost === "player.vimeo.com") {
  403.             if (urlData.pathname === "/moogaloop.swf") {
  404.                 return generate(qs.clip_id, qs);
  405.             }
  406.             const urlMatch = urlData.pathname.match(urlParse);
  407.             if (urlMatch) {
  408.                 return generate(urlMatch[2], qs);
  409.             }
  410.         }
  411.     },
  412.     function (data, embed, query) {
  413.         let url = embed ? "https://player.vimeo.com/video/" : "https://vimeo.com/";
  414.         url += data.mediaid.replace(/[^0-9]/g, ""); // sanitize mediaid
  415.     
  416.         query.when(data.loop,     "loop=1");
  417.         query.when(data.autoplay, "autoplay=1");
  418.  
  419.         return url;
  420.     }
  421. );
  422.  
  423. },{"../platform_base":5}],8:[function(require,module,exports){
  424. "use strict";
  425. const querystring = require("querystring");
  426. const embedUrlParse = /^\/(embed|v)\/([0-9a-zA-Z\-_]*)(.*)/;
  427.  
  428. /**
  429.  * @param {string} videoId
  430.  * @param {object} param
  431.  * @returns {MediaInfo}
  432.  */
  433. function generate (videoId, param) {
  434.     return {
  435.         mediaid: videoId,
  436.         height: null, width: null,
  437.         allowFullscreen: param.fs !== "0",
  438.         timestamp: param.t || param.time || param.start || null,
  439.         loop: param.loop === "1",
  440.         autoplay: param.autoplay === "1"
  441.     }
  442. }
  443.  
  444. module.exports = require("../platform_base")(
  445.     function (urlData, qs) {
  446.         if (urlData.normalizedHost === "youtube.com") {
  447.             if (qs.v) {
  448.                 return generate(qs.v, qs);
  449.             }
  450.             const embedUrlMatch = urlData.pathname.match(embedUrlParse);
  451.             if (embedUrlMatch) {
  452.                 // youtube /v/ urls can be kind of odd and and append the query with & to the path
  453.                 const vUrlQs = querystring.parse(embedUrlMatch[3]);
  454.                 return generate(embedUrlMatch[2], Object.assign({}, qs, vUrlQs));
  455.             }
  456.         } else if (urlData.normalizedHost === "youtu.be") {
  457.             const qs = querystring.parse(urlData.query);
  458.             return generate(urlData.pathname.slice(1), qs);
  459.         }
  460.     },
  461.     function (data, embed, query) {
  462.         let url = embed ? "https://www.youtube.com/embed/" : "https://www.youtube.com/watch";
  463.         const mediaid = data.mediaid.replace(/[^0-9a-zA-Z\-_]/g, ""); // sanitize mediaid
  464.     
  465.         query.when(data.allowFullscreen === false, "fs=1");
  466.         query.when(data.loop,                      "loop=1");
  467.         query.when(data.autoplay,                  "autoplay=1");
  468.         if (data.timestamp) {
  469.             query.push("start=" + data.timestamp.replace(/[^0-9hms]/g, ""));
  470.         }
  471.  
  472.         if (embed) {
  473.             url += mediaid;
  474.         } else {
  475.             query.push("v=" + mediaid)
  476.         }
  477.  
  478.         return url;
  479.     }
  480. );
  481.  
  482. },{"../platform_base":5,"querystring":13}],9:[function(require,module,exports){
  483. const DOMParser = (window.window).DOMParser;
  484.  
  485. module.exports = {
  486.     get_nodes: function (text, ...node_types) {
  487.         let parser = (new DOMParser ()).parseFromString("<html><body>" + text + "</body></html>", "text/html");
  488.         var tags = [];
  489.         for (const node_type of node_types) {
  490.             tags.push.apply(tags, parser.getElementsByTagName(node_type));
  491.         }
  492.         return tags;
  493.     },
  494.  
  495.     processIframe: function (iframe, urlProcessor) {
  496.         const ret = urlProcessor(iframe.getAttribute("src"));
  497.         if (ret) {
  498.             ret.allowFullscreen = iframe.getAttribute("allowfullscreen") != null;
  499.             ret.height = iframe.getAttribute("height");
  500.             ret.width = iframe.getAttribute("width");
  501.             return ret;
  502.         }
  503.     },
  504.  
  505.     buildIframe: function (src, height, width, allowFullscreen) {
  506.         let ret = "<iframe "
  507.         if (height != null) {
  508.             ret += 'height="' + parseInt(height) + '" '
  509.         }
  510.         if (width != null) {
  511.             ret += 'width="' + parseInt(width) + '" '
  512.         }
  513.         if (allowFullscreen === true) {
  514.             ret += 'allowfullscreen webkitallowfullscreen mozallowfullscreen '
  515.         }
  516.         ret += 'frameborder="0" src="' + src + '"></iframe>'
  517.         return ret;
  518.     }
  519. };
  520.  
  521. },{}],10:[function(require,module,exports){
  522. const url = require("url");
  523. const querystring = require("querystring");
  524.  
  525. module.exports = {
  526.     parse: function (text) {
  527.         let fullUrl = url.parse(text);
  528.     
  529.         if (fullUrl.protocol === null) {
  530.             fullUrl = url.parse("test:" + (text.startsWith("//") ? "" : "//") + text);
  531.         }
  532.  
  533.         if (fullUrl.host) {
  534.             fullUrl.normalizedHost = fullUrl.host.startsWith("www.") ? fullUrl.host.substring(4) : fullUrl.host;
  535.         }
  536.  
  537.         return fullUrl;
  538.     }
  539. };
  540.  
  541. },{"querystring":13,"url":3}],11:[function(require,module,exports){
  542. // Copyright Joyent, Inc. and other Node contributors.
  543. //
  544. // Permission is hereby granted, free of charge, to any person obtaining a
  545. // copy of this software and associated documentation files (the
  546. // "Software"), to deal in the Software without restriction, including
  547. // without limitation the rights to use, copy, modify, merge, publish,
  548. // distribute, sublicense, and/or sell copies of the Software, and to permit
  549. // persons to whom the Software is furnished to do so, subject to the
  550. // following conditions:
  551. //
  552. // The above copyright notice and this permission notice shall be included
  553. // in all copies or substantial portions of the Software.
  554. //
  555. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  556. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  557. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  558. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  559. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  560. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  561. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  562.  
  563. 'use strict';
  564.  
  565. // If obj.hasOwnProperty has been overridden, then calling
  566. // obj.hasOwnProperty(prop) will break.
  567. // See: https://github.com/joyent/node/issues/1707
  568. function hasOwnProperty(obj, prop) {
  569.   return Object.prototype.hasOwnProperty.call(obj, prop);
  570. }
  571.  
  572. module.exports = function(qs, sep, eq, options) {
  573.   sep = sep || '&';
  574.   eq = eq || '=';
  575.   var obj = {};
  576.  
  577.   if (typeof qs !== 'string' || qs.length === 0) {
  578.     return obj;
  579.   }
  580.  
  581.   var regexp = /\+/g;
  582.   qs = qs.split(sep);
  583.  
  584.   var maxKeys = 1000;
  585.   if (options && typeof options.maxKeys === 'number') {
  586.     maxKeys = options.maxKeys;
  587.   }
  588.  
  589.   var len = qs.length;
  590.   // maxKeys <= 0 means that we should not limit keys count
  591.   if (maxKeys > 0 && len > maxKeys) {
  592.     len = maxKeys;
  593.   }
  594.  
  595.   for (var i = 0; i < len; ++i) {
  596.     var x = qs[i].replace(regexp, '%20'),
  597.         idx = x.indexOf(eq),
  598.         kstr, vstr, k, v;
  599.  
  600.     if (idx >= 0) {
  601.       kstr = x.substr(0, idx);
  602.       vstr = x.substr(idx + 1);
  603.     } else {
  604.       kstr = x;
  605.       vstr = '';
  606.     }
  607.  
  608.     k = decodeURIComponent(kstr);
  609.     v = decodeURIComponent(vstr);
  610.  
  611.     if (!hasOwnProperty(obj, k)) {
  612.       obj[k] = v;
  613.     } else if (isArray(obj[k])) {
  614.       obj[k].push(v);
  615.     } else {
  616.       obj[k] = [obj[k], v];
  617.     }
  618.   }
  619.  
  620.   return obj;
  621. };
  622.  
  623. var isArray = Array.isArray || function (xs) {
  624.   return Object.prototype.toString.call(xs) === '[object Array]';
  625. };
  626.  
  627. },{}],12:[function(require,module,exports){
  628. // Copyright Joyent, Inc. and other Node contributors.
  629. //
  630. // Permission is hereby granted, free of charge, to any person obtaining a
  631. // copy of this software and associated documentation files (the
  632. // "Software"), to deal in the Software without restriction, including
  633. // without limitation the rights to use, copy, modify, merge, publish,
  634. // distribute, sublicense, and/or sell copies of the Software, and to permit
  635. // persons to whom the Software is furnished to do so, subject to the
  636. // following conditions:
  637. //
  638. // The above copyright notice and this permission notice shall be included
  639. // in all copies or substantial portions of the Software.
  640. //
  641. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  642. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  643. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  644. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  645. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  646. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  647. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  648.  
  649. 'use strict';
  650.  
  651. var stringifyPrimitive = function(v) {
  652.   switch (typeof v) {
  653.     case 'string':
  654.       return v;
  655.  
  656.     case 'boolean':
  657.       return v ? 'true' : 'false';
  658.  
  659.     case 'number':
  660.       return isFinite(v) ? v : '';
  661.  
  662.     default:
  663.       return '';
  664.   }
  665. };
  666.  
  667. module.exports = function(obj, sep, eq, name) {
  668.   sep = sep || '&';
  669.   eq = eq || '=';
  670.   if (obj === null) {
  671.     obj = undefined;
  672.   }
  673.  
  674.   if (typeof obj === 'object') {
  675.     return map(objectKeys(obj), function(k) {
  676.       var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
  677.       if (isArray(obj[k])) {
  678.         return map(obj[k], function(v) {
  679.           return ks + encodeURIComponent(stringifyPrimitive(v));
  680.         }).join(sep);
  681.       } else {
  682.         return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
  683.       }
  684.     }).join(sep);
  685.  
  686.   }
  687.  
  688.   if (!name) return '';
  689.   return encodeURIComponent(stringifyPrimitive(name)) + eq +
  690.          encodeURIComponent(stringifyPrimitive(obj));
  691. };
  692.  
  693. var isArray = Array.isArray || function (xs) {
  694.   return Object.prototype.toString.call(xs) === '[object Array]';
  695. };
  696.  
  697. function map (xs, f) {
  698.   if (xs.map) return xs.map(f);
  699.   var res = [];
  700.   for (var i = 0; i < xs.length; i++) {
  701.     res.push(f(xs[i], i));
  702.   }
  703.   return res;
  704. }
  705.  
  706. var objectKeys = Object.keys || function (obj) {
  707.   var res = [];
  708.   for (var key in obj) {
  709.     if (Object.prototype.hasOwnProperty.call(obj, key)) res.push(key);
  710.   }
  711.   return res;
  712. };
  713.  
  714. },{}],13:[function(require,module,exports){
  715. 'use strict';
  716.  
  717. exports.decode = exports.parse = require('./decode');
  718. exports.encode = exports.stringify = require('./encode');
  719.  
  720. },{"./decode":11,"./encode":12}]},{},[2]);