☰

Mint.com Customize Default Categories

Hide specified default built-in mint.com categories

  1. // ==UserScript==
  2. // @name Mint.com Customize Default Categories
  3. // @namespace com.schrauger.mint.js
  4. // @author Stephen Schrauger
  5. // @description Hide specified default built-in mint.com categories
  6. // @homepage https://github.com/schrauger/mint.com-customize-default-categories
  7. // @include https://*.mint.com/*
  8. // @include https://mint.intuit.com/*
  9. // @version 1.4.5
  10. // @grant none
  11. // ==/UserScript==
  12. /*jslint browser: true*/
  13. /*global jQuery*/
  14. (function () {
  15. function after_jquery() {
  16.     var number_of_bit_arrays = 3; // use 3 arrays to store all preferences.
  17.     var unique_id_length = 4; // the bit array is prefixed with '#!1 ' or '#!2 ' or '#!3 ', which is 4 characters long
  18.     var categories_per_string = 8; // with 20 characters per string, and 2 characters per category, we can fit 8 (plus the 4-char unique id)
  19.     var characters_per_category = 2; // with 6 flags, this allows for 11 sub categories and 1 major category
  20.     var bit_flags_per_char = 6; // using 01XXXXXX ASCII codes, which allows for 6 flags per character
  21.     var category_id = 20; // save the custom fields in the 'uncategorized' major category, which has the id of 20
  22.     var class_hidden = 'sgs-hide-from-mint'; // just a unique class; if an element has it, it will be hidden.
  23.     var class_edit_mode = 'mint_edit_mode';
  24.  
  25.     var hs_action_hide = 'hide';
  26.     var hs_action_show = 'show';
  27.     var hs_action_edit = 'edit';
  28.     
  29.     var sgs_style_sheet = create_style_sheet();
  30.  
  31. // Need to define all categories and subcategories, along with their ID. Create this list dynamically.
  32.     function get_default_category_list() {
  33.         var categories = [];
  34.  
  35.         // loop through each category and create an array of arrays with their info
  36.         jQuery('#popup-cc-L1').find('> li').each(function () {
  37.             var category_major = [];
  38.             category_major.id = jQuery(this).attr('id').replace(/\D/g, ''); // number-only portion (they all start with 'pop-categories-'{number}
  39.             //console.log(category_major.id);
  40.             category_major.name = jQuery(this).children('a').text();
  41.             category_major.categories_minor = [];
  42.             category_major.is_hidden = jQuery(this).hasClass(class_hidden);
  43.             /* get the minor/sub categories. only the :first ul, because the second one is
  44.              user-defined custom categories, which they can change with native mint.com controls
  45.              */
  46.             jQuery(this).find('div.popup-cc-L2 ul:first > li').each(function () {
  47.                 var category_minor = [];
  48.                 category_minor.id = jQuery(this).attr('id').replace(/\D/g, '');
  49.                 category_minor.name = jQuery(this).text();
  50.                 category_minor.is_hidden = jQuery(this).hasClass(class_hidden);
  51.                 category_major.categories_minor.push(category_minor);
  52.             });
  53.             categories.push(category_major);
  54.         });
  55.  
  56.         return categories;
  57.     }
  58.  
  59. // Save any categories the user wants hidden.
  60. // This will be done by creating a custom subcategory in the 'uncategorized' category, where the name of this
  61. // subcategory will define which other categories to hide.
  62. // This way, if the UserScript is installed on multiple computers, the user sees their preferences synced.
  63. // Alternatively, a cookie could be used, but preferences would be specific to that device.
  64.  
  65.     /**
  66.      * @str_bit_array_array Array A printable-ascii encoded bit array (values that can be saved in a custom category)
  67.      * @array_of_all_categories Array 8*3 categories with their subcategories and
  68.      *                                  ID, name, subcategories and is_hidden members
  69.      *                                  for both the category and subcategories
  70.      */
  71.     function decode_bit_array(str_bit_array_array, array_of_all_categories) {
  72.  
  73.         // second, translate any extra characters into their forbidden character
  74.         // (double quote is forbidden; use a non-bit-array character to encode)
  75.  
  76.         // third, loop through each category and each of its subcategories
  77.  
  78.         // use bitwise operators to see if the subcategory minor id (always 1-9) is marked as hidden
  79.  
  80.  
  81.         str_bit_array_array.sort();
  82.  
  83.         array_of_all_categories.sort(function (a, b) {
  84.             return (a.id - b.id); // sort by id, lowest first
  85.         });
  86.  
  87.  
  88.         var field_count = 0; // 0, 1, or 2; for the 3 unique fields holding the 23 category hidden attributes
  89.         var bit_string_category_count = 0; // only 8 categories per string. once this goes past 7, reset and use next string.
  90.         var str_bit_array = str_bit_array_array[field_count]; // 3 custom fields with attributes
  91.         // remove the first 4 characters (the unique ID plus a space)
  92.         str_bit_array = str_bit_array.substring(unique_id_length); // 0-based, meaning start at the fifth character (inclusive)
  93.  
  94.         // loop through each major category and its minor categories and mark them as hidden or not
  95.         for (var category_major_count = 0, category_major_length = array_of_all_categories.length; category_major_count < category_major_length; category_major_count++) {
  96.             var category_major = array_of_all_categories[category_major_count];
  97.  
  98.             array_of_all_categories[category_major_count].categories_minor.sort(function (a, b) {
  99.                 return (a.id - b.id); // sort by id, lowest first
  100.             });
  101.  
  102.  
  103.             var bit_characters = str_bit_array.substr(bit_string_category_count * characters_per_category, characters_per_category); // grab the 2 characters for this category
  104.  
  105.             for (var category_minor_count = 0, category_minor_length = category_major.categories_minor.length; category_minor_count < category_minor_length; category_minor_count++) {
  106.  
  107.                 var minor_id = category_major.categories_minor[category_minor_count].id.slice(-2); // the last two digits are the minor category; the first two are always the same as the parent major category
  108.                 // if flag is '1', it is hidden
  109.                 array_of_all_categories[category_major_count].categories_minor[category_minor_count].is_hidden = is_category_hidden(bit_characters, minor_id);
  110.                 //console.debug(array_of_all_categories[category_major_count].categories_minor[category_minor_count].name + ' is hidden: '
  111.                 //                + array_of_all_categories[category_major_count].categories_minor[category_minor_count].is_hidden);
  112.             }
  113.             var last_flag = characters_per_category * bit_flags_per_char; // last flag is used for major category, instead of subcategory #12 (2 * 6);
  114.             array_of_all_categories[category_major_count].is_hidden = is_category_hidden(bit_characters, last_flag);
  115.             //console.debug(array_of_all_categories[category_major_count].name + ' is hidden: '
  116.             //                    + array_of_all_categories[category_major_count].is_hidden);
  117.             bit_string_category_count += 1;
  118.             if (bit_string_category_count > (categories_per_string - 1)) {
  119.                 // each of our custom bit arrays can only hold 8 categories' info. reset the counter and move on to the next bit array
  120.                 bit_string_category_count = 0;
  121.                 field_count += 1;
  122.  
  123.                 str_bit_array = str_bit_array_array[field_count]; // 3 custom fields with attributes
  124.                 // remove the first 4 characters (the unique ID plus a space)
  125.                 str_bit_array = str_bit_array.substring(unique_id_length); // 0-based, meaning start at character 5 (inclusive)
  126.             }
  127.         }
  128.         return array_of_all_categories;
  129.     }
  130.  
  131.     /**
  132.      * Returns true if the bit location is set to true.
  133.      */
  134.     function is_category_hidden(ascii_characters, minor_id) {
  135.         var bit_shift_count = ((minor_id - 1) % bit_flags_per_char); // category 1 is stored in last bit flag; cat 2 in the second to last. cat 7 stored in last flag
  136.         var bit_to_use = (Math.floor((minor_id - 1) / bit_flags_per_char)); // 1-6 (0-5) in first bit. 7-12 (6-11) stored in second. etc. 7/6 floored is 1.
  137.         var bit_character = (ascii_characters.charCodeAt(bit_to_use)); // get binary representation
  138.         var is_hidden = ((bit_character >>> bit_shift_count) & 000001); // shift the bits over and mask with '1'. if both are 1, it will return 1 (true) for hidden
  139.         //console.log('is_hidden: ' + is_hidden);
  140.         return is_hidden;
  141.     }
  142.  
  143.     function encode_category_hidden(ascii_characters, minor_id, is_hidden) {
  144.         var bit_shift_count = ((minor_id - 1) % bit_flags_per_char); // category 1 is stored in last bit flag; cat 2 in the second to last. cat 7 stored in last flag
  145.         var bit_to_use = (Math.floor((minor_id - 1) / bit_flags_per_char)); // 1-6 (0-5) in first bit. 7-12 (6-11) stored in second. etc. 7/6 floored is 1.
  146.         var mask = ((is_hidden << bit_shift_count)); // move the mask to the proper location
  147.  
  148.         var new_char = String.fromCharCode(ascii_characters[bit_to_use].charCodeAt(0) | mask);
  149.         ascii_characters = ascii_characters.replaceAt(bit_to_use, new_char); // replace with new character
  150.         //console.debug(ascii_characters);
  151.         return ascii_characters;
  152.     }
  153.  
  154.     /**
  155.      * Replaces the substituted characters with the 'illegal' characters.
  156.      * This way, the script can use bitwise operations in a logical manner.
  157.      */
  158.     function translate_to_script(string_with_substituted_characters) {
  159.         var str_return = string_with_substituted_characters.replace('?', String.fromCharCode(127)); // the delete char (127) is substituted with a question mark when saved at mint
  160.         return str_return;
  161.     }
  162.  
  163.     /**
  164.      * Replaces any illegal characters with substituted characters that mint.com allows in text fields.
  165.      */
  166.     function translate_to_mint(string_with_illegal_characters) {
  167.         var str_return = string_with_illegal_characters.replace(String.fromCharCode(127), '?');
  168.         return str_return;
  169.     }
  170.  
  171.     /**
  172.      * Extracts the bit arrays from the saved custom category input box and puts all 3 into a string array.
  173.      * @returns {Array}
  174.      */
  175.     function extract_mint_array() {
  176.         var str_bit_array_array = [];
  177.         for (var array_number = 1; array_number <= number_of_bit_arrays; array_number++){
  178.            str_bit_array_array.push(jQuery('#menu-category-' + category_id + ' ul li:contains("#!' + array_number + '"):first').text());
  179.             //console.log('processing val is ' + jQuery(this).text()); 
  180.         }
  181.         return str_bit_array_array;
  182.     }
  183.  
  184.     function encode_bit_array(array_of_all_categories) {
  185.         // loop through each category, create an ASCII character, and replace illegal characters
  186.  
  187.         array_of_all_categories.sort(function (a, b) {
  188.             return (a.id - b.id); // sort by id, lowest first
  189.         });
  190.  
  191.         var field_count = 0; // 0, 1, or 2; for the 3 unique fields holding the 23 category hidden attributes
  192.         var bit_string_category_count = 0; // only 8 categories per string. once this goes past 7, reset and use next string.
  193.         var str_bit_array_array = [];
  194.  
  195.         // loop through each major category and its minor categories and mark them as hidden or not
  196.         str_bit_array_array[field_count] = new Array(characters_per_category * categories_per_string + 1).join('@');
  197.         for (var category_major_count = 0, category_major_length = array_of_all_categories.length; category_major_count < category_major_length; category_major_count++) {
  198.  
  199.             var category_major = array_of_all_categories[category_major_count];
  200.  
  201.             array_of_all_categories[category_major_count].categories_minor.sort(function (a, b) {
  202.                 return (a.id - b.id); // sort by id, lowest first
  203.             });
  204.  
  205.  
  206.             var bit_characters = new Array(characters_per_category + 1).join('@'); // the @ character is 01000000, so all flags (last 6) start 'off'.
  207.             for (var category_minor_count = 0, category_minor_length = category_major.categories_minor.length; category_minor_count < category_minor_length; category_minor_count++) {
  208.  
  209.                 var minor_id = category_major.categories_minor[category_minor_count].id.slice(-2); // the last two digits are the minor category; the first two are always the same as the parent major category
  210.                 // if flag is '1', it is hidden
  211.  
  212.                 bit_characters = encode_category_hidden(bit_characters, minor_id, array_of_all_categories[category_major_count].categories_minor[category_minor_count].is_hidden);
  213.                 str_bit_array_array[field_count] = str_bit_array_array[field_count].replaceAt(bit_string_category_count * characters_per_category, bit_characters);
  214.             }
  215.             var last_flag = characters_per_category * bit_flags_per_char; // last flag is used for major category, instead of subcategory #12 (2 * 6);
  216.             bit_characters = encode_category_hidden(bit_characters, last_flag, array_of_all_categories[category_major_count].is_hidden);
  217.  
  218.             str_bit_array_array[field_count] = str_bit_array_array[field_count].replaceAt(bit_string_category_count * characters_per_category, bit_characters);
  219.  
  220.             bit_string_category_count += 1;
  221.             if (bit_string_category_count > (categories_per_string - 1)) {
  222.                 // each of our custom bit arrays can only hold 8 categories' info. reset the counter and move on to the next bit array
  223.                 bit_string_category_count = 0;
  224.                 field_count += 1;
  225.                 str_bit_array_array[field_count] = new Array(characters_per_category * categories_per_string + 1).join('@');
  226.             }
  227.         }
  228.         // now that all 3 bit arrays are creates, tack on the unique id to the string
  229.         for (var i = 0; i < number_of_bit_arrays; i++) {
  230.             str_bit_array_array[i] = '#!' + (i + 1) + ' ' + str_bit_array_array[i];
  231.             str_bit_array_array[i] = translate_to_mint(str_bit_array_array[i]);
  232.             //console.log(str_bit_array_array[i]);
  233.         }
  234.         return str_bit_array_array;
  235.     }
  236.  
  237.     function clean_up_extra_fields(bit_string) {
  238.         var unique_id = bit_string.substr(0, unique_id_length);
  239.         jQuery('ul.popup-cc-L2-custom > li > input[value^="' + unique_id + '"]:not(:first)').each(function () {
  240.             var input_id = jQuery(this).prev().val();
  241.             delete_field(input_id);
  242.         });
  243.     }
  244.  
  245.     /**
  246.      * Will update or insert as needed.
  247.      * @param bit_string
  248.      */
  249.     function upsert_field(bit_string) {
  250.         var unique_id = bit_string.substr(0, unique_id_length);
  251.         var input_id = jQuery('ul.popup-cc-L2-custom > li > input[value^="' + unique_id + '"]:first').prev().val();
  252.         if (input_id) {
  253.             update_field(bit_string);
  254.         } else {
  255.             insert_field(bit_string);
  256.         }
  257.     }
  258.  
  259.     function insert_field(bit_string) {
  260.         var hidden_token = JSON.parse(jQuery('#javascript-user').val()).token;
  261.         var data = {
  262.             pcatId: category_id,
  263.             catId: 0,
  264.             category: bit_string,
  265.             task: 'C',
  266.             token: hidden_token
  267.         };
  268.         jQuery.ajax(
  269.             {
  270.                 type: "POST",
  271.                 url: '/updateCategory.xevent',
  272.                 data: data
  273.             }
  274.         );
  275.     }
  276.  
  277.     function update_field(bit_string) {
  278.  
  279.         var hidden_token = JSON.parse(jQuery('#javascript-user').val()).token;
  280.         var unique_id = bit_string.substr(0, unique_id_length);
  281.  
  282.         var input = jQuery('ul.popup-cc-L2-custom > li > input[value^="' + unique_id + '"]:first');
  283.         //console.log('setting input string from ' + input.val() + ' to ' + bit_string);
  284.         input.val(bit_string); // set the value on the user's page manually (not needed for ajax, but needed for later processing)
  285.         //jQuery('#menu-category-' + category_id + ' ul li:contains("' + unique_id + '")').text(bit_string); //@TODO what is this line doing?
  286.         /*    input.prop('value',bit_string);
  287.          input.attr('value',bit_string);*/
  288.         var input_id = input.prev().val();
  289.         var data = {
  290.             pcatId: category_id,
  291.             catId: input_id,
  292.             category: bit_string,
  293.             task: 'U',
  294.             token: hidden_token
  295.         };
  296.         jQuery.ajax(
  297.             {
  298.                 type: "POST",
  299.                 url: '/updateCategory.xevent',
  300.                 data: data
  301.             }
  302.         );
  303.     }
  304.  
  305.     function delete_field(input_id) {
  306.         var hidden_token = JSON.parse(jQuery('#javascript-user').val()).token;
  307.         var data = {
  308.             catId: input_id,
  309.             task: 'D',
  310.             token: hidden_token
  311.         };
  312.         jQuery.ajax(
  313.             {
  314.                 type: "POST",
  315.                 url: '/updateCategory.xevent',
  316.                 data: data
  317.             }
  318.         );
  319.     }
  320.  
  321.     /**
  322.      * Loop through all the category objects. If any are hidden,
  323.      * add the proper CSS to hide the field.
  324.      * Also, remove any line-throughs, in case a hidden category has been restored.
  325.      * @param default_categories
  326.      */
  327.     function process_hidden_categories(default_categories) {
  328.         clearSGSStyle(); // clear css rules first. these rules define elements that are hidden, based on their id.
  329.         
  330.         for (var major_count = 0; major_count < default_categories.length; major_count++) {
  331.             for (var minor_count = 0; minor_count < default_categories[major_count].categories_minor.length; minor_count++) {
  332.                 if (default_categories[major_count].categories_minor[minor_count].is_hidden) {
  333.                     jQuery('#menu-category-' + default_categories[major_count].categories_minor[minor_count].id).addClass(class_hidden);
  334.                     css_hide_element('#menu-category-' + default_categories[major_count].categories_minor[minor_count].id);
  335.                     
  336.                     //console.log('hide minor ' + default_categories[major_count].categories_minor[minor_count].id);
  337.                     jQuery('#pop-categories-' + default_categories[major_count].categories_minor[minor_count].id).addClass(class_hidden);
  338.                 }
  339.                 jQuery('#menu-category-' + default_categories[major_count].categories_minor[minor_count].id).css('text-decoration', '');
  340.                 jQuery('#pop-categories-' + default_categories[major_count].categories_minor[minor_count].id).css('text-decoration', '');
  341.             }
  342.             if (default_categories[major_count].is_hidden) {
  343.                 jQuery('#menu-category-' + default_categories[major_count].id).addClass(class_hidden);
  344.                 jQuery('#pop-categories-' + default_categories[major_count].id).addClass(class_hidden);
  345.  
  346.             }
  347. // insert rename here
  348.             jQuery('#menu-category-' + default_categories[major_count].id).css('text-decoration', '');
  349.             jQuery('#pop-categories-' + default_categories[major_count].id).css('text-decoration', '');
  350.  
  351.         }
  352.         hide_show_category(hs_action_hide);
  353.     }
  354.     
  355.     
  356.     /**
  357.      * Recently, mint has been removing all classes of elements after the dropdown
  358.      * is shown. This unfortunately removes my hiding class, causing subcategories
  359.      * to be shown after briefly being hidden.
  360.      * Therefore, this function was created to make a global css rule to hide
  361.      * and show elements based on their id, rather than by adding classes.
  362.      */
  363.     function css_hide_element(element_id){
  364.         addSGSStyle(element_id, 'display: none');
  365.     }
  366.  
  367.     /**
  368.      *
  369.      * @param action
  370.      */
  371.     function hide_show_category(action) {
  372.         var category = jQuery('.' + class_hidden);
  373.         if (action == hs_action_hide) {
  374.             // hide the categories completely
  375.             category.hide();
  376.             category.css('text-decoration', 'line-through');
  377.         }
  378.         if (action == hs_action_show) {
  379.             // remove any visible attributes
  380.             category.show();
  381.             category.css('text-decoration', '');
  382.         }
  383.         if (action == hs_action_edit) {
  384.             category.show();
  385.             category.css('text-decoration', 'line-through');
  386.         }
  387.     }
  388.  
  389.     function add_toggle() {
  390.         if (!(jQuery('#sgs-toggle').length)) {
  391.             var toggle_style = "position: absolute; right: 30px; top: 35px; cursor: pointer";
  392.             var toggle_text = "Edit Hidden Categories";
  393.             jQuery('#pop-categories-main').prepend('<div id="sgs-toggle" class="" style="' + toggle_style + '">' + toggle_text + '</div>');
  394.             jQuery('#sgs-toggle').click(function () {
  395.                 edit_categories();
  396.             });
  397.             jQuery('#pop-categories-submit').click(function(){
  398.                 jQuery('#sgs-toggle').addClass('editing'); // force the current mode to be editing so the edit_categories call saves
  399.                 edit_categories(); // if user clicks the "I'm done" button, we should also save the categories.
  400.             })
  401.         }
  402.     }
  403.  
  404.     function edit_categories() {
  405.         var toggle = jQuery('#sgs-toggle');
  406.         toggle.toggleClass('editing');
  407.         if (toggle.hasClass('editing')) {
  408.             toggle.text('Save Hidden Categories');
  409.             mint_edit(true); // make all categories clickable; when clicked, add class and strike out
  410.         } else {
  411.             mint_edit(false); // remove clickable event and strike css; go back to hiding
  412.             mint_save();
  413.             toggle.text('Edit Hidden Categories');
  414.  
  415.         }
  416.  
  417.     }
  418.  
  419.     function mint_edit(edit_mode) {
  420.         if (edit_mode) {
  421.             // get the major and minor categories in the popup editor
  422.             var minor_categories = jQuery('div.popup-cc-L2 > ul:first-of-type > li'); // second ul is custom categories, so just get first
  423.             var major_categories = jQuery('#popup-cc-L1').find('.isL1');
  424.  
  425.  
  426.             // display all previously hidden fields (except our three custom fields holding bit arrays)
  427.  
  428.  
  429.             // add checkboxes to the categories
  430.             minor_categories.each(function () {
  431.                 add_checkbox(this);
  432.             });
  433.             major_categories.each(function () {
  434.                 add_checkbox(this);
  435.             })
  436.             jQuery('input.hide_show_checkbox').css({
  437.                                                        'position': 'absolute',
  438.                                                        'right': '-18px'
  439.                                                    });
  440.  
  441.             // add label for minor checkboxes
  442.             jQuery('div.popup-cc-L2 > h3:first-of-type').append('<span class="' + class_edit_mode + ' minor_hide_show_label">Hide</span>');
  443.             jQuery('span.minor_hide_show_label').css({
  444.                                                          'position': 'absolute',
  445.                                                          'right': '64px',
  446.                                                          'top': '3px',
  447.                                                          'font-size': '13px',
  448.                                                          'font-weight': 'bold'
  449.                                                      });
  450.  
  451.  
  452.             // add label for major categories
  453.             jQuery('#pop-categories-form fieldset').prepend('<span class="' + class_edit_mode + ' major_hide_show_label">Hide</span>');
  454.             jQuery('span.major_hide_show_label').css({
  455.                                                          'position': 'absolute',
  456.                                                          'left': '267px',
  457.                                                          'font-size': '13px',
  458.                                                          'font-weight': 'bold'
  459.                                                      });
  460.             // add checkbox event. when checked add the 'hidden' class (which is scanned on save)
  461.             jQuery('input.hide_show_checkbox').click(function () {
  462.                 var parent_id = jQuery(this).parent().attr('id').replace(/\D/g, '');
  463.                 if (jQuery(this).is(':checked')) {
  464.                     jQuery('#menu-category-' + parent_id).addClass(class_hidden);
  465.                     jQuery('#pop-categories-' + parent_id).addClass(class_hidden);
  466.                     jQuery(this).parent().css('text-decoration', 'line-through');
  467.                 } else {
  468.                     jQuery('#menu-category-' + parent_id).removeClass(class_hidden);
  469.                     jQuery('#pop-categories-' + parent_id).removeClass(class_hidden);
  470.                     ;
  471.                     jQuery(this).parent().css('text-decoration', '');
  472.  
  473.                 }
  474.             });
  475.             hide_show_category(hs_action_edit);
  476.         } else {
  477.             // no longer editing (saving), so remove our labels and checkboxes, and re-hide the desired categories
  478.             jQuery('.' + class_edit_mode).remove();
  479.             hide_show_category(hs_action_hide);
  480.         }
  481.     }
  482.  
  483.     function add_checkbox(element) {
  484.         var checked = '';
  485.         if (jQuery(element).hasClass(class_hidden)) {
  486.             // hidden categories are checked
  487.             checked = 'checked="checked"';
  488.         }
  489.         jQuery(element).append('<input type="checkbox" class="' + class_edit_mode + ' hide_show_checkbox"' + checked + ' />');
  490.     }
  491.  
  492.     /**
  493.      * hooks to the save or cancel button so that hidden categories will be re-hidden after ajax refresh
  494.      */
  495.     function add_save_hook() {
  496.         if ((jQuery('#pop-categories-submit').length && (!(jQuery('#pop-categories-submit').hasClass('sgs-hook-added'))))) {
  497.  
  498.             jQuery('#pop-categories-submit').addClass('sgs-hook-added');
  499.             jQuery('#pop-categories-submit, #pop-categories-close').click(function () {
  500.                 mint_refresh();
  501.             });
  502.         }
  503.     }
  504.  
  505.     /**
  506.      * Hides our bit array custom categories permanently so the user won't accidentally mess with them.
  507.      */
  508.     function hide_bit_array() {
  509.         jQuery('input[value^="#!"]').parent().hide();
  510.         jQuery('li[id^="menu-category-"] a:contains("#!")').parent().hide();
  511.         jQuery('li[id^="menu-category-"] a:contains("#!")').each(function( index ) {
  512.             // use the new css global stylesheet function to hide the element as well.
  513.             css_hide_element("#" + jQuery(this).parent().attr('id'));
  514.         });
  515.     }
  516.  
  517.     /**
  518.      * Allows immutable strings to have character(s) replaced
  519.      * @param index
  520.      * @param character
  521.      * @returns {string}
  522.      */
  523.     String.prototype.replaceAt = function (index, character) {
  524.         return this.substr(0, index) + character + this.substr(index + character.length);
  525.     };
  526.  
  527.     /**
  528.      * Lets you bind an event and have it run first.
  529.      * @param name
  530.      * @param fn
  531.      */
  532.     jQuery.fn.bindFirst = function (name, fn) {
  533.         // bind as you normally would
  534.         // don't want to miss out on any jQuery magic
  535.         this.on(name, fn);
  536.  
  537.         // Thanks to a comment by @Martin, adding support for
  538.         // namespaced events too.
  539.         this.each(function () {
  540.             var handlers = jQuery._data(this, 'events')[name.split('.')[0]];
  541.             // take out the handler we just inserted from the end
  542.             var handler = handlers.pop();
  543.             // move it at the beginning
  544.             handlers.splice(0, 0, handler);
  545.         });
  546.     };
  547.  
  548.     function mint_refresh() {
  549.         add_toggle();
  550.         add_save_hook();
  551.         // when the popup is opened or closed, re-hide the categories
  552.         var str_bit_array_array = extract_mint_array();
  553.         var default_categories = get_default_category_list();
  554.         default_categories = decode_bit_array(str_bit_array_array, default_categories);
  555.         process_hidden_categories(default_categories); // hides the appropriate fields
  556.  
  557.         //Hides our three fields, since the user probably shouldn't mess with them directly (and they look weird).
  558.         hide_bit_array(); // comment this out in order to see the bit string data
  559.     }
  560.  
  561.     /**
  562.      * Saves the preferences
  563.      */
  564.     function mint_save() {
  565.         //console.debug('saving');
  566.         var default_categories = get_default_category_list();
  567.         var bit_array_array = encode_bit_array(default_categories);
  568.         for (var i = 0; i < bit_array_array.length; i++) {
  569.             clean_up_extra_fields(bit_array_array[i]); // delete any extra preference fields my older script created
  570.             upsert_field(bit_array_array[i]);
  571.         }
  572.     }
  573.     
  574.     function add_dropdown_hook() {
  575.         //console.log('start dropdown');
  576.         //if ((jQuery('#txnEdit-category_input').length) && (!(jQuery('#txtEdit-category_input').hasClass('sgs-hook-added')))) {
  577.         jQuery('#txnEdit-category_input').addClass('sgs-hook-added');
  578.         jQuery('#txnEdit-category_input, #txnEdit-category_picker').off('click', mint_refresh);
  579.         jQuery('#txnEdit-category_input, #txnEdit-category_picker').on('click', mint_refresh);
  580.         //}
  581.     }
  582.     
  583.     /**
  584.      * A bonus feature of this script: Fixes Mint's google search query.
  585.      * (If a transaction description contains a space, quote or other URI character, 
  586.      * mint.com doesn't encode it, which causes the google search link to be invalid.)
  587.      */
  588.     function google_search_fix(){
  589.         jQuery('#txnEdit-toggle').on('click', function(){
  590.             // get the text; don't try decoding the partial original search link
  591.             plain_search = jQuery('a.desc_link strong var').text();
  592.  
  593.             // proper encoding
  594.             new_search = encodeURIComponent(plain_search);
  595.  
  596.             // encoding changes spaces to %20, but that is deprecated now. urls take '+' instead.
  597.             new_search = new_search.replace(/%20/gi, '+');
  598.  
  599.             // replace old url with new
  600.             jQuery('a.desc_link').attr('href', 'https://www.google.com/#q=' + new_search);
  601.         });
  602.     }
  603.     
  604.     /**
  605.      * Function to add a global css style to a page.
  606.      * https://davidwalsh.name/add-rules-stylesheets
  607.      * This function is called once, at the top of the code, storing
  608.      * the new stylesheet reference in a script-global variable.
  609.      */
  610.     function create_style_sheet(){
  611.         // Create the <style> tag
  612.         var style = document.createElement("style");
  613.  
  614.         // Add a media (and/or media query) here if you'd like!
  615.         // style.setAttribute("media", "screen")
  616.         // style.setAttribute("media", "only screen and (max-width : 1024px)")
  617.  
  618.         // WebKit hack :(
  619.         style.appendChild(document.createTextNode(""));
  620.  
  621.         // Add the <style> element to the page
  622.         document.head.appendChild(style);
  623.  
  624.         return style.sheet;   
  625.     }
  626.     
  627.     // Cross compatible function to insert a rule. Index is optional.
  628.     function _addCSSRule(sheet, selector, rules, index) {
  629.  
  630.         if("insertRule" in sheet) {
  631.             sheet.insertRule(selector + "{" + rules + "}", index);
  632.         }
  633.         else if("addRule" in sheet) {
  634.             sheet.addRule(selector, rules, index);
  635.         }
  636.  
  637.     }
  638.     
  639.     /*
  640.      * This is the actual function called to hide an element via its id.
  641.      */
  642.     function addSGSStyle(css_selector, css_rule) {
  643.         _addCSSRule(sgs_style_sheet, css_selector, css_rule);
  644.     }
  645.     
  646.     /*
  647.      * Rather than removing specific rules, we just wipe the entire sheet out.
  648.      * Afterwards, the rules are recreated to fit the new preferences.
  649.      */
  650.     function clearSGSStyle() {
  651.  
  652.         while (sgs_style_sheet.cssRules.length > 0){
  653.  
  654.             sgs_style_sheet.deleteRule(0);
  655.         }
  656.     }
  657.     
  658.     ////// Start jQuery Addon - 660-1123
  659.     if (!(jQuery.fn.arrive)){
  660.         /*globals jQuery,Window,HTMLElement,HTMLDocument,HTMLCollection,NodeList,MutationObserver */
  661.         /*exported Arrive*/
  662.         /*jshint latedef:false */
  663.  
  664.         /*
  665.          * arrive.js
  666.          * v2.4.1
  667.          * https://github.com/uzairfarooq/arrive
  668.          * MIT licensed
  669.          *
  670.          * Copyright (c) 2014-2017 Uzair Farooq
  671.          */
  672.         var Arrive = (function(window, $, undefined) {
  673.  
  674.             "use strict";
  675.  
  676.             if(!window.MutationObserver || typeof HTMLElement === 'undefined'){
  677.                 return; //for unsupported browsers
  678.             }
  679.  
  680.             var arriveUniqueId = 0;
  681.  
  682.             var utils = (function() {
  683.                 var matches = HTMLElement.prototype.matches || HTMLElement.prototype.webkitMatchesSelector || HTMLElement.prototype.mozMatchesSelector
  684.                     || HTMLElement.prototype.msMatchesSelector;
  685.  
  686.                 return {
  687.                     matchesSelector: function(elem, selector) {
  688.                         return elem instanceof HTMLElement && matches.call(elem, selector);
  689.                     },
  690.                     // to enable function overloading - By John Resig (MIT Licensed)
  691.                     addMethod: function (object, name, fn) {
  692.                         var old = object[ name ];
  693.                         object[ name ] = function(){
  694.                             if ( fn.length == arguments.length ) {
  695.                                 return fn.apply( this, arguments );
  696.                             }
  697.                             else if ( typeof old == 'function' ) {
  698.                                 return old.apply( this, arguments );
  699.                             }
  700.                         };
  701.                     },
  702.                     callCallbacks: function(callbacksToBeCalled, registrationData) {
  703.                         if (registrationData && registrationData.options.onceOnly && registrationData.firedElems.length == 1) {
  704.                             // as onlyOnce param is true, make sure we fire the event for only one item
  705.                             callbacksToBeCalled = [callbacksToBeCalled[0]];
  706.                         }
  707.  
  708.                         for (var i = 0, cb; (cb = callbacksToBeCalled[i]); i++) {
  709.                             if (cb && cb.callback) {
  710.                                 cb.callback.call(cb.elem, cb.elem);
  711.                             }
  712.                         }
  713.  
  714.                         if (registrationData && registrationData.options.onceOnly && registrationData.firedElems.length == 1) {
  715.                             // unbind event after first callback as onceOnly is true.
  716.                             registrationData.me.unbindEventWithSelectorAndCallback.call(
  717.                                 registrationData.target, registrationData.selector, registrationData.callback);
  718.                         }
  719.                     },
  720.                     // traverse through all descendants of a node to check if event should be fired for any descendant
  721.                     checkChildNodesRecursively: function(nodes, registrationData, matchFunc, callbacksToBeCalled) {
  722.                         // check each new node if it matches the selector
  723.                         for (var i=0, node; (node = nodes[i]); i++) {
  724.                             if (matchFunc(node, registrationData, callbacksToBeCalled)) {
  725.                                 callbacksToBeCalled.push({ callback: registrationData.callback, elem: node });
  726.                             }
  727.  
  728.                             if (node.childNodes.length > 0) {
  729.                                 utils.checkChildNodesRecursively(node.childNodes, registrationData, matchFunc, callbacksToBeCalled);
  730.                             }
  731.                         }
  732.                     },
  733.                     mergeArrays: function(firstArr, secondArr){
  734.                         // Overwrites default options with user-defined options.
  735.                         var options = {},
  736.                             attrName;
  737.                         for (attrName in firstArr) {
  738.                             if (firstArr.hasOwnProperty(attrName)) {
  739.                                 options[attrName] = firstArr[attrName];
  740.                             }
  741.                         }
  742.                         for (attrName in secondArr) {
  743.                             if (secondArr.hasOwnProperty(attrName)) {
  744.                                 options[attrName] = secondArr[attrName];
  745.                             }
  746.                         }
  747.                         return options;
  748.                     },
  749.                     toElementsArray: function (elements) {
  750.                         // check if object is an array (or array like object)
  751.                         // Note: window object has .length property but it's not array of elements so don't consider it an array
  752.                         if (typeof elements !== "undefined" && (typeof elements.length !== "number" || elements === window)) {
  753.                             elements = [elements];
  754.                         }
  755.                         return elements;
  756.                     }
  757.                 };
  758.             })();
  759.  
  760.  
  761.             // Class to maintain state of all registered events of a single type
  762.             var EventsBucket = (function() {
  763.                 var EventsBucket = function() {
  764.                     // holds all the events
  765.  
  766.                     this._eventsBucket    = [];
  767.                     // function to be called while adding an event, the function should do the event initialization/registration
  768.                     this._beforeAdding    = null;
  769.                     // function to be called while removing an event, the function should do the event destruction
  770.                     this._beforeRemoving  = null;
  771.                 };
  772.  
  773.                 EventsBucket.prototype.addEvent = function(target, selector, options, callback) {
  774.                     var newEvent = {
  775.                         target:             target,
  776.                         selector:           selector,
  777.                         options:            options,
  778.                         callback:           callback,
  779.                         firedElems:         []
  780.                     };
  781.  
  782.                     if (this._beforeAdding) {
  783.                         this._beforeAdding(newEvent);
  784.                     }
  785.  
  786.                     this._eventsBucket.push(newEvent);
  787.                     return newEvent;
  788.                 };
  789.  
  790.                 EventsBucket.prototype.removeEvent = function(compareFunction) {
  791.                     for (var i=this._eventsBucket.length - 1, registeredEvent; (registeredEvent = this._eventsBucket[i]); i--) {
  792.                         if (compareFunction(registeredEvent)) {
  793.                             if (this._beforeRemoving) {
  794.                                 this._beforeRemoving(registeredEvent);
  795.                             }
  796.  
  797.                             // mark callback as null so that even if an event mutation was already triggered it does not call callback
  798.                             var removedEvents = this._eventsBucket.splice(i, 1);
  799.                             if (removedEvents && removedEvents.length) {
  800.                                 removedEvents[0].callback = null;
  801.                             }
  802.                         }
  803.                     }
  804.                 };
  805.  
  806.                 EventsBucket.prototype.beforeAdding = function(beforeAdding) {
  807.                     this._beforeAdding = beforeAdding;
  808.                 };
  809.  
  810.                 EventsBucket.prototype.beforeRemoving = function(beforeRemoving) {
  811.                     this._beforeRemoving = beforeRemoving;
  812.                 };
  813.  
  814.                 return EventsBucket;
  815.             })();
  816.  
  817.  
  818.             /**
  819.              * @constructor
  820.              * General class for binding/unbinding arrive and leave events
  821.              */
  822.             var MutationEvents = function(getObserverConfig, onMutation) {
  823.                 var eventsBucket    = new EventsBucket(),
  824.                     me              = this;
  825.  
  826.                 var defaultOptions = {
  827.                     fireOnAttributesModification: false
  828.                 };
  829.  
  830.                 // actual event registration before adding it to bucket
  831.                 eventsBucket.beforeAdding(function(registrationData) {
  832.                     var
  833.                         target    = registrationData.target,
  834.                         observer;
  835.  
  836.                     // mutation observer does not work on window or document
  837.                     if (target === window.document || target === window) {
  838.                         target = document.getElementsByTagName("html")[0];
  839.                     }
  840.  
  841.                     // Create an observer instance
  842.                     observer = new MutationObserver(function(e) {
  843.                         onMutation.call(this, e, registrationData);
  844.                     });
  845.  
  846.                     var config = getObserverConfig(registrationData.options);
  847.  
  848.                     observer.observe(target, config);
  849.  
  850.                     registrationData.observer = observer;
  851.                     registrationData.me = me;
  852.                 });
  853.  
  854.                 // cleanup/unregister before removing an event
  855.                 eventsBucket.beforeRemoving(function (eventData) {
  856.                     eventData.observer.disconnect();
  857.                 });
  858.  
  859.                 this.bindEvent = function(selector, options, callback) {
  860.                     options = utils.mergeArrays(defaultOptions, options);
  861.  
  862.                     var elements = utils.toElementsArray(this);
  863.  
  864.                     for (var i = 0; i < elements.length; i++) {
  865.                         eventsBucket.addEvent(elements[i], selector, options, callback);
  866.                     }
  867.                 };
  868.  
  869.                 this.unbindEvent = function() {
  870.                     var elements = utils.toElementsArray(this);
  871.                     eventsBucket.removeEvent(function(eventObj) {
  872.                         for (var i = 0; i < elements.length; i++) {
  873.                             if (this === undefined || eventObj.target === elements[i]) {
  874.                                 return true;
  875.                             }
  876.                         }
  877.                         return false;
  878.                     });
  879.                 };
  880.  
  881.                 this.unbindEventWithSelectorOrCallback = function(selector) {
  882.                     var elements = utils.toElementsArray(this),
  883.                         callback = selector,
  884.                         compareFunction;
  885.  
  886.                     if (typeof selector === "function") {
  887.                         compareFunction = function(eventObj) {
  888.                             for (var i = 0; i < elements.length; i++) {
  889.                                 if ((this === undefined || eventObj.target === elements[i]) && eventObj.callback === callback) {
  890.                                     return true;
  891.                                 }
  892.                             }
  893.                             return false;
  894.                         };
  895.                     }
  896.                     else {
  897.                         compareFunction = function(eventObj) {
  898.                             for (var i = 0; i < elements.length; i++) {
  899.                                 if ((this === undefined || eventObj.target === elements[i]) && eventObj.selector === selector) {
  900.                                     return true;
  901.                                 }
  902.                             }
  903.                             return false;
  904.                         };
  905.                     }
  906.                     eventsBucket.removeEvent(compareFunction);
  907.                 };
  908.  
  909.                 this.unbindEventWithSelectorAndCallback = function(selector, callback) {
  910.                     var elements = utils.toElementsArray(this);
  911.                     eventsBucket.removeEvent(function(eventObj) {
  912.                         for (var i = 0; i < elements.length; i++) {
  913.                             if ((this === undefined || eventObj.target === elements[i]) && eventObj.selector === selector && eventObj.callback === callback) {
  914.                                 return true;
  915.                             }
  916.                         }
  917.                         return false;
  918.                     });
  919.                 };
  920.  
  921.                 return this;
  922.             };
  923.  
  924.  
  925.             /**
  926.              * @constructor
  927.              * Processes 'arrive' events
  928.              */
  929.             var ArriveEvents = function() {
  930.                 // Default options for 'arrive' event
  931.                 var arriveDefaultOptions = {
  932.                     fireOnAttributesModification: false,
  933.                     onceOnly: false,
  934.                     existing: false
  935.                 };
  936.  
  937.                 function getArriveObserverConfig(options) {
  938.                     var config = {
  939.                         attributes: false,
  940.                         childList: true,
  941.                         subtree: true
  942.                     };
  943.  
  944.                     if (options.fireOnAttributesModification) {
  945.                         config.attributes = true;
  946.                     }
  947.  
  948.                     return config;
  949.                 }
  950.  
  951.                 function onArriveMutation(mutations, registrationData) {
  952.                     mutations.forEach(function( mutation ) {
  953.                         var newNodes    = mutation.addedNodes,
  954.                             targetNode = mutation.target,
  955.                             callbacksToBeCalled = [],
  956.                             node;
  957.  
  958.                         // If new nodes are added
  959.                         if( newNodes !== null && newNodes.length > 0 ) {
  960.                             utils.checkChildNodesRecursively(newNodes, registrationData, nodeMatchFunc, callbacksToBeCalled);
  961.                         }
  962.                         else if (mutation.type === "attributes") {
  963.                             if (nodeMatchFunc(targetNode, registrationData, callbacksToBeCalled)) {
  964.                                 callbacksToBeCalled.push({ callback: registrationData.callback, elem: targetNode });
  965.                             }
  966.                         }
  967.  
  968.                         utils.callCallbacks(callbacksToBeCalled, registrationData);
  969.                     });
  970.                 }
  971.  
  972.                 function nodeMatchFunc(node, registrationData, callbacksToBeCalled) {
  973.                     // check a single node to see if it matches the selector
  974.                     if (utils.matchesSelector(node, registrationData.selector)) {
  975.                         if(node._id === undefined) {
  976.                             node._id = arriveUniqueId++;
  977.                         }
  978.                         // make sure the arrive event is not already fired for the element
  979.                         if (registrationData.firedElems.indexOf(node._id) == -1) {
  980.                             registrationData.firedElems.push(node._id);
  981.  
  982.                             return true;
  983.                         }
  984.                     }
  985.  
  986.                     return false;
  987.                 }
  988.  
  989.                 arriveEvents = new MutationEvents(getArriveObserverConfig, onArriveMutation);
  990.  
  991.                 var mutationBindEvent = arriveEvents.bindEvent;
  992.  
  993.                 // override bindEvent function
  994.                 arriveEvents.bindEvent = function(selector, options, callback) {
  995.  
  996.                     if (typeof callback === "undefined") {
  997.                         callback = options;
  998.                         options = arriveDefaultOptions;
  999.                     } else {
  1000.                         options = utils.mergeArrays(arriveDefaultOptions, options);
  1001.                     }
  1002.  
  1003.                     var elements = utils.toElementsArray(this);
  1004.  
  1005.                     if (options.existing) {
  1006.                         var existing = [];
  1007.  
  1008.                         for (var i = 0; i < elements.length; i++) {
  1009.                             var nodes = elements[i].querySelectorAll(selector);
  1010.                             for (var j = 0; j < nodes.length; j++) {
  1011.                                 existing.push({ callback: callback, elem: nodes[j] });
  1012.                             }
  1013.                         }
  1014.  
  1015.                         // no need to bind event if the callback has to be fired only once and we have already found the element
  1016.                         if (options.onceOnly && existing.length) {
  1017.                             return callback.call(existing[0].elem, existing[0].elem);
  1018.                         }
  1019.  
  1020.                         setTimeout(utils.callCallbacks, 1, existing);
  1021.                     }
  1022.  
  1023.                     mutationBindEvent.call(this, selector, options, callback);
  1024.                 };
  1025.  
  1026.                 return arriveEvents;
  1027.             };
  1028.  
  1029.  
  1030.             /**
  1031.              * @constructor
  1032.              * Processes 'leave' events
  1033.              */
  1034.             var LeaveEvents = function() {
  1035.                 // Default options for 'leave' event
  1036.                 var leaveDefaultOptions = {};
  1037.  
  1038.                 function getLeaveObserverConfig() {
  1039.                     var config = {
  1040.                         childList: true,
  1041.                         subtree: true
  1042.                     };
  1043.  
  1044.                     return config;
  1045.                 }
  1046.  
  1047.                 function onLeaveMutation(mutations, registrationData) {
  1048.                     mutations.forEach(function( mutation ) {
  1049.                         var removedNodes  = mutation.removedNodes,
  1050.                             callbacksToBeCalled = [];
  1051.  
  1052.                         if( removedNodes !== null && removedNodes.length > 0 ) {
  1053.                             utils.checkChildNodesRecursively(removedNodes, registrationData, nodeMatchFunc, callbacksToBeCalled);
  1054.                         }
  1055.  
  1056.                         utils.callCallbacks(callbacksToBeCalled, registrationData);
  1057.                     });
  1058.                 }
  1059.  
  1060.                 function nodeMatchFunc(node, registrationData) {
  1061.                     return utils.matchesSelector(node, registrationData.selector);
  1062.                 }
  1063.  
  1064.                 leaveEvents = new MutationEvents(getLeaveObserverConfig, onLeaveMutation);
  1065.  
  1066.                 var mutationBindEvent = leaveEvents.bindEvent;
  1067.  
  1068.                 // override bindEvent function
  1069.                 leaveEvents.bindEvent = function(selector, options, callback) {
  1070.  
  1071.                     if (typeof callback === "undefined") {
  1072.                         callback = options;
  1073.                         options = leaveDefaultOptions;
  1074.                     } else {
  1075.                         options = utils.mergeArrays(leaveDefaultOptions, options);
  1076.                     }
  1077.  
  1078.                     mutationBindEvent.call(this, selector, options, callback);
  1079.                 };
  1080.  
  1081.                 return leaveEvents;
  1082.             };
  1083.  
  1084.  
  1085.             var arriveEvents = new ArriveEvents(),
  1086.                 leaveEvents  = new LeaveEvents();
  1087.  
  1088.             function exposeUnbindApi(eventObj, exposeTo, funcName) {
  1089.                 // expose unbind function with function overriding
  1090.                 utils.addMethod(exposeTo, funcName, eventObj.unbindEvent);
  1091.                 utils.addMethod(exposeTo, funcName, eventObj.unbindEventWithSelectorOrCallback);
  1092.                 utils.addMethod(exposeTo, funcName, eventObj.unbindEventWithSelectorAndCallback);
  1093.             }
  1094.  
  1095.             /*** expose APIs ***/
  1096.             function exposeApi(exposeTo) {
  1097.                 exposeTo.arrive = arriveEvents.bindEvent;
  1098.                 exposeUnbindApi(arriveEvents, exposeTo, "unbindArrive");
  1099.  
  1100.                 exposeTo.leave = leaveEvents.bindEvent;
  1101.                 exposeUnbindApi(leaveEvents, exposeTo, "unbindLeave");
  1102.             }
  1103.  
  1104.             if ($) {
  1105.                 exposeApi($.fn);
  1106.             }
  1107.             exposeApi(HTMLElement.prototype);
  1108.             exposeApi(NodeList.prototype);
  1109.             exposeApi(HTMLCollection.prototype);
  1110.             exposeApi(HTMLDocument.prototype);
  1111.             exposeApi(Window.prototype);
  1112.  
  1113.             var Arrive = {};
  1114.             // expose functions to unbind all arrive/leave events
  1115.             exposeUnbindApi(arriveEvents, Arrive, "unbindAllArrive");
  1116.             exposeUnbindApi(leaveEvents, Arrive, "unbindAllLeave");
  1117.  
  1118.             return Arrive;
  1119.  
  1120.         })(window, typeof jQuery === 'undefined' ? null : jQuery, undefined);
  1121.     }
  1122.     ////// End jQuery Addon
  1123.     jQuery(document).arrive("#txnEdit-category_input", add_dropdown_hook);
  1124.     jQuery(document).arrive("#txnEdit-toggle", google_search_fix);
  1125.  
  1126. }
  1127.  
  1128.  
  1129. /**
  1130.  * Mint.com loads jquery after page is loaded, and it conflicts with other verions. We can't
  1131.  * use a sandbox for our script, either, since we must use their version of jquery in order
  1132.  * to hook into their ajax completion events.
  1133.  * Therefore, we must manually check for jquery every so often (50 ms) until it finally exists.
  1134.  * Then, we can call our jquery-requiring function and modify the page.
  1135.  * @param method
  1136.  */
  1137. function defer(method) {
  1138.     if (window.jQuery) {
  1139.         method();
  1140.     } else {
  1141.         setTimeout(function () {
  1142.             defer(method);
  1143.         }, 50);
  1144.     }
  1145. }
  1146. window.addEventListener('load', function () {
  1147.     defer(after_jquery);
  1148. });
  1149. }());
  1150.