decidim-decidim_awesome 0.5.1

data/lib/decidim/decidim_awesome/test/factories.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "decidim/core/test/factories"
+require "decidim/proposals/test/factories"
+
+FactoryBot.define do
+  factory :awesome_config, class: "Decidim::DecidimAwesome::AwesomeConfig" do
+    var { Faker::Hacker.noun }
+    value { Decidim::DecidimAwesome.config.to_a.sample(1).to_h }
+    organization { create :organization }
+  end
+
+  factory :config_constraint, class: "Decidim::DecidimAwesome::ConfigConstraint" do
+    settings { { Faker::Hacker.noun => Faker::Hacker.noun } }
+    awesome_config { create :awesome_config }
+  end
+
+  factory :editor_image, class: "Decidim::DecidimAwesome::EditorImage" do
+    image { Faker::Hacker.noun }
+    path { Faker::Internet.url(host: "", scheme: "") }
+    author { create :user }
+    organization { create :organization }
+  end
+
+  factory :map_component, parent: :component do
+    name { Decidim::Components::Namer.new(participatory_space.organization.available_locales, :proposals).i18n_name }
+    manifest_name { :awesome_map }
+    participatory_space { create(:participatory_process, :with_steps, organization: organization) }
+  end
+
+  factory :iframe_component, parent: :component do
+    name { Decidim::Components::Namer.new(participatory_space.organization.available_locales, :proposals).i18n_name }
+    manifest_name { :awesome_iframe }
+    participatory_space { create(:participatory_process, :with_steps, organization: organization) }
+  end
+end

data/lib/decidim/decidim_awesome/test/shared_examples/config_examples.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+shared_examples "javascript config vars" do
+  it "has DecidimAwesome object" do
+    expect(page.body).to have_content("window.DecidimAwesome")
+    expect(page.body).to have_content("window.DecidimAwesome.editor_uploader_path")
+    expect(page.body).to have_content("window.DecidimAwesome.texts")
+  end
+end
+
+shared_examples "has menu link" do |item|
+  it "shows the feature link" do
+    within ".secondary-nav" do
+      expect(page).to have_link(href: "/admin/decidim_awesome/config/#{item}")
+    end
+  end
+end
+
+shared_examples "do not have menu link" do |item|
+  it "do not show the feature link" do
+    within ".secondary-nav" do
+      expect(page).not_to have_link(href: "/admin/decidim_awesome/config/#{item}")
+    end
+  end
+end

data/lib/decidim/decidim_awesome/test/themes/css.lvh.me.css

@@ -0,0 +1,3 @@
+body {
+  background: rgb(1, 2, 3);
+}

data/lib/decidim/decidim_awesome/test/themes/erb.lvh.me.scss.erb

@@ -0,0 +1,2 @@
+/* Decidim <%= Decidim.version %> */
+@import "test-theme/body.scss"

data/lib/decidim/decidim_awesome/test/themes/scss.lvh.me.scss

@@ -0,0 +1 @@
+@import "test-theme/body.scss"

data/lib/decidim/decidim_awesome/test/themes/test-theme/body.scss

@@ -0,0 +1,4 @@
+body{
+  background: darken(#f00, 10%);
+  background: rgb(1, 2, 3);
+}

data/lib/decidim/decidim_awesome/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This holds the decidim-decidim_awesome version.
+  module DecidimAwesome
+    VERSION = "0.5.1"
+    COMPAT_DECIDIM_VERSION = [">= 0.21.0", "< 0.23"].freeze
+    DECIDIM_VERSION = "0.22"
+  end
+end

data/vendor/assets/javascripts/codemirror-4.inline-attachment.js

@@ -0,0 +1,89 @@
+/*jslint newcap: true */
+/*global inlineAttachment: false */
+/**
+ * CodeMirror version for inlineAttachment
+ *
+ * Call inlineAttachment.attach(editor) to attach to a codemirror instance
+ */
+(function() {
+  'use strict';
+
+  var codeMirrorEditor = function(instance) {
+
+    if (!instance.getWrapperElement) {
+      throw "Invalid CodeMirror object given";
+    }
+
+    this.codeMirror = instance;
+  };
+
+  codeMirrorEditor.prototype.getValue = function() {
+    return this.codeMirror.getValue();
+  };
+
+  codeMirrorEditor.prototype.insertValue = function(val) {
+    this.codeMirror.replaceSelection(val);
+  };
+
+  codeMirrorEditor.prototype.setValue = function(val) {
+    var cursor = this.codeMirror.getCursor();
+    this.codeMirror.setValue(val);
+    this.codeMirror.setCursor(cursor);
+  };
+
+  /**
+   * Attach InlineAttachment to CodeMirror
+   *
+   * @param {CodeMirror} codeMirror
+   */
+  codeMirrorEditor.attach = function(codeMirror, options) {
+
+    options = options || {};
+
+    var editor = new codeMirrorEditor(codeMirror),
+      inlineattach = new inlineAttachment(options, editor),
+      el = codeMirror.getWrapperElement();
+
+    el.addEventListener('paste', function(e) {
+      inlineattach.onPaste(e);
+    }, false);
+
+    codeMirror.setOption('onDragEvent', function(data, e) {
+      if (e.type === "drop") {
+        e.stopPropagation();
+        e.preventDefault();
+        return inlineattach.onDrop(e);
+      }
+    });
+  };
+
+  var codeMirrorEditor4 = function(instance) {
+    codeMirrorEditor.call(this, instance);
+  };
+
+  codeMirrorEditor4.attach = function(codeMirror, options) {
+
+    options = options || {};
+
+    var editor = new codeMirrorEditor(codeMirror),
+      inlineattach = new inlineAttachment(options, editor),
+      el = codeMirror.getWrapperElement();
+
+    el.addEventListener('paste', function(e) {
+      inlineattach.onPaste(e);
+    }, false);
+
+    codeMirror.on('drop', function(data, e) {
+      if (inlineattach.onDrop(e)) {
+        e.stopPropagation();
+        e.preventDefault();
+        return true;
+      } else {
+        return false;
+      }
+    });
+  };
+
+  inlineAttachment.editors.codemirror4 = codeMirrorEditor4;
+
+})();

data/vendor/assets/javascripts/form-storage.js

@@ -0,0 +1,824 @@
+/**
+ * Modules in this bundle
+ * @license
+ *
+ * form-storage:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: appleple
+ *   version: 1.3.0
+ *
+ * decode-uri-component:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: Sam Verschueren <sam.verschueren@gmail.com>
+ *   homepage: https://github.com/SamVerschueren/decode-uri-component#readme
+ *   version: 0.2.0
+ *
+ * form-serialize:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: Roman Shtylman <shtylman@gmail.com>
+ *   homepage: https://github.com/shtylman/form-serialize#readme
+ *   version: 0.7.2
+ *
+ * query-string-es5:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: Sindre Sorhus <sindresorhus@gmail.com>
+ *   homepage: https://github.com/sindresorhus/query-string#readme
+ *   version: 6.1.4
+ *
+ * This header is generated by licensify (https://github.com/twada/licensify)
+ */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.FormStorage = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+'use strict';
+var token = '%[a-f0-9]{2}';
+var singleMatcher = new RegExp(token, 'gi');
+var multiMatcher = new RegExp('(' + token + ')+', 'gi');
+
+function decodeComponents(components, split) {
+  try {
+    // Try to decode the entire string first
+    return decodeURIComponent(components.join(''));
+  } catch (err) {
+    // Do nothing
+  }
+
+  if (components.length === 1) {
+    return components;
+  }
+
+  split = split || 1;
+
+  // Split the array in 2 parts
+  var left = components.slice(0, split);
+  var right = components.slice(split);
+
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+
+function decode(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch (err) {
+    var tokens = input.match(singleMatcher);
+
+    for (var i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join('');
+
+      tokens = input.match(singleMatcher);
+    }
+
+    return input;
+  }
+}
+
+function customDecodeURIComponent(input) {
+  // Keep track of all the replacements and prefill the map with the `BOM`
+  var replaceMap = {
+    '%FE%FF': '\uFFFD\uFFFD',
+    '%FF%FE': '\uFFFD\uFFFD'
+  };
+
+  var match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      // Decode as big chunks as possible
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch (err) {
+      var result = decode(match[0]);
+
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+
+    match = multiMatcher.exec(input);
+  }
+
+  // Add `%C2` at the end of the map to make sure it does not replace the combinator before everything else
+  replaceMap['%C2'] = '\uFFFD';
+
+  var entries = Object.keys(replaceMap);
+
+  for (var i = 0; i < entries.length; i++) {
+    // Replace all decoded components
+    var key = entries[i];
+    input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
+  }
+
+  return input;
+}
+
+module.exports = function (encodedURI) {
+  if (typeof encodedURI !== 'string') {
+    throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
+  }
+
+  try {
+    encodedURI = encodedURI.replace(/\+/g, ' ');
+
+    // Try the built in decoder first
+    return decodeURIComponent(encodedURI);
+  } catch (err) {
+    // Fallback to a more advanced decoder
+    return customDecodeURIComponent(encodedURI);
+  }
+};
+
+},{}],2:[function(require,module,exports){
+// get successful control from form and assemble into object
+// http://www.w3.org/TR/html401/interact/forms.html#h-17.13.2
+
+// types which indicate a submit action and are not successful controls
+// these will be ignored
+var k_r_submitter = /^(?:submit|button|image|reset|file)$/i;
+
+// node names which could be successful controls
+var k_r_success_contrls = /^(?:input|select|textarea|keygen)/i;
+
+// Matches bracket notation.
+var brackets = /(\[[^\[\]]*\])/g;
+
+// serializes form fields
+// @param form MUST be an HTMLForm element
+// @param options is an optional argument to configure the serialization. Default output
+// with no options specified is a url encoded string
+//    - hash: [true | false] Configure the output type. If true, the output will
+//    be a js object.
+//    - serializer: [function] Optional serializer function to override the default one.
+//    The function takes 3 arguments (result, key, value) and should return new result
+//    hash and url encoded str serializers are provided with this module
+//    - disabled: [true | false]. If true serialize disabled fields.
+//    - empty: [true | false]. If true serialize empty fields
+function serialize(form, options) {
+    if (typeof options != 'object') {
+        options = { hash: !!options };
+    }
+    else if (options.hash === undefined) {
+        options.hash = true;
+    }
+
+    var result = (options.hash) ? {} : '';
+    var serializer = options.serializer || ((options.hash) ? hash_serializer : str_serialize);
+
+    var elements = form && form.elements ? form.elements : [];
+
+    //Object store each radio and set if it's empty or not
+    var radio_store = Object.create(null);
+
+    for (var i=0 ; i<elements.length ; ++i) {
+        var element = elements[i];
+
+        // ingore disabled fields
+        if ((!options.disabled && element.disabled) || !element.name) {
+            continue;
+        }
+        // ignore anyhting that is not considered a success field
+        if (!k_r_success_contrls.test(element.nodeName) ||
+            k_r_submitter.test(element.type)) {
+            continue;
+        }
+
+        var key = element.name;
+        var val = element.value;
+
+        // we can't just use element.value for checkboxes cause some browsers lie to us
+        // they say "on" for value when the box isn't checked
+        if ((element.type === 'checkbox' || element.type === 'radio') && !element.checked) {
+            val = undefined;
+        }
+
+        // If we want empty elements
+        if (options.empty) {
+            // for checkbox
+            if (element.type === 'checkbox' && !element.checked) {
+                val = '';
+            }
+
+            // for radio
+            if (element.type === 'radio') {
+                if (!radio_store[element.name] && !element.checked) {
+                    radio_store[element.name] = false;
+                }
+                else if (element.checked) {
+                    radio_store[element.name] = true;
+                }
+            }
+
+            // if options empty is true, continue only if its radio
+            if (val == undefined && element.type == 'radio') {
+                continue;
+            }
+        }
+        else {
+            // value-less fields are ignored unless options.empty is true
+            if (!val) {
+                continue;
+            }
+        }
+
+        // multi select boxes
+        if (element.type === 'select-multiple') {
+            val = [];
+
+            var selectOptions = element.options;
+            var isSelectedOptions = false;
+            for (var j=0 ; j<selectOptions.length ; ++j) {
+                var option = selectOptions[j];
+                var allowedEmpty = options.empty && !option.value;
+                var hasValue = (option.value || allowedEmpty);
+                if (option.selected && hasValue) {
+                    isSelectedOptions = true;
+
+                    // If using a hash serializer be sure to add the
+                    // correct notation for an array in the multi-select
+                    // context. Here the name attribute on the select element
+                    // might be missing the trailing bracket pair. Both names
+                    // "foo" and "foo[]" should be arrays.
+                    if (options.hash && key.slice(key.length - 2) !== '[]') {
+                        result = serializer(result, key + '[]', option.value);
+                    }
+                    else {
+                        result = serializer(result, key, option.value);
+                    }
+                }
+            }
+
+            // Serialize if no selected options and options.empty is true
+            if (!isSelectedOptions && options.empty) {
+                result = serializer(result, key, '');
+            }
+
+            continue;
+        }
+
+        result = serializer(result, key, val);
+    }
+
+    // Check for all empty radio buttons and serialize them with key=""
+    if (options.empty) {
+        for (var key in radio_store) {
+            if (!radio_store[key]) {
+                result = serializer(result, key, '');
+            }
+        }
+    }
+
+    return result;
+}
+
+function parse_keys(string) {
+    var keys = [];
+    var prefix = /^([^\[\]]*)/;
+    var children = new RegExp(brackets);
+    var match = prefix.exec(string);
+
+    if (match[1]) {
+        keys.push(match[1]);
+    }
+
+    while ((match = children.exec(string)) !== null) {
+        keys.push(match[1]);
+    }
+
+    return keys;
+}
+
+function hash_assign(result, keys, value) {
+    if (keys.length === 0) {
+        result = value;
+        return result;
+    }
+
+    var key = keys.shift();
+    var between = key.match(/^\[(.+?)\]$/);
+
+    if (key === '[]') {
+        result = result || [];
+
+        if (Array.isArray(result)) {
+            result.push(hash_assign(null, keys, value));
+        }
+        else {
+            // This might be the result of bad name attributes like "[][foo]",
+            // in this case the original `result` object will already be
+            // assigned to an object literal. Rather than coerce the object to
+            // an array, or cause an exception the attribute "_values" is
+            // assigned as an array.
+            result._values = result._values || [];
+            result._values.push(hash_assign(null, keys, value));
+        }
+
+        return result;
+    }
+
+    // Key is an attribute name and can be assigned directly.
+    if (!between) {
+        result[key] = hash_assign(result[key], keys, value);
+    }
+    else {
+        var string = between[1];
+        // +var converts the variable into a number
+        // better than parseInt because it doesn't truncate away trailing
+        // letters and actually fails if whole thing is not a number
+        var index = +string;
+
+        // If the characters between the brackets is not a number it is an
+        // attribute name and can be assigned directly.
+        if (isNaN(index)) {
+            result = result || {};
+            result[string] = hash_assign(result[string], keys, value);
+        }
+        else {
+            result = result || [];
+            result[index] = hash_assign(result[index], keys, value);
+        }
+    }
+
+    return result;
+}
+
+// Object/hash encoding serializer.
+function hash_serializer(result, key, value) {
+    var matches = key.match(brackets);
+
+    // Has brackets? Use the recursive assignment function to walk the keys,
+    // construct any missing objects in the result tree and make the assignment
+    // at the end of the chain.
+    if (matches) {
+        var keys = parse_keys(key);
+        hash_assign(result, keys, value);
+    }
+    else {
+        // Non bracket notation can make assignments directly.
+        var existing = result[key];
+
+        // If the value has been assigned already (for instance when a radio and
+        // a checkbox have the same name attribute) convert the previous value
+        // into an array before pushing into it.
+        //
+        // NOTE: If this requirement were removed all hash creation and
+        // assignment could go through `hash_assign`.
+        if (existing) {
+            if (!Array.isArray(existing)) {
+                result[key] = [ existing ];
+            }
+
+            result[key].push(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+
+    return result;
+}
+
+// urlform encoding serializer
+function str_serialize(result, key, value) {
+    // encode newlines as \r\n cause the html spec says so
+    value = value.replace(/(\r)?\n/g, '\r\n');
+    value = encodeURIComponent(value);
+
+    // spaces should be '+' rather than '%20'.
+    value = value.replace(/%20/g, '+');
+    return result + (result ? '&' : '') + encodeURIComponent(key) + '=' + value;
+}
+
+module.exports = serialize;
+
+},{}],3:[function(require,module,exports){
+'use strict';
+
+var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
+
+var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+
+var encodeURIComponent = function (str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function (x) {
+    return "%" + x.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+
+var decodeComponent = require('decode-uri-component');
+
+function encoderForArrayFormat(options) {
+  switch (options.arrayFormat) {
+    case 'index':
+      return function (key, value, index) {
+        return value === null ? [encode(key, options), '[', index, ']'].join('') : [encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('');
+      };
+    case 'bracket':
+      return function (key, value) {
+        return value === null ? [encode(key, options), '[]'].join('') : [encode(key, options), '[]=', encode(value, options)].join('');
+      };
+    default:
+      return function (key, value) {
+        return value === null ? encode(key, options) : [encode(key, options), '=', encode(value, options)].join('');
+      };
+  }
+}
+
+function parserForArrayFormat(options) {
+  var result = void 0;
+
+  switch (options.arrayFormat) {
+    case 'index':
+      return function (key, value, accumulator) {
+        result = /\[(\d*)\]$/.exec(key);
+
+        key = key.replace(/\[\d*\]$/, '');
+
+        if (!result) {
+          accumulator[key] = value;
+          return;
+        }
+
+        if (accumulator[key] === undefined) {
+          accumulator[key] = {};
+        }
+
+        accumulator[key][result[1]] = value;
+      };
+    case 'bracket':
+      return function (key, value, accumulator) {
+        result = /(\[\])$/.exec(key);
+        key = key.replace(/\[\]$/, '');
+
+        if (!result) {
+          accumulator[key] = value;
+          return;
+        }
+
+        if (accumulator[key] === undefined) {
+          accumulator[key] = [value];
+          return;
+        }
+
+        accumulator[key] = [].concat(accumulator[key], value);
+      };
+    default:
+      return function (key, value, accumulator) {
+        if (accumulator[key] === undefined) {
+          accumulator[key] = value;
+          return;
+        }
+
+        accumulator[key] = [].concat(accumulator[key], value);
+      };
+  }
+}
+
+function encode(value, options) {
+  if (options.encode) {
+    return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
+  }
+
+  return value;
+}
+
+function decode(value, options) {
+  if (options.decode) {
+    return decodeComponent(value);
+  }
+
+  return value;
+}
+
+function keysSorter(input) {
+  if (Array.isArray(input)) {
+    return input.sort();
+  }
+
+  if ((typeof input === 'undefined' ? 'undefined' : _typeof(input)) === 'object') {
+    return keysSorter(Object.keys(input)).sort(function (a, b) {
+      return Number(a) - Number(b);
+    }).map(function (key) {
+      return input[key];
+    });
+  }
+
+  return input;
+}
+
+function extract(input) {
+  var queryStart = input.indexOf('?');
+  if (queryStart === -1) {
+    return '';
+  }
+  return input.slice(queryStart + 1);
+}
+
+function parse(input, options) {
+  options = Object.assign({ decode: true, arrayFormat: 'none' }, options);
+
+  var formatter = parserForArrayFormat(options);
+
+  // Create an object with no prototype
+  var ret = Object.create(null);
+
+  if (typeof input !== 'string') {
+    return ret;
+  }
+
+  input = input.trim().replace(/^[?#&]/, '');
+
+  if (!input) {
+    return ret;
+  }
+
+  var _iteratorNormalCompletion = true;
+  var _didIteratorError = false;
+  var _iteratorError = undefined;
+
+  try {
+    for (var _iterator = input.split('&')[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+      var param = _step.value;
+
+      var _param$replace$split = param.replace(/\+/g, ' ').split('='),
+          _param$replace$split2 = _slicedToArray(_param$replace$split, 2),
+          key = _param$replace$split2[0],
+          value = _param$replace$split2[1];
+
+      // Missing `=` should be `null`:
+      // http://w3.org/TR/2012/WD-url-20120524/#collect-url-parameters
+
+
+      value = value === undefined ? null : decode(value, options);
+
+      formatter(decode(key, options), value, ret);
+    }
+  } catch (err) {
+    _didIteratorError = true;
+    _iteratorError = err;
+  } finally {
+    try {
+      if (!_iteratorNormalCompletion && _iterator.return) {
+        _iterator.return();
+      }
+    } finally {
+      if (_didIteratorError) {
+        throw _iteratorError;
+      }
+    }
+  }
+
+  return Object.keys(ret).sort().reduce(function (result, key) {
+    var value = ret[key];
+    if (Boolean(value) && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object' && !Array.isArray(value)) {
+      // Sort object keys, not values
+      result[key] = keysSorter(value);
+    } else {
+      result[key] = value;
+    }
+
+    return result;
+  }, Object.create(null));
+}
+
+exports.extract = extract;
+exports.parse = parse;
+
+exports.stringify = function (obj, options) {
+  var defaults = {
+    encode: true,
+    strict: true,
+    arrayFormat: 'none'
+  };
+
+  options = Object.assign(defaults, options);
+
+  if (options.sort === false) {
+    options.sort = function () {};
+  }
+
+  var formatter = encoderForArrayFormat(options);
+
+  return obj ? Object.keys(obj).sort(options.sort).map(function (key) {
+    var value = obj[key];
+
+    if (value === undefined) {
+      return '';
+    }
+
+    if (value === null) {
+      return encode(key, options);
+    }
+
+    if (Array.isArray(value)) {
+      var result = [];
+
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = value.slice()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var value2 = _step2.value;
+
+          if (value2 === undefined) {
+            continue;
+          }
+
+          result.push(formatter(key, value2, result.length));
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      return result.join('&');
+    }
+
+    return encode(key, options) + '=' + encode(value, options);
+  }).filter(function (x) {
+    return x.length > 0;
+  }).join('&') : '';
+};
+
+exports.parseUrl = function (input, options) {
+  return {
+    url: input.split('?')[0] || '',
+    query: parse(extract(input), options)
+  };
+};
+},{"decode-uri-component":1}],4:[function(require,module,exports){
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _formSerialize = require('form-serialize');
+
+var _formSerialize2 = _interopRequireDefault(_formSerialize);
+
+var _queryStringEs = require('query-string-es5');
+
+var _queryStringEs2 = _interopRequireDefault(_queryStringEs);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var defaults = {
+  name: 'form',
+  ignores: [],
+  includes: [],
+  checkbox: null
+};
+
+var FormStorage = function () {
+  function FormStorage(selector, opt) {
+    _classCallCheck(this, FormStorage);
+
+    this.ele = document.querySelector(selector);
+    this.opt = Object.assign({}, defaults, opt);
+    if (this.opt.checkbox) {
+      this.checkbox = document.querySelector(this.opt.checkbox);
+      this.setCheckbox();
+      this.apply();
+    }
+  }
+
+  _createClass(FormStorage, [{
+    key: 'save',
+    value: function save() {
+      var str = (0, _formSerialize2.default)(this.ele);
+      window.localStorage.setItem(this.opt.name, str);
+    }
+  }, {
+    key: 'clear',
+    value: function clear() {
+      window.localStorage.removeItem(this.opt.name);
+    }
+  }, {
+    key: 'setCheckbox',
+    value: function setCheckbox() {
+      var _this = this;
+
+      this.ele.addEventListener('submit', function () {
+        if (_this.checkbox.checked) {
+          _this.save();
+        } else {
+          _this.clear();
+        }
+      });
+    }
+  }, {
+    key: 'getState',
+    value: function getState() {
+      return (0, _formSerialize2.default)(this.ele);
+    }
+  }, {
+    key: 'applyState',
+    value: function applyState(str) {
+      var _this2 = this;
+
+      var _opt = this.opt,
+          ignores = _opt.ignores,
+          includes = _opt.includes;
+
+      var obj = _queryStringEs2.default.parse(str.replace(/^"(.*)"$/, "$1"));
+
+      var _loop = function _loop(key) {
+        var flag = false;
+        var target = _this2.ele.querySelector('[name="' + key + '"]');
+        var targets = _this2.ele.querySelectorAll('[name="' + key + '"]');
+
+        if (!target) {
+          return 'continue';
+        }
+
+        ignores.forEach(function (ignore) {
+          if (target.matches(ignore)) {
+            flag = true;
+            return false;
+          }
+        });
+
+        if (flag) {
+          return 'continue';
+        }
+
+        if (includes.length > 0) {
+          flag = true;
+          includes.forEach(function (include) {
+            if (target.matches(include)) {
+              flag = false;
+              return false;
+            }
+          });
+          if (flag) {
+            return 'continue';
+          }
+        }
+
+        if (targets && targets.length > 1) {
+          var arr = obj[key];
+          [].forEach.call(targets, function (tar, index) {
+            if (tar.type === 'checkbox') {
+              if (arr.forEach) {
+                arr.forEach(function (item) {
+                  if (item === tar.value) {
+                    tar.checked = true;
+                  }
+                });
+              } else {
+                if (arr === tar.value) {
+                  tar.checked = true;
+                }
+              }
+            } else if (tar.type === 'radio') {
+              if (tar.value === arr) {
+                tar.checked = true;
+              }
+            }
+          });
+          return 'continue';
+        }
+
+        if (target.type === 'radio' || target.type === 'checkbox') {
+          if (obj[key] === target.value) {
+            target.checked = true;
+          }
+        } else {
+          target.value = obj[key];
+        }
+      };
+
+      for (var key in obj) {
+        var _ret = _loop(key);
+
+        if (_ret === 'continue') continue;
+      }
+    }
+  }, {
+    key: 'apply',
+    value: function apply() {
+      var str = window.localStorage.getItem(this.opt.name);
+      if (!str) {
+        return;
+      }
+      this.applyState(str);
+    }
+  }]);
+
+  return FormStorage;
+}();
+
+exports.default = FormStorage;
+module.exports = exports['default'];
+
+},{"form-serialize":2,"query-string-es5":3}]},{},[4])(4)
+});