☰

Basic Functions (For userscripts)

Useful functions for myself

Ce script ne doit pas être installé directement. C'est une librairie destinée à être incluse dans d'autres scripts avec la méta-directive // @require https://update.greatest.deepsurf.us/scripts/456034/1596651/Basic%20Functions%20%28For%20userscripts%29.js 

  1. // ==UserScript==
  2. // @name               Basic Functions (For userscripts)
  3. // @name:zh-CN         常用函数（用户脚本）
  4. // @name:en            Basic Functions (For userscripts)
  5. // @namespace          PY-DNG Userscripts
  6. // @version            1.9.3
  7. // @description        Useful functions for myself
  8. // @description:zh-CN  自用函数
  9. // @description:en     Useful functions for myself
  10. // @author             PY-DNG
  11. // @license            GPL-3.0-or-later
  12. // ==/UserScript==
  13.  
  14. /* eslint-disable no-multi-spaces */
  15. /* eslint-disable no-return-assign */
  16.  
  17. // Note: version 0.8.2.1 is modified just the license and it's not uploaded to GF yet 23-11-26 15:03
  18. // Note: version 0.8.3.1 is added just the description of parseArgs and has not uploaded to GF yet 24-02-03 18:55
  19.  
  20. let [
  21.     // Console & Debug
  22.     LogLevel, DoLog, Err, Assert,
  23.  
  24.     // DOM
  25.     $, $All, $CrE, $AEL, $$CrE, addStyle, detectDom, destroyEvent,
  26.  
  27.     // Data
  28.     copyProp, copyProps, parseArgs, escJsStr, replaceText,
  29.  
  30.     // Environment & Browser
  31.     getUrlArgv, dl_browser, dl_GM,
  32.  
  33.     // Logic & Task
  34.     AsyncManager, queueTask, FunctionLoader, loadFuncs, require, isLoaded
  35. ] = (function() {
  36.     const [LogLevel, DoLog] = (function() {
  37.         /**
  38.          * level defination for DoLog function, bigger ones has higher possibility to be printed in console
  39.          * @typedef {Object} LogLevel
  40.          * @property {0} None - 0
  41.          * @property {1} Error - 1
  42.          * @property {2} Success - 2
  43.          * @property {3} Warning - 3
  44.          * @property {4} Info - 4
  45.          */
  46.         /** @type {LogLevel} */
  47.         const LogLevel = {
  48.             None: 0,
  49.             Error: 1,
  50.             Success: 2,
  51.             Warning: 3,
  52.             Info: 4,
  53.         };
  54.  
  55.         return [LogLevel, DoLog];
  56.  
  57.         /**
  58.          * @overload
  59.          * @param {String} content - log content
  60.          */
  61.         /**
  62.          * @overload
  63.          * @param {Number} level - level specified in LogLevel object
  64.          * @param {String} content - log content
  65.          */
  66.         /**
  67.          * Logger with level and logger function specification
  68.          * @overload
  69.          * @param {Number} level - level specified in LogLevel object
  70.          * @param {String} content - log content
  71.          * @param {String} logger - which log function to use (in window.console[logger])
  72.          */
  73.         function DoLog() {
  74.             // Get window
  75.             const win = (typeof(unsafeWindow) === 'object' && unsafeWindow !== null) ? unsafeWindow : window;
  76.  
  77.             const LogLevelMap = {};
  78.             LogLevelMap[LogLevel.None] = {
  79.                 prefix: '',
  80.                 color: 'color:#ffffff'
  81.             }
  82.             LogLevelMap[LogLevel.Error] = {
  83.                 prefix: '[Error]',
  84.                 color: 'color:#ff0000'
  85.             }
  86.             LogLevelMap[LogLevel.Success] = {
  87.                 prefix: '[Success]',
  88.                 color: 'color:#00aa00'
  89.             }
  90.             LogLevelMap[LogLevel.Warning] = {
  91.                 prefix: '[Warning]',
  92.                 color: 'color:#ffa500'
  93.             }
  94.             LogLevelMap[LogLevel.Info] = {
  95.                 prefix: '[Info]',
  96.                 color: 'color:#888888'
  97.             }
  98.             LogLevelMap[LogLevel.Elements] = {
  99.                 prefix: '[Elements]',
  100.                 color: 'color:#000000'
  101.             }
  102.  
  103.             // Current log level
  104.             DoLog.logLevel = (win.isPY_DNG && win.userscriptDebugging) ? LogLevel.Info : LogLevel.Warning; // Info Warning Success Error
  105.  
  106.             // Log counter
  107.             DoLog.logCount === undefined && (DoLog.logCount = 0);
  108.  
  109.             // Get args
  110.             let [level, logContent, logger] = parseArgs([...arguments], [
  111.                 [2],
  112.                 [1,2],
  113.                 [1,2,3]
  114.             ], [LogLevel.Info, 'DoLog initialized.', 'log']);
  115.  
  116.             let msg = '%c' + LogLevelMap[level].prefix + (typeof GM_info === 'object' ? `[${GM_info.script.name}]` : '') + (LogLevelMap[level].prefix ? ' ' : '');
  117.             let subst = LogLevelMap[level].color;
  118.  
  119.             switch (typeof(logContent)) {
  120.                 case 'string':
  121.                     msg += '%s';
  122.                     break;
  123.                 case 'number':
  124.                     msg += '%d';
  125.                     break;
  126.                 default:
  127.                     msg += '%o';
  128.                     break;
  129.             }
  130.  
  131.             // Log when log level permits
  132.             if (level <= DoLog.logLevel) {
  133.                 // Log to console when log level permits
  134.                 if (level <= DoLog.logLevel) {
  135.                     if (++DoLog.logCount > 512) {
  136.                         console.clear();
  137.                         DoLog.logCount = 0;
  138.                     }
  139.                     console[logger](msg, subst, logContent);
  140.                 }
  141.             }
  142.         }
  143.     }) ();
  144.  
  145.     /**
  146.      * Throw an error
  147.      * @param {String} msg - the error message
  148.      * @param {typeof Error} [ErrorConstructor=Error] - which error constructor to use, defaulting to Error()
  149.      */
  150.     function Err(msg, ErrorConstructor=Error) {
  151.         throw new ErrorConstructor((typeof GM_info === 'object' ? `[${GM_info.script.name}]` : '') + msg);
  152.     }
  153.  
  154.     /**
  155.      * Assert given condition is true-like, otherwise throws given error
  156.      * @param {*} condition 
  157.      * @param {string} errmsg 
  158.      * @param {typeof Error} [ErrorConstructor=Error] 
  159.      */
  160.     function Assert(condition, errmsg, ErrorConstructor=Error) {
  161.         condition || Err(errmsg, ErrorConstructor);
  162.     }
  163.  
  164.     /**
  165.      * Convenient function to querySelector
  166.      * @overload
  167.      * @param {Element|Document|DocumentFragment} [root] - which target to call querySelector on
  168.      * @param {string} selector - querySelector selector
  169.      * @returns {Element|null}
  170.      */
  171.     function $() {
  172.         switch(arguments.length) {
  173.             case 2:
  174.                 return arguments[0].querySelector(arguments[1]);
  175.             default:
  176.                 return document.querySelector(arguments[0]);
  177.         }
  178.     }
  179.     /**
  180.      * Convenient function to querySelectorAll
  181.      * @overload
  182.      * @param {Element|Document|DocumentFragment} [root] - which target to call querySelectorAll on
  183.      * @param {string} selector - querySelectorAll selector
  184.      * @returns {NodeList}
  185.      */
  186.     function $All() {
  187.         switch(arguments.length) {
  188.             case 2:
  189.                 return arguments[0].querySelectorAll(arguments[1]);
  190.                 break;
  191.             default:
  192.                 return document.querySelectorAll(arguments[0]);
  193.         }
  194.     }
  195.     /**
  196.      * Convenient function to querySelectorAll
  197.      * @overload
  198.      * @param {Document} [root] - which document to call createElement on
  199.      * @param {string} tagName
  200.      * @returns {HTMLElement}
  201.      */
  202.     function $CrE() {
  203.         switch(arguments.length) {
  204.             case 2:
  205.                 return arguments[0].createElement(arguments[1]);
  206.                 break;
  207.             default:
  208.                 return document.createElement(arguments[0]);
  209.         }
  210.     }
  211.     /**
  212.      * Convenient function to addEventListener
  213.      * @overload
  214.      * @param {EventTarget} target - which target to call addEventListener on
  215.      * @param {string} type
  216.      * @param {EventListenerOrEventListenerObject | null} callback
  217.      * @param {AddEventListenerOptions | boolean} [options]
  218.      */
  219.     function $AEL(...args) {
  220.         /** @type {EventTarget} */
  221.         const target = args.shift();
  222.         return target.addEventListener.apply(target, args);
  223.     }
  224.     /**
  225.      * @typedef {[type: string, callback: EventListenerOrEventListenerObject | null, options: AddEventListenerOptions | boolean]} $AEL_Arguments 
  226.      */
  227.     /**
  228.      * @typedef {Object} $$CrE_Options
  229.      * @property {string} tagName
  230.      * @property {object} [props] - properties set by `element[prop] = value;`
  231.      * @property {object} [attrs] - attributes set by `element.setAttribute(attr, value);`
  232.      * @property {string | string[]} [classes] - class names to be set
  233.      * @property {object} [styles] - styles set by `element[style_name] = style_value;`
  234.      * @property {$AEL_Arguments[]} [listeners] - event listeners added by `$AEL(element, ...listener);`
  235.      */
  236.     /**
  237.      * @overload
  238.      * @param {$$CrE_Options} options
  239.      * @returns {HTMLElement}
  240.      */
  241.     /**
  242.      * Create configorated element
  243.      * @overload
  244.      * @param {string} tagName
  245.      * @param {object} [props] - properties set by `element[prop] = value;`
  246.      * @param {object} [attrs] - attributes set by `element.setAttribute(attr, value);`
  247.      * @param {string | string[]} [classes] - class names to be set
  248.      * @param {object} [styles] - styles set by `element[style_name] = style_value;`
  249.      * @param {$AEL_Arguments[]} [listeners] - event listeners added by `$AEL(element, ...listener);`
  250.      * @returns {HTMLElement}
  251.      */
  252.     function $$CrE() {
  253.         const [tagName, props, attrs, classes, styles, listeners] = parseArgs([...arguments], [
  254.             function(args, defaultValues) {
  255.                 const arg = args[0];
  256.                 return {
  257.                     'string': () => [arg, ...defaultValues.filter((arg, i) => i > 0)],
  258.                     'object': () => ['tagName', 'props', 'attrs', 'classes', 'styles', 'listeners'].map((prop, i) => arg.hasOwnProperty(prop) ? arg[prop] : defaultValues[i])
  259.                 }[typeof arg]();
  260.             },
  261.             [1,2],
  262.             [1,2,3],
  263.             [1,2,3,4],
  264.             [1,2,3,4,5]
  265.         ], ['div', {}, {}, [], {}, []]);
  266.         const elm = $CrE(tagName);
  267.         for (const [name, val] of Object.entries(props)) {
  268.             elm[name] = val;
  269.         }
  270.         for (const [name, val] of Object.entries(attrs)) {
  271.             elm.setAttribute(name, val);
  272.         }
  273.         for (const cls of Array.isArray(classes) ? classes : [classes]) {
  274.             elm.classList.add(cls);
  275.         }
  276.         for (const [name, val] of Object.entries(styles)) {
  277.             elm.style[name] = val;
  278.         }
  279.         for (const listener of listeners) {
  280.             $AEL(elm, ...listener);
  281.         }
  282.         return elm;
  283.     }
  284.  
  285.     /**
  286.      * @overload
  287.      * @param {string} css - css content
  288.      * @returns {HTMLStyleElement}
  289.      */
  290.     /**
  291.      * @overload
  292.      * @param {string} css - css content
  293.      * @param {string} id - `id` attribute for <style> element
  294.      * @returns {HTMLStyleElement}
  295.      */
  296.     /**
  297.      * Append a style text to document(<head>) with a <style> element \
  298.      * removes existing <style> elements with same id if id provided, so style updates can be done by using one same id
  299.      * 
  300.      * Uses `GM_addElement` if `GM_addElement` exists and param `id` not specified. (`GM_addElement` uses id attribute, so specifing id manually when using `GM_addElement` takes no effect) \
  301.      * In another case `GM_addStyle` instead of `GM_addElement` exists, and both `id` and `parentElement` not specified, `GM_addStyle` will be used. \
  302.      * `document.createElement('style')` will be used otherwise.
  303.      * @overload
  304.      * @param {HTMLElement} parentElement - parent element to place <style> element
  305.      * @param {string} css - css content
  306.      * @param {string} id - `id` attribute for <style> element
  307.      * @returns {HTMLStyleElement}
  308.      */
  309.     function addStyle() {
  310.         // Get arguments
  311.         const [parentElement, css, id] = parseArgs([...arguments], [
  312.             [2],
  313.             [2,3],
  314.             [1,2,3]
  315.         ], [null, '', null]);
  316.  
  317.         if (typeof GM_addElement === 'function' && id === null) {
  318.             return GM_addElement(parentElement, 'style', { textContent: css });
  319.         } else if (typeof GM_addStyle === 'function' && parentElement === null && id === null) {
  320.             return GM_addStyle(css);
  321.         } else {
  322.             // Make <style>
  323.             const style = $CrE('style');
  324.             style.innerHTML = css;
  325.             id !== null && (style.id = id);
  326.             id !== null && Array.from($All(`style#${id}`)).forEach(elm => elm.remove());
  327.  
  328.             // Append to parentElement
  329.             (parentElement ?? document.head).appendChild(style);
  330.             return style;
  331.         }
  332.     }
  333.  
  334.     /**
  335.      * @typedef {Object} detectDom_options
  336.      * @property {Node} root - root target to observe on
  337.      * @property {string | string[]} [selector] - selector(s) to observe for, be aware that in options object it is named selector, but is named selectors in param
  338.      * @property {boolean} [attributes] - whether to observe existing elements' attribute changes
  339.      * @property {function} [callback] - if provided, use callback instead of Promise when selector element found
  340.      */
  341.     /**
  342.      * @overload
  343.      * @param {string | string[]} selector - selector(s) to observe for, be aware that in options object it is named selector, but is named selectors in param
  344.      * @returns {Promise<HTMLElement>}
  345.      */
  346.     /**
  347.      * @overload
  348.      * @param {detectDom_options} options
  349.      * @returns {MutationObserver}
  350.      */
  351.     /**
  352.      * Get callback / resolve promise when specific dom/element appearce in document \
  353.      * uses MutationObserver for implementation \
  354.      * This behavior is different from versions that equals to or older than 0.8.4.2, so be careful when using it.
  355.      * @overload
  356.      * @param {Node} root - root target to observe on
  357.      * @param {string | string[]} [selectors] - selector(s) to observe for
  358.      * @param {boolean} [attributes] - whether to observe existing elements' attribute changes
  359.      * @param {function} [callback] - if provided, use callback instead of Promise when selector element found
  360.      * @returns {MutationObserver}
  361.      */
  362.     function detectDom() {
  363.         let [selectors, root, attributes, callback] = parseArgs([...arguments], [
  364.             function(args, defaultValues) {
  365.                 const arg = args[0];
  366.                 return {
  367.                     'string': () => [arg, ...defaultValues.filter((arg, i) => i > 0)],
  368.                     'object': () => ['selector', 'root', 'attributes', 'callback'].map((prop, i) => arg.hasOwnProperty(prop) ? arg[prop] : defaultValues[i])
  369.                 }[typeof arg]();
  370.             },
  371.             [2,1],
  372.             [2,1,3],
  373.             [2,1,3,4],
  374.         ], [[''], document, false, null]);
  375.         !Array.isArray(selectors) && (selectors = [selectors]);
  376.  
  377.         if (select(root, selectors)) {
  378.             for (const elm of selectAll(root, selectors)) {
  379.                 if (callback) {
  380.                     setTimeout(callback.bind(null, elm));
  381.                 } else {
  382.                     return Promise.resolve(elm);
  383.                 }
  384.             }
  385.         }
  386.  
  387.         const observer = new MutationObserver(mCallback);
  388.         observer.observe(root, {
  389.             childList: true,
  390.             subtree: true,
  391.             attributes,
  392.         });
  393.  
  394.         let isPromise = !callback;
  395.         return callback ? observer : new Promise((resolve, reject) => callback = resolve);
  396.  
  397.         function mCallback(mutationList, observer) {
  398.             const addedNodes = mutationList.reduce((an, mutation) => {
  399.                 switch (mutation.type) {
  400.                     case 'childList':
  401.                         an.push(...mutation.addedNodes);
  402.                         break;
  403.                     case 'attributes':
  404.                         an.push(mutation.target);
  405.                         break;
  406.                 }
  407.                 return an;
  408.             }, []);
  409.             const addedSelectorNodes = addedNodes.reduce((nodes, anode) => {
  410.                 if (anode.matches && match(anode, selectors)) {
  411.                     nodes.add(anode);
  412.                 }
  413.                 const childMatches = anode.querySelectorAll ? selectAll(anode, selectors) : [];
  414.                 for (const cm of childMatches) {
  415.                     nodes.add(cm);
  416.                 }
  417.                 return nodes;
  418.             }, new Set());
  419.             for (const node of addedSelectorNodes) {
  420.                 callback(node);
  421.                 isPromise && observer.disconnect();
  422.             }
  423.         }
  424.  
  425.         function selectAll(elm, selectors) {
  426.             !Array.isArray(selectors) && (selectors = [selectors]);
  427.             return selectors.map(selector => [...$All(elm, selector)]).reduce((all, arr) => {
  428.                 all.push(...arr);
  429.                 return all;
  430.             }, []);
  431.         }
  432.  
  433.         function select(elm, selectors) {
  434.             const all = selectAll(elm, selectors);
  435.             return all.length ? all[0] : null;
  436.         }
  437.  
  438.         function match(elm, selectors) {
  439.             return !!elm.matches && selectors.some(selector => elm.matches(selector));
  440.         }
  441.     }
  442.  
  443.     /**
  444.      * Just stopPropagation and preventDefault
  445.      * @param {Event} e
  446.      */
  447.     function destroyEvent(e) {
  448.         if (!e) {return false;};
  449.         if (!e instanceof Event) {return false;};
  450.         e.stopPropagation();
  451.         e.preventDefault();
  452.     }
  453.  
  454.     /**
  455.      * copy property value from obj1 to obj2 if exists
  456.      * @param {object} obj1
  457.      * @param {object} obj2
  458.      * @param {string|Symbol} prop
  459.      */
  460.     function copyProp(obj1, obj2, prop) {obj1.hasOwnProperty(prop) && (obj2[prop] = obj1[prop]);}
  461.     /**
  462.      * copy property values from obj1 to obj2 if exists
  463.      * @param {object} obj1 
  464.      * @param {object} obj2 
  465.      * @param {string|Symbol} [props] - properties to copy, copy all enumerable properties if not specified
  466.      */
  467.     function copyProps(obj1, obj2, props) {(props ?? Object.keys(obj1)).forEach((prop) => (copyProp(obj1, obj2, prop)));}
  468.  
  469.     /**
  470.      * Argument parser with sorting and defaultValue support \
  471.      * See use cases in other functions
  472.      * @param {Array} args - original arguments' value to be parsed 
  473.      * @param {(number[]|function)[]} rules - rules to sort arguments or custom function to parse arguments
  474.      * @param {Array} defaultValues - default values for arguments not provided a value
  475.      * @returns {Array}
  476.      */
  477.     function parseArgs(args, rules, defaultValues=[]) {
  478.         // args and rules should be array, but not just iterable (string is also iterable)
  479.         if (!Array.isArray(args) || !Array.isArray(rules)) {
  480.             throw new TypeError('parseArgs: args and rules should be array')
  481.         }
  482.  
  483.         // fill rules[0]
  484.         (!Array.isArray(rules[0]) || rules[0].length === 1) && rules.splice(0, 0, []);
  485.  
  486.         // max arguments length
  487.         const count = rules.length - 1;
  488.  
  489.         // args.length must <= count
  490.         if (args.length > count) {
  491.             throw new TypeError(`parseArgs: args has more elements(${args.length}) longer than ruless'(${count})`);
  492.         }
  493.  
  494.         // rules[i].length should be === i if rules[i] is an array, otherwise it should be a function
  495.         for (let i = 1; i <= count; i++) {
  496.             const rule = rules[i];
  497.             if (Array.isArray(rule)) {
  498.                 if (rule.length !== i) {
  499.                     throw new TypeError(`parseArgs: rules[${i}](${rule}) should have ${i} numbers, but given ${rules[i].length}`);
  500.                 }
  501.                 if (!rule.every((num) => (typeof num === 'number' && num <= count))) {
  502.                     throw new TypeError(`parseArgs: rules[${i}](${rule}) should contain numbers smaller than count(${count}) only`);
  503.                 }
  504.             } else if (typeof rule !== 'function') {
  505.                 throw new TypeError(`parseArgs: rules[${i}](${rule}) should be an array or a function.`)
  506.             }
  507.         }
  508.  
  509.         // Parse
  510.         const rule = rules[args.length];
  511.         let parsed;
  512.         if (Array.isArray(rule)) {
  513.             parsed = [...defaultValues];
  514.             for (let i = 0; i < rule.length; i++) {
  515.                 parsed[rule[i]-1] = args[i];
  516.             }
  517.         } else {
  518.             parsed = rule(args, defaultValues);
  519.         }
  520.         return parsed;
  521.     }
  522.  
  523.     /**
  524.      * escape str into javascript written format
  525.      * @param {string} str
  526.      * @param {string} [quote] 
  527.      * @returns 
  528.      */
  529.     function escJsStr(str, quote='"') {
  530.         str = str.replaceAll('\\', '\\\\').replaceAll(quote, '\\' + quote).replaceAll('\t', '\\t');
  531.         str = quote === '`' ? str.replaceAll(/(\$\{[^\}]*\})/g, '\\$1') : str.replaceAll('\r', '\\r').replaceAll('\n', '\\n');
  532.         return quote + str + quote;
  533.     }
  534.     
  535.     /**
  536.      * Replace given text with no mismatching of replacing replaced text
  537.      * 
  538.      * e.g. replaceText('aaaabbbbccccdddd', {'a': 'b', 'b': 'c', 'c': 'd', 'd': 'e'}) === 'bbbbccccddddeeee' \
  539.      *      replaceText('abcdAABBAA', {'BB': 'AA', 'AAAAAA': 'This is a trap!'}) === 'abcdAAAAAA' \
  540.      *      replaceText('abcd{AAAA}BB}', {'{AAAA}': '{BB', '{BBBB}': 'This is a trap!'}) === 'abcd{BBBB}' \
  541.      *      replaceText('abcd', {}) === 'abcd'
  542.      * 
  543.      * **Note**: \
  544.      *  replaceText will replace in sort of replacer's iterating sort \
  545.      *  e.g. currently replaceText('abcdAABBAA', {'BBAA': 'TEXT', 'AABB': 'TEXT'}) === 'abcdAATEXT' \
  546.      *  but remember: (As MDN Web Doc said,) Although the keys of an ordinary Object are ordered now, this was \
  547.      *  not always the case, and the order is complex. As a result, it's best not to rely on property order. \
  548.      *  So, don't expect replaceText will treat replacer key-values in any specific sort. Use replaceText to \
  549.      *  replace irrelevance replacer keys only.
  550.      * @param {string} text 
  551.      * @param {object} replacer 
  552.      * @returns {string}
  553.      */
  554.     function replaceText(text, replacer) {
  555.         if (Object.entries(replacer).length === 0) {return text;}
  556.         const [models, targets] = Object.entries(replacer);
  557.         const len = models.length;
  558.         let text_arr = [{text: text, replacable: true}];
  559.         for (const [model, target] of Object.entries(replacer)) {
  560.             text_arr = replace(text_arr, model, target);
  561.         }
  562.         return text_arr.map((text_obj) => (text_obj.text)).join('');
  563.  
  564.         function replace(text_arr, model, target) {
  565.             const result_arr = [];
  566.             for (const text_obj of text_arr) {
  567.                 if (text_obj.replacable) {
  568.                     const splited = text_obj.text.split(model);
  569.                     for (const part of splited) {
  570.                         result_arr.push({text: part, replacable: true});
  571.                         result_arr.push({text: target, replacable: false});
  572.                     }
  573.                     result_arr.pop();
  574.                 } else {
  575.                     result_arr.push(text_obj);
  576.                 }
  577.             }
  578.             return result_arr;
  579.         }
  580.     }
  581.  
  582.     /**
  583.      * @typedef {Object} getUrlArgv_options
  584.      * @property {string} name
  585.      * @property {string} [url]
  586.      * @property {string} [defaultValue]
  587.      * @property {function} [dealFunc] - function that inputs original getUrlArgv result and outputs final return value
  588.      */
  589.     /**
  590.      * @overload
  591.      * @param {Object} getUrlArgv_options
  592.      * @returns 
  593.      */
  594.     /**
  595.      * Get a url argument from location.href
  596.      * @param {string} name
  597.      * @param {string} [url]
  598.      * @param {string} [defaultValue]
  599.      * @param {function} [dealFunc] - function that inputs original getUrlArgv result and outputs final return value
  600.      */
  601.     function getUrlArgv() {
  602.         const [name, url, defaultValue, dealFunc] = parseArgs([...arguments], [
  603.             function(args, defaultValues) {
  604.                 const arg = args[0];
  605.                 return {
  606.                     'string': () => [arg, ...defaultValues.filter((arg, i) => i > 0)],
  607.                     'object': () => ['name', 'url', 'defaultValue', 'dealFunc'].map((prop, i) => arg.hasOwnProperty(prop) ? arg[prop] : defaultValues[i])
  608.                 }[typeof arg]();
  609.             },
  610.             [2,1],
  611.             [2,1,3],
  612.             [2,1,3,4]
  613.         ], [null, location.href, null, a => a]);
  614.  
  615.         if (name === null) { return null; }
  616.  
  617.         const search = new URL(url).search;
  618.         const objSearch = new URLSearchParams(search);
  619.         const raw = objSearch.has(name) ? objSearch.get(name) : defaultValue;
  620.         const argv = dealFunc(raw);
  621.  
  622.         return argv;
  623.     }
  624.  
  625.     /**
  626.      * download file from given url by simulating <a download="..." href=""></a> clicks \
  627.      * a common use case is to download Blob objects as file from `URL.createObjectURL`
  628.      * @param {string} url 
  629.      * @param {string} filename 
  630.      */
  631.     function dl_browser(url, filename) {
  632.         const a = document.createElement('a');
  633.         a.href = url;
  634.         a.download = filename;
  635.         a.click();
  636.     }
  637.  
  638.     /**
  639.      * File download function \
  640.      * details looks like the detail of GM_xmlhttpRequest \
  641.      * onload function will be called after file saved to disk
  642.      * @param {object} details
  643.      */
  644.     function dl_GM(details) {
  645.         if (!details.url || !details.name) {return false;};
  646.  
  647.         // Configure request object
  648.         const requestObj = {
  649.             url: details.url,
  650.             responseType: 'blob',
  651.             onload: function(e) {
  652.                 // Save file
  653.                 dl_browser(URL.createObjectURL(e.response), details.name);
  654.  
  655.                 // onload callback
  656.                 details.onload ? details.onload(e) : function() {};
  657.             }
  658.         }
  659.         if (details.onloadstart       ) {requestObj.onloadstart        = details.onloadstart;};
  660.         if (details.onprogress        ) {requestObj.onprogress         = details.onprogress;};
  661.         if (details.onerror           ) {requestObj.onerror            = details.onerror;};
  662.         if (details.onabort           ) {requestObj.onabort            = details.onabort;};
  663.         if (details.onreadystatechange) {requestObj.onreadystatechange = details.onreadystatechange;};
  664.         if (details.ontimeout         ) {requestObj.ontimeout          = details.ontimeout;};
  665.  
  666.         // Send request
  667.         Assert(typeof GM_xmlhttpRequest === 'function', 'GM_xmlhttpRequest should be provided in order to use dl_GM', TypeError);
  668.         GM_xmlhttpRequest(requestObj);
  669.     }
  670.  
  671.     /**
  672.      * Manager to manager async tasks \
  673.      * This was written when I haven't learnt Promise, so for fluent promise users, just ignore it:)
  674.      * 
  675.      * # Usage
  676.      * ```javascript
  677.      * // This simulates a async task, it can be a XMLHttpRequest, some file reading, or so on...
  678.      * function someAsyncTask(callback, duration) {
  679.      *     const result = Math.random(); 
  680.      *     setTimeout(() => callback(result), duration);
  681.      * }
  682.      * 
  683.      * // Do 10 async tasks, and log all results when all async tasks finished
  684.      * const AM = new AsyncManager();
  685.      * const results = [];
  686.      * AM.onfinish = function() {
  687.      *     console.log('All tasks finished!');
  688.      *     console.log(results);
  689.      * }
  690.      * 
  691.      * for (let i = 0; i < 10; i++) {
  692.      *     AM.add();
  693.      *     const duration = (Math.random() * 5 + 5) * 1000;
  694.      *     const index = i;
  695.      *     someAsyncTask(result => {
  696.      *         console.log(`Task ${index} finished after ${duration}ms!`);
  697.      *         results[index] = result;
  698.      *     }, duration);
  699.      *     console.log(`Task ${index} started!`);
  700.      * }
  701.      * 
  702.      * // Set AM.finishEvent to true after all tasks added, allowing AsyncManager to call onfinish callback 
  703.      * ```
  704.      * @constructor
  705.      */
  706.     function AsyncManager() {
  707.         const AM = this;
  708.  
  709.         // Ongoing tasks count
  710.         this.taskCount = 0;
  711.  
  712.         // Whether generate finish events
  713.         let finishEvent = false;
  714.         Object.defineProperty(this, 'finishEvent', {
  715.             configurable: true,
  716.             enumerable: true,
  717.             get: () => (finishEvent),
  718.             set: (b) => {
  719.                 finishEvent = b;
  720.                 b && AM.taskCount === 0 && AM.onfinish && AM.onfinish();
  721.             }
  722.         });
  723.  
  724.         // Add one task
  725.         this.add = () => (++AM.taskCount);
  726.  
  727.         // Finish one task
  728.         this.finish = () => ((--AM.taskCount === 0 && AM.finishEvent && AM.onfinish && AM.onfinish(), AM.taskCount));
  729.     }
  730.  
  731.     /**
  732.      * Put tasks in specific queue and order their execution \
  733.      * Set `queueTask[queueId].max`, `queueTask[queueId].sleep` to custom queue's max ongoing tasks and sleep time between tasks
  734.      * @param {function} task - task function to run
  735.      * @param {string | Symbol} queueId - identifier to specify a target queue. if provided, given task will be added into specified queue. 
  736.      * @returns 
  737.      */
  738.     function queueTask(task, queueId='default') {
  739.         init();
  740.  
  741.         return new Promise((resolve, reject) => {
  742.             queueTask.hasOwnProperty(queueId) || (queueTask[queueId] = { tasks: [], ongoing: 0 });
  743.             queueTask[queueId].tasks.push({task, resolve, reject});
  744.             checkTask(queueId);
  745.         });
  746.  
  747.         function init() {
  748.             if (!queueTask[queueId]?.initialized) {
  749.                 queueTask[queueId] = {
  750.                     // defaults
  751.                     tasks: [],
  752.                     ongoing: 0,
  753.                     max: 3,
  754.                     sleep: 500,
  755.  
  756.                     // user's pre-sets
  757.                     ...(queueTask[queueId] || {}),
  758.  
  759.                     // initialized flag
  760.                     initialized: true
  761.                 }
  762.             };
  763.         }
  764.  
  765.         function checkTask() {
  766.             const queue = queueTask[queueId];
  767.             setTimeout(() => {
  768.                 if (queue.ongoing < queue.max && queue.tasks.length) {
  769.                     const task = queue.tasks.shift();
  770.                     queue.ongoing++;
  771.                     setTimeout(
  772.                         () => task.task().then(v => {
  773.                             queue.ongoing--;
  774.                             task.resolve(v);
  775.                             checkTask(queueId);
  776.                         }).catch(e => {
  777.                             queue.ongoing--;
  778.                             task.reject(e);
  779.                             checkTask(queueId);
  780.                         }),
  781.                         queue.sleep
  782.                     );
  783.                 }
  784.             });
  785.         }
  786.     }
  787.  
  788.     const [FunctionLoader, loadFuncs, require, isLoaded] = (function() {
  789.         /**
  790.          * 一般用作函数对象oFunc的加载条件，检测当前环境是否适合/需要该oFunc加载
  791.          * @typedef {Object} checker_func
  792.          * @property {string} type - checker's identifier
  793.          * @property {function} func - actual internal judgement implementation
  794.          */
  795.         /**
  796.          * 一般用作函数对象oFunc的加载条件，检测当前环境是否适合/需要该oFunc加载
  797.          * @typedef {Object} checker
  798.          * @property {string} type - checker's identifier
  799.          * @property {*} value - param that goes into checker function
  800.          */
  801.         /**
  802.          * 需要使用的substorage名称
  803.          * @typedef {"GM_setValue" | "GM_getValue" | "GM_listValues" | "GM_deleteValue"} substorage_value
  804.          */
  805.         /**
  806.          * 可以传入params的字符串名称
  807.          * @typedef {'oFunc' | substorage_value} param
  808.          */
  809.         /**
  810.          * 被加载函数对象的func函数
  811.          * @callback oFuncBody
  812.          * @param {oFunc} oFunc
  813.          * @returns {*|Promise<*>}
  814.          */
  815.         /**
  816.          * 被加载执行的函数对象
  817.          * @typedef {Object} oFunc
  818.          * @property {string} id - 每次load（每个FuncPool实例）内唯一的标识符
  819.          * @property {boolean} [disabled] - 为真值时，无论checkers还是detectDom等任何其他条件通过或未通过，均不执行此函数对象；默认为false
  820.          * @property {checker[]|checker} [checkers] - oFunc执行的条件
  821.          * @property {string[]|string} [detectDom] - 如果提供，开始checker检查前会首先等待其中所有css选择器对应的元素在document中出现
  822.          * @property {string[]|string} [dependencies] - 如果提供，应为其他函数对象的id或者id列表；开始checker检查前会首先等待其中所有指定的函数对象加载完毕
  823.          * @property {boolean} [readonly] - 指定该函数的返回值是否应该被Proxy保护为不可修改对象
  824.          * @property {param[]|param} params - 可选，指定传入oFunc.func的参数列表；可以为参数本身或其组成的数组
  825.          * 参数可以为 字符串 或是 其他类型，如果是字符串就传入对应的FunctionLoader提供的内置值（见下），如果是其他类型则按照原样传入
  826.          * - "oFunc":
  827.          *     函数对象本身
  828.          * - "GM_setValue", "GM_getValue", "GM_listValues", "GM_deleteValue":
  829.          *     和脚本管理器提供的函数一致，但是读取和写入的对象是以oFunc.id为键的子空间
  830.          *     比如，GM_getValue("prop") 就相当于调用脚本管理器提供的的 GM_getValue(oFunc.id)["prop"]
  831.          * @property {oFuncBody} func - 实际实现了功能的函数
  832.          * @property {boolean} [STOP] - [调试用] 指定不执行此函数对象
  833.          */
  834.  
  835.         const registered_checkers = {
  836. 			switch: value => value,
  837. 			url: value => location.href === value,
  838. 			path: value => location.pathname === value,
  839. 			regurl: value => !!location.href.match(value),
  840. 			regpath: value => !!location.pathname.match(value),
  841. 			starturl: value => location.href.startsWith(value),
  842. 			startpath: value => location.pathname.startsWith(value),
  843. 			func: value => value()
  844. 		};
  845.  
  846.         class FuncPool extends EventTarget {
  847.             static #STILL_LOADING = Symbol('oFunc still loading');
  848.             static FunctionNotFound = Symbol('Function not found');
  849.             static FunctionNotLoaded = Symbol('Function not loaded');
  850.             static CheckerNotPass = Symbol('Function checker does not pass');
  851.             static ErrorWhileLoad = Symbol('Error caught when function loading');
  852.  
  853.             /** @typedef {symbol|*} return_value */
  854.             /** @type {Map<oFunc, return_value>} */
  855.             #oFuncs = new Map();
  856.  
  857.             #GM_funcs;
  858.  
  859.             /** @typedef {{error: Error, oFunc: oFunc}} load_error */
  860.             /** @type {load_error[]} */
  861.             errors;
  862.  
  863.             /**
  864.              * 创建新函数池
  865.              * @param {Object} [details={}] - 可选，默认为{}空对象
  866.              * @param {function} [details.GM_getValue] - 可选，读取脚本存储的函数；如果提供，使用提供的值，否则使用上下文中的值
  867.              * @param {function} [details.GM_setValue] - 可选，写入脚本存储的函数；如果提供，使用提供的值，否则使用上下文中的值
  868.              * @param {function} [details.GM_deleteValue] - 可选，删除脚本存储的函数；如果提供，使用提供的值，否则使用上下文中的值
  869.              * @param {function} [details.GM_listValues] - 可选，列出脚本存储的函数；如果提供，使用提供的值，否则使用上下文中的值
  870.              * @param {oFunc | oFunc[]} [oFuncs] - 可选，需要立即加载的函数对象
  871.              * @returns {FuncPool}
  872.              */
  873.             constructor({
  874.                 GM_getValue: _GM_getValue = typeof GM_getValue === 'function' ? GM_getValue : null,
  875.                 GM_setValue: _GM_setValue = typeof GM_setValue === 'function' ? GM_setValue : null,
  876.                 GM_deleteValue: _GM_deleteValue = typeof GM_deleteValue === 'function' ? GM_deleteValue : null,
  877.                 GM_listValues: _GM_listValues = typeof GM_listValues === 'function' ? GM_listValues : null,
  878.                 oFuncs = []
  879.             } = {}) {
  880.                 super();
  881.                 this.#GM_funcs = {
  882.                     GM_getValue: _GM_getValue,
  883.                     GM_setValue: _GM_setValue,
  884.                     GM_deleteValue: _GM_deleteValue,
  885.                     GM_listValues: _GM_listValues
  886.                 };
  887.                 this.errors = [];
  888.                 this.load(oFuncs);
  889.             }
  890.  
  891.             /**
  892.              * 加载提供的一个或多个函数对象，并将其加入到函数池中 \
  893.              * 异步函数，当所有传入的函数对象都彻底load完毕/checkers确定不加载时resolve
  894.              * @param {oFunc[]|oFunc} [oFuncs] - 可选，需要加载的函数对象或其数组，不提供时默认为空数组
  895.              */
  896.             async load(oFuncs=[]) {
  897.                 oFuncs = Array.isArray(oFuncs) ? oFuncs : [oFuncs];
  898.                 await Promise.all(oFuncs.map(oFunc => this.#load(oFunc)));
  899.             }
  900.  
  901.             /**
  902.              * 加载一个函数对象，并将其加入到函数池中 \
  903.              * 当id重复时，直接报错RedeclarationError \
  904.              * 异步函数，当彻底load完毕/checkers确定不加载时resolve \
  905.              * 当加载完毕时，广播load事件；如果全部加载完毕，还广播all_load事件
  906.              * @todo 当checker确定不加载时，广播什么事件？后续all_load是否仍然触发？
  907.              * @param {oFunc} oFunc
  908.              * @returns {Promise<boolean>} 本次调用是否成功执行了加载并顺利加载完毕
  909.              */
  910.             async #load(oFunc) {
  911.                 const that = this;
  912.  
  913.                 // disabled的函数对象，不执行
  914.                 if (oFunc.disabled) {
  915.                     return false;
  916.                 }
  917.  
  918.                 // 已经在函数池中的函数对象，不重复load
  919.                 if (this.#oFuncs.has(oFunc)) {
  920.                     return false;
  921.                 }
  922.  
  923.                 // 检查有无重复id
  924.                 for (const o of this.#oFuncs.keys()) {
  925.                     if (o.id === oFunc.id) {
  926.                         throw new RedeclarationError(`Attempts to load oFunc with id already in use: ${oFunc.id}`);
  927.                     }
  928.                 }
  929.  
  930.                 // 设置当前返回值为STILL_LOADING
  931.                 this.#oFuncs.set(oFunc, FuncPool.#STILL_LOADING);
  932.  
  933.                 // 加载依赖
  934.                 const dependencies = Array.isArray(oFunc.dependencies) ? oFunc.dependencies : ( oFunc.dependencies ? [oFunc.dependencies] : [] );
  935.                 await Promise.all(dependencies.map(id => new Promise((resolve, reject) => {
  936.                     $AEL(that, 'load', e => e.detail.oFunc.id === id && resolve());
  937.                 })));
  938.  
  939.                 // 检测checkers加载条件
  940.                 const checkers = Array.isArray(oFunc.checkers) ? oFunc.checkers : ( oFunc.checkers ? [oFunc.checkers] : [] );
  941.                 if (!testCheckers(checkers, oFunc)) {
  942.                     this.#oFuncs.set(oFunc, FuncPool.CheckerNotPass);
  943.                     return false;
  944.                 }
  945.  
  946.                 // 检测detectDOM中css选择器指定的元素出现
  947.                 const selectors = Array.isArray(oFunc.detectDom) ? oFunc.detectDom : ( oFunc.detectDom ? [oFunc.detectDom] : [] );
  948.                 await Promise.all(selectors.map(selector => detectDom(selector)));
  949.  
  950.                 // 处理substorage
  951.                 const substorage = this.#MakeSubStorage(oFunc.id);
  952.  
  953.                 // 处理函数参数
  954.                 const builtins = {
  955.                     oFunc,
  956.                     ...substorage
  957.                 };
  958.                 const params = oFunc.params ? (Array.isArray(oFunc.params) ? oFunc.params : [oFunc.params]) : [];
  959.                 const args = params.map(param => typeof param === 'string' ? builtins[param] : param);
  960.  
  961.                 // 执行函数对象
  962.                 let raw_return_value, return_value;
  963.                 try {
  964.                     raw_return_value = oFunc.func(...args);
  965.                     return_value = await Promise.resolve(raw_return_value);
  966.                 } catch (error) {
  967.                     // 当出现错误时，广播错误事件，储存错误信息，设置错误状态
  968.                     const load_error = { error, oFunc };
  969.                     this.#broadcast('error', load_error);
  970.                     this.errors.push(load_error);
  971.                     this.#oFuncs.set(oFunc, FuncPool.ErrorWhileLoad);
  972.                     return false;
  973.                 }
  974.  
  975.                 // 设置返回值
  976.                 this.#oFuncs.set(oFunc, return_value);
  977.  
  978.                 // 广播事件
  979.                 this.#broadcast('load', { oFunc, id: oFunc.id, return_value });
  980.                 Array.from(this.#oFuncs.values()).every(v => v !== FuncPool.#STILL_LOADING) &&
  981.                     this.#broadcast('all_load');
  982.                 
  983.                 return true;
  984.             }
  985.  
  986.             /**
  987.              * 获取指定函数对象的返回值 \
  988.              * 如果指定的函数对象不存在，返回FuncPool.FunctionNotFound \
  989.              * 如果指定的函数对象存在但尚未加载，返回FuncPool.FunctionNotLoaded \
  990.              * 如果函数对象指定了readonly为真值，则返回前用Proxy包装返回值，使其不可修改
  991.              * @param {string} id - 函数对象的id
  992.              * @returns {*}
  993.              */
  994.             require(id) {
  995.                 for (const [oFunc, return_value] of this.#oFuncs.entries()) {
  996.                     if (oFunc.id === id) {
  997.                         if (return_value === FuncPool.#STILL_LOADING) {
  998.                             return FuncPool.FunctionNotLoaded;
  999.                         } else {
  1000.                             return oFunc.readonly ? FuncPool.#MakeReadonlyObj(return_value) : return_value;
  1001.                         }
  1002.                     }
  1003.                 }
  1004.                 return FuncPool.FunctionNotFound;
  1005.             }
  1006.  
  1007.             isLoaded(id) {
  1008.                 for (const [oFunc, return_value] of this.#oFuncs.entries()) {
  1009.                     if (oFunc.id === id) {
  1010.                         if (return_value === FuncPool.#STILL_LOADING) {
  1011.                             return false;
  1012.                         } else {
  1013.                             return true;
  1014.                         }
  1015.                     }
  1016.                     return false;
  1017.                 }
  1018.             }
  1019.  
  1020.             /**
  1021.              * 调用this.dispatchEvent分发自定义事件
  1022.              * 同时对可分发的事件名称进行限制
  1023.              * @param {'load' | 'all_load' | 'error'} evt_name 
  1024.              * @param {*} [detail] 
  1025.              */
  1026.             #broadcast(evt_name, detail) {
  1027.                 return this.dispatchEvent(new CustomEvent(evt_name, { detail }));
  1028.             }
  1029.  
  1030.             get GM_funcs() {
  1031.                 return { ...this.#GM_funcs };
  1032.             }
  1033.  
  1034.             /**
  1035.              * 以Proxy包装value，使其属性只读 \
  1036.              * 如果传入的不是object，则直接返回value \
  1037.              * @param {Object} val
  1038.              * @returns {Proxy}
  1039.              */
  1040.             static #MakeReadonlyObj(val) {
  1041.                 return isObject(val) ? new Proxy(val, {
  1042.                     get: function(target, property, receiver) {
  1043.                         return FuncPool.#MakeReadonlyObj(target[property]);
  1044.                     },
  1045.                     set: function(target, property, value, receiver) {},
  1046.                     has: function(target, prop) {},
  1047.                     setPrototypeOf(target, newProto) {
  1048.                         return false;
  1049.                     },
  1050.                     defineProperty(target, property, descriptor) {
  1051.                         return true;
  1052.                     },
  1053.                     deleteProperty(target, property) {
  1054.                         return false;
  1055.                     },
  1056.                     preventExtensions(target) {
  1057.                         return false;
  1058.                     }
  1059.                 }) : val;
  1060.  
  1061.                 function isObject(value) {
  1062.                     return ['object', 'function'].includes(typeof value) && value !== null;
  1063.                 }
  1064.             }
  1065.  
  1066.             /**
  1067.              * 创建适用于子功能函数的 GM_setValue, GM_getValue, GM_deleteValue 和 GM_listValues \
  1068.              * 调用返回的`GM_setValue(str, val)`相当于对脚本管理器提供的GM*函数进行如下调用：
  1069.              * ``` javascript
  1070.              * const obj = GM_getValue(key, {});
  1071.              * if (typeof obj !== 'object' or obj === null) { throw new TypeError(''); }
  1072.              * obj[str] = val;
  1073.              * GM_setValue(key, obj);
  1074.              * ```
  1075.              * @param {string} key - 实际调用用户脚本管理器的GM*函数时提供的key，一般是子功能函数id
  1076.              * @returns {{ GM_setValue: function, GM_getValue: function, GM_deleteValue: function, GM_listValues: function }}
  1077.              */
  1078.             #MakeSubStorage(key) {
  1079.                 const GM_funcs = this.#GM_funcs;
  1080.                 return {
  1081.                     GM_setValue(name, val) {
  1082.                         checkGrant(['GM_setValue', 'GM_getValue'], 'GM_setValue');
  1083.                         const obj = GM_funcs.GM_getValue(key, {});
  1084.                         Assert(isObject(obj), `FunctionLoader: storage item of key ${name} should be an object`, TypeError);
  1085.                         obj[name] = val;
  1086.                         GM_funcs.GM_setValue(key, obj);
  1087.                     },
  1088.                     GM_getValue(name, default_value=null) {
  1089.                         checkGrant(['GM_getValue'], 'GM_getValue');
  1090.                         const obj = GM_funcs.GM_getValue(key, {});
  1091.                         return obj.hasOwnProperty(name) ? obj[name] : default_value;
  1092.                     },
  1093.                     GM_deleteValue(name) {
  1094.                         checkGrant(['GM_setValue', 'GM_getValue'], 'GM_deleteValue');
  1095.                         const obj = GM_funcs.GM_getValue(key, {});
  1096.                         delete obj[name];
  1097.                         GM_funcs.GM_setValue(key, obj);
  1098.                     },
  1099.                     GM_listValues() {
  1100.                         checkGrant(['GM_getValue'], 'GM_listValues');
  1101.                         const obj = GM_funcs.GM_getValue(key, {});
  1102.                         return Object.keys(obj);
  1103.                     }
  1104.                 };
  1105.  
  1106.                 /**
  1107.                  * 检查指定的GM_*函数是否存在，不存在就抛出错误
  1108.                  * @param {string|string[]} funcnames
  1109.                  * @param {string} calling - 正在调用的GM_函数的名字，输出错误信息时用
  1110.                  */
  1111.                 function checkGrant(funcnames, calling) {
  1112.                     Array.isArray(funcnames) || (funcnames = [funcnames]);
  1113.                     for (const funcname of funcnames) {
  1114.                         Assert(GM_funcs[funcname], `FunctionLoader: @grant ${funcname} in userscript metadata before using ${calling}`, TypeError);
  1115.                     }
  1116.                 }
  1117.  
  1118.                 function isObject(val) {
  1119.                     return typeof val === 'object' && val !== null;
  1120.                 }
  1121.             }
  1122.         }
  1123.         class RedeclarationError extends TypeError {}
  1124.         class CircularDependencyError extends ReferenceError {}
  1125.  
  1126.  
  1127.         // 预置的函数池
  1128.         const default_pool = new FuncPool();
  1129.  
  1130.         /**
  1131.          * 在预置的函数池中加载函数对象或其数组
  1132.          * @param {oFunc[]|oFunc} oFuncs - 需要执行的函数对象
  1133.          * @returns {FuncPool}
  1134.          */
  1135.         function loadFuncs(oFuncs) {
  1136.             default_pool.load(oFuncs);
  1137.             return default_pool;
  1138.         }
  1139.  
  1140.         /**
  1141.          * 在预置的函数池中获取函数对象的返回值
  1142.          * @param {string} id - 函数对象的字符串id
  1143.          * @returns {*}
  1144.          */
  1145.         function require(id) {
  1146.             return default_pool.require(id);
  1147.         }
  1148.  
  1149.         /**
  1150.          * 在预置的函数池中检查指定函数对象是否已经加载完毕（有返回值可用）
  1151.          * @param {string} id - 函数对象的字符串id
  1152.          * @returns {boolean}
  1153.          */
  1154.         function isLoaded(id) {
  1155.             return default_pool.isLoaded(id);
  1156.         }
  1157.  
  1158.         /**
  1159.          * 测试给定checker是否检测通过 \
  1160.          * 给定多个checker时，checkers之间是 或 关系，有一个checker通过即算作整体通过 \
  1161.          * 注意此函数设计和旧版testChecker的设计不同，旧版中一个checker可以有多个值，还可通过checker.all指定多值之间的关系为 与 还是 或
  1162.          * @param {checker[]|checker} [checkers] - 需要检测的checkers
  1163.          * @param {oFunc|*} [this_value] - 如提供，将用作checkers运行时的this值；一般而言为checkers所属的函数对象
  1164.          * @returns {boolean}
  1165.          */
  1166.         function testCheckers(checkers=[], this_value=null) {
  1167.             checkers = Array.isArray(checkers) ? checkers : [checkers];
  1168.             return checkers.length === 0 || checkers.some(checker => !!registered_checkers[checker.type]?.call(this_value, checker.value));
  1169.         }
  1170.  
  1171.         /**
  1172.          * 注册新checker \
  1173.          * 如果给定type已经被其他checker占用，则会报错RedeclarationError \
  1174.          * @param {string} type - checker类名
  1175.          * @param {function} func - checker implementation
  1176.          */
  1177.         function registerChecker(type, func) {
  1178.             if (registered_checkers.hasOwnProperty(type)) {
  1179.                 throw RedeclarationError(`Attempts to register checker with type already in use: ${type}`);
  1180.             }
  1181.             registered_checkers[type] = func;
  1182.         }
  1183.  
  1184.         const FunctionLoader = {
  1185.             FuncPool,
  1186.             testCheckers,
  1187.             registerChecker,
  1188.             get checkers() {
  1189.                 return Object.assign({}, registered_checkers);
  1190.             },
  1191.             Error: {
  1192.                 RedeclarationError,
  1193.                 CircularDependencyError
  1194.             }
  1195.         };
  1196.         return [FunctionLoader, loadFuncs, require, isLoaded];
  1197.     }) ();
  1198.  
  1199.     return [
  1200.         // Console & Debug
  1201.         LogLevel, DoLog, Err, Assert,
  1202.  
  1203.         // DOM
  1204.         $, $All, $CrE, $AEL, $$CrE, addStyle, detectDom, destroyEvent,
  1205.  
  1206.         // Data
  1207.         copyProp, copyProps, parseArgs, escJsStr, replaceText,
  1208.  
  1209.         // Environment & Browser
  1210.         getUrlArgv, dl_browser, dl_GM,
  1211.  
  1212.         // Logic & Task
  1213.         AsyncManager, queueTask, FunctionLoader, loadFuncs, require, isLoaded
  1214.     ];
  1215. }) ();