Skip to content
BranchesTags

Repository files navigation

yikes

Package yikes provides functionality for reporting errors to operators.

It is based on the design explored in this post, specifically the error reporting for operators bit. The idea is that operators want errors reported wherever they occur in the call stack, not from some middleware that requires the error to be aware of its own stack trace and any context surrounding the error than operator may be interested in.

It provides a Reporter type that can be used to report errors. It uses the log/slog.Logger type to report errors, but the reporting doesn't have to be to a log line; the Logger could be configured, for example, to report to an error reporting service.

The error return from the Reporter.Report method (and its aliases, Reporter.Error, Reporter.Warn, and Reporter.Critical) is the same error but wrapped in a type that indicates to yikes that the error has already been reported and should not be reported again, unless it's being reported at a higher level. This is done so callers of helper functions within your application don't need to worry about whether the helper reported the error or not; they can just call Reporter.Report and have it do the deduplication itself. It will be rereported at a higher level so any automation that triggers at higher levels will still trigger, even if a function deeper in the call stack didn't have the context to understand the error should be reported at a higher level. If the application, for some reason, needs to know whether an error was reported or not, AlreadyReported can provide that information.

The intended use of this package is, whenever encountering an error an operator would be interested in, to replace this:

iferr!=nil {
returnerr
}

with this:

iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}

optionally passing any context the operator would be interested in as arguments to Reporter.Error.

About

Error reporting for operators.

Resources

Readme
MIT license
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, '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" + '
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, '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('^' + ".*" + '
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, '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('^' + ".*" + '
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, '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" + '
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, '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('^' + ".*" + '
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, '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('^' + ".*" + '
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, '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); }
})();
})();
GitHub - impractical/yikes: Error reporting for operators. · GitHub
Skip to content
BranchesTags
Repository files navigation
yikes
Package yikes provides functionality for reporting errors to operators.
It is based on the design explored in this
post, specifically the error
reporting for operators bit. The idea is that operators want errors reported
wherever they occur in the call stack, not from some middleware that requires
the error to be aware of its own stack trace and any context surrounding the
error than operator may be interested in.
It provides a Reporter type
that can be used to report errors. It uses the
log/slog.Logger type to report errors,
but the reporting doesn't have to be to a log line; the Logger could be
configured, for example, to report to an error reporting service.
The error return from the
Reporter.Report
method (and its aliases,
Reporter.Error,
Reporter.Warn, and
Reporter.Critical)
is the same error but wrapped in a type that indicates to yikes that the error
has already been reported and should not be reported again, unless it's being
reported at a higher level. This is done so callers of helper functions within
your application don't need to worry about whether the helper reported the
error or not; they can just call
Reporter.Report and
have it do the deduplication itself. It will be rereported at a higher level so
any automation that triggers at higher levels will still trigger, even if a
function deeper in the call stack didn't have the context to understand the
error should be reported at a higher level. If the application, for some
reason, needs to know whether an error was reported or not,
AlreadyReported can
provide that information.
The intended use of this package is, whenever encountering an error an
operator would be interested in, to replace this:
iferr!=nil {
returnerr
}
with this:
iferr!=nil {
returnyikes.From(ctx).Error(ctx, "some error occurred", err)
}
optionally passing any context the operator would be interested in as
arguments to
Reporter.Error.
About
Error reporting for operators.
Resources
Readme
MIT license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages