NEWS.md

Latest commit

History

History
88 lines (59 loc) · 3 KB

NEWS.md

File metadata and controls

88 lines (59 loc) · 3 KB
Raw

std.prototype NEWS - User visible changes

Noteworthy changes in release ?.? (????-??-??) [?]

Noteworthy changes in release 1.1 (2020-07-26) [stable]

New Features

  • Initial support for Lua 5.4 and 5.5.

Noteworthy changes in release 1.0.1 (2016-02-07) [stable]

Bug fixes

  • The former lua-stdlib strict module, has moved to std.strict to avoid confusion with the original PUC-Rio strict.lua. The base module now looks for it there.

Noteworthy changes in release 1.0 (2016-02-07) [stable]

New features (since lua-stdlib-41.2)

  • Initial release, now separated out from lua-stdlib.

  • Objects and Modules are no longer conflated - what you get back from a require "std.prototype.something" is now ALWAYS a module:

    localobject=require"std.prototype.object"assert (object.type (object) =="Module")

    And the modules that provide objects have a new prototype field that contains the prototye for that kind of object:

    localObject=object.prototypeassert (object.type (Object) =="Object")

    For backwards compatibility, if you call the module with a constructor table, the previous recommended way to disambiguate between a module and the object it prototyped, that table is passed through to the module's object prototype.

  • Now that we have proper separation of concerns between module tables and object prototype tables, the central std.prototype.object.mapfields instantiation function is much cleaner and faster.

  • We used to have an object module method, std.object.type, which often got imported using:

    localprototype=require"std.object".type

    So we renamed it to std.object.prototype to avoid a name clash with the type symbol, and subsequently deprecated the earlier equivalent type method; but that was a mistake, because core Lua provides type, and io.type (and in recent releases, math.type). So now, for orthogonality with core Lua, we're going back to using std.prototype.object.type, because that just makes more sense. Sorry!

Bug fixes

  • You can now derive other types from std.prototype.set by passing a _type field in the init argument, just like the other table argument objects.

  • In-order iteration with __pairs metamethod has been reinstated. There were no spec examples, and the implementation mysteriously went missing in a previous round of refactoring.

Incompatible changes

  • Deprecated methods and functions have all been removed.

  • std.tree is now std.prototype.trie and defines a Trie object, not a Tree object. The implementation has been a Radix Tree (aka Trie) all along.

  • Objects no longer honor mangling and stripping _functions tables from objects during instantiation, instead move your actual object into the module prototype field, and add the module functions to
    the parent table returned when the module is required.

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n 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;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} 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
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.

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

Skip to content
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.

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

Skip to content
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} 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
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.

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

Skip to content
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.

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

Skip to content
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.

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

Skip to content
NEWS.md
Latest commit
History
History
88 lines (59 loc) · 3 KB
NEWS.md
File metadata and controls
88 lines (59 loc) · 3 KB
Raw
std.prototype NEWS - User visible changes
Noteworthy changes in release ?.? (????-??-??) [?]
Noteworthy changes in release 1.1 (2020-07-26) [stable]
New Features
  • Initial support for Lua 5.4 and 5.5.
Noteworthy changes in release 1.0.1 (2016-02-07) [stable]
Bug fixes
  • The former lua-stdlib strict module, has moved to std.strict
to avoid confusion with the original PUC-Rio strict.lua. The base
module now looks for it there.
Noteworthy changes in release 1.0 (2016-02-07) [stable]
New features (since lua-stdlib-41.2)
  • Initial release, now separated out from lua-stdlib.
  • Objects and Modules are no longer conflated - what you get back from
a require "std.prototype.something" is now ALWAYS a module:
    localobject=require"std.prototype.object"assert (object.type (object) =="Module")
    And the modules that provide objects have a new prototype field
that contains the prototye for that kind of object:
    localObject=object.prototypeassert (object.type (Object) =="Object")
    For backwards compatibility, if you call the module with a
constructor table, the previous recommended way to disambiguate
between a module and the object it prototyped, that table is passed
through to the module's object prototype.
  • Now that we have proper separation of concerns between module tables
and object prototype tables, the central std.prototype.object.mapfields
instantiation function is much cleaner and faster.
  • We used to have an object module method, std.object.type, which
often got imported using:
    localprototype=require"std.object".type
    So we renamed it to std.object.prototype to avoid a name clash with
the type symbol, and subsequently deprecated the earlier equivalent
type method; but that was a mistake, because core Lua provides type,
and io.type (and in recent releases, math.type). So now, for
orthogonality with core Lua, we're going back to using
std.prototype.object.type, because that just makes more sense. Sorry!
Bug fixes
  • You can now derive other types from std.prototype.set by passing a
_type field in the init argument, just like the other table argument
objects.
  • In-order iteration with __pairs metamethod has been reinstated.
There were no spec examples, and the implementation mysteriously
went missing in a previous round of refactoring.
Incompatible changes
  • Deprecated methods and functions have all been removed.
  • std.tree is now std.prototype.trie and defines a Trie object, not a
Tree object. The implementation has been a Radix Tree (aka Trie)
all along.
  • Objects no longer honor mangling and stripping _functions tables
from objects during instantiation, instead move your actual object
into the module prototype field, and add the module functions to
    
the parent table returned when the module is required.