module.md

Latest commit

History

History
147 lines (95 loc) · 3.17 KB

module.md

File metadata and controls

147 lines (95 loc) · 3.17 KB
Raw

Common Module Definition / draft

This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.

  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.

Module Definition

A module is defined with define keyword, which is a function.

define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.

Module Context

In a module, there are three free variables: require, exports and module.

define(function(require,exports,module){// The module code goes here});

The require Function

  1. require is a function

    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.

  2. require.async is a function

    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.

The exports Object

In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.

The module Object

  1. module.uri

    The full resolved uri to the module.

  2. module.dependencies

    A list of module identifiers that required by the module.

  3. module.exports

    The exported API of the module. It is the same as exports object.

Module Identifier

  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.

Sample Code

A typical sample

math.js

define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});

increment.js

define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});

program.js

define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});

Wrapped modules with non-function factory

object-data.js

define({foo: "bar"});

array-data.js

define(['foo','bar']);

string-data.js

define('foo bar');
, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');


, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');


, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');


, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');


, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');


, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');


, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
module.md
Latest commit
History
History
147 lines (95 loc) · 3.17 KB
module.md
File metadata and controls
147 lines (95 loc) · 3.17 KB
Raw
Common Module Definition / draft
This specification addresses how modules should be written in order to be interoperable in browser-based environment. By implication, this specification defines the minimum features that a module system must provide in order to support interoperable modules.
  • Modules are singletons.
  • New free variables within the module scope should not be introduced.
  • Execution must be lazy.
Module Definition
A module is defined with define keyword, which is a function.
define(factory);
  1. The define function accepts a single argument, the module factory.
  2. The factory may be a function or other valid values.
  3. If factory is a function, the first three parameters of the function, if specified, must be "require", "exports", and "module", in that order.
  4. If factory is not a function, then the module's exports are set to that object.
Module Context
In a module, there are three free variables: require, exports and module.
define(function(require,exports,module){// The module code goes here});
The require Function
  1. require is a function
    1. require accepts a module identifier.
    2. require returns the exported API of the foreign module.
    3. If requested module cannot be returned, require should return null.
  2. require.async is a function
    1. require.async accepts a list of module identifiers and a optional callback function.
    2. The callback function receives module exports as function arguments, listed in the same order as the order in the first argument.
    3. If requested module cannot be returned, the callback should receive null correspondingly.
The exports Object
In a module, there is a free variable called "exports", that is an object that the module may add its API to as it executes.
The module Object
  1. module.uri
    The full resolved uri to the module.
  2. module.dependencies
    A list of module identifiers that required by the module.
  3. module.exports
    The exported API of the module. It is the same as exports object.
Module Identifier
  1. A module identifier is and must be a literal string.
  2. Module identifiers may not have a filename extensions like .js.
  3. Module identifiers should be dash-joined string, such as foo-bar.
  4. Module identifiers can be a relative path, like ./foo and ../bar.
Sample Code
A typical sample
math.js
define(function(require,exports,module){exports.add=function(){varsum=0,i=0,args=arguments,l=args.length;while(i<l){sum+=args[i++];}returnsum;};});
increment.js
define(function(require,exports,module){varadd=require('math').add;exports.increment=function(val){returnadd(val,1);};});
program.js
define(function(require,exports,module){varinc=require('increment').increment;vara=1;inc(a);// 2module.id=="program";});
Wrapped modules with non-function factory
object-data.js
define({foo: "bar"});
array-data.js
define(['foo','bar']);
string-data.js
define('foo bar');