NotHereToPlayGames

Okay, that was more than "two words". But come on, you cannot fully answer your question in "two words". Oh, wait, I CAN answer in TWO WORDS == SUPERMIUM ONLY.

Supermium author changed the naming of an internal flag and also changed its default state. This is only in Supermium v126 R6 and higher. So all Supermium versions beginning with v126 R6 behave *DIFFERENTLY* than all other v126 and higher for *ALL OTHER* Chrome/Chromium forks. This causes *great confusion* for anybody UPGRADING and keeping a profile from R5 or older. Especially if that profile sets/unsets this flag. The UPGRADED profile now has this flag doing the OPPOSITE of why the user set/unset it in the first place. Most importantly - this is Supermium Only. Users that set flags now have to comb through all of their flags to see if the Supermium Author now has it doing the OPPOSITE of all other Chrome/Chromium Forks "on the planet". Unless, of course, those forks don't fork from upstream but fork from Supermium directly (I have not checked nor tried any forks of Supermium, if they do exist).

This thread is nothing more than a bunch of know-it-all's (myself included, lol) talking in circles because, well, because we know it all. There is now a REAL followup to this at GitHub (which I have been requesting all along) - https://github.com/win32ss/supermium/issues/1229 And this **IS** a Supermium issue! No other Chrome Forks changed the name of the flag and its default state, only Supermium did this, no others! "Your subjectivity has biased your objectivity."

I have 'normal' Chrome v122 and 'normal' Edge at work. Both of them display the identity page correctly. Unknown version of Edge (company IT updates it often). I can prevent company IT from updating my Chrome v122. I also can *not* run any Ungoogled at work. I can only run Official Chrome or Official Edge. But have more control over which version of Official Chrome. I've tried over a DOZEN different forks of Chrome/Chromium v126, ungoogled and normal, clienthints enabled/disabled, different useragents, comparing flags/command switches - this really is something that is *ONLY* happening in Supermium R6 and higher. It is not flag-related, it is not client hints, it is not user agent, it is something in Supermium R6 and higher that DOES NOT EXIST in any other v126. It would be one thing if a flag or command switch solved this in OTHER v126's also, but again, this is something that is happening *ONLY* in Supermium R6 and higher (requiring a flag to fix). Again, it would be one thing if Browser X v126 was effected and it required the flag *AND* Supermium R6 v126 was effected and it required the flag. THERE ARE NO OTHER v126's THAT NEED THIS FLAG TO RENDER THAT PAGE. NO OTHER CHROME FORKS ARE EFFECTED. NONE! Okay, none that I can find (there are a LOT of forks!), and I spent all weekend HUNTING. This is something *ISOLATED* to Supermium R6 and higher.

Supermium R6 and higher is BROKEN. Users should consider R5 as the most-recent working version of Supermium. Creator should be brought to this attention at GitHub (will not be by me!). Out of the box, no changes, R5 works (for cited web site) in XP and in 10. Out of the box, no changes, R6 does not work (for cited web site) in XP or in 10. R5 and R6 are both v126's and I cannot find any other Chrome/Chromium v126's to not work for the cited web site. This is a Supermium R6 and higher issue ONLY. It's not going to "go away" in new releases without the creator addressing whatever he introduced in R6 and is carrying over to everything newer. That's the best I can gather, at least. I really strongly and wholeheartedly feel this needs addressed at GitHub (again, will not be by me!).

Keyword is "suggested". VistaLover would have to stop back in and tell us if he is or is not enabling/disabling. Until then, we should not be "guessing" VistaLover's configuration. As a test, we could revert the flag and add this polyfill. At the very least rule out one of the flag features. https://glitch.com/edit/#!/close-watcher-demo?path=polyfill.js

no sh#t... they communicate through headers... PERIOD... done here, you just want to confuse issues instead of solve them...

It's gonna require someone with a Discord account to track down. Maybe it can be polyfilled. Maybe not.

For me, v132 FAILS that web site in XP and 10. I don't recall, as I'm not at home at the moment, but I'm fairly certain that v126 R5 works in both and that the issue "half-started" (fails in XP, works in 10) in v126 R6 and became "full-blown" (fails in XP and fails in 10) in v132.

That's from Official Ungoogled, not Supermium. I only run Supermium from inside VMs and I've devoted enough time to this before leaving for work as it is. The author uses the Official Ungoogled patches. The results "should" be the same. I have not confirmed this directly. No time to at the moment. I leave the rest of this "debate" for the rest of you. Moving on... "Toodles"...

I will not waste my time. I'm here to help DAVE resolve his issue. The web site in question DOES NOT send Client Hints headers. PERIOD! Your conspiracy theories are helping no one! Moving on... "Toodles"...

I don't think that it is Client Hints. Repeating Conspiracy Theories over and over does not help find a solution. v132 has a flag to disable Client Hints and that is having no effect on the rendering of britishgas.co.uk v122 pre-dates Client Hints and changing User Agent has no effect on the rendering of britishgas.co.uk Needs to become a GitHub Issue.

Perhaps a GitHub ticket needs created? Just-downloaded no-changes Supermium v132 in XP x86 - Just-downloaded no-changes Supermium v132 in Win10 x64 -

Correction. It is something inside Supermium. I get the "correct" rendering (includes elements above and immediately below red bar) in 360Chrome v13.5 in both XP and in Win10. So that rules out it being the OS. But I do not think it is flag or command line.

I can confirm that this is not a Supermium issue, but it is the Windows Version that is making the difference. My Supermium 126 renders your (and VistaLover) view in Win10. But the same exact Supermium 126 carried over to XP (no flag changes, no command line changes, no changes whatsoever) renders the version without the elements above and immediately below the red bar. I didn't dig any deeper than that.

You seem to be missing: 1) .toReversed 2) .toSpliced 3) .with The previous post "all-in-one" should cover all four. But these three as individual polyfills are below, in case you want them. // ==UserScript== // @name Inject Change Array by Copy .toReversed() Polyfill [110] // @version 0.0.1 // @match *://*/* // @run-at document-start // @grant none // ==/UserScript== if (!Array.prototype.toReversed) { Array.prototype.toReversed = function () { return this.slice().reverse(); }; } // ==UserScript== // @name Inject Change Array by Copy .toSpliced() Polyfill [110] // @version 0.0.1 // @match *://*/* // @run-at document-start // @grant none // ==/UserScript== if (!Array.prototype.toSpliced) { Array.prototype.toSpliced = function (start, deleteCount, ...items) { const copy = this.slice(); copy.splice(start, deleteCount, ...items); return copy; }; } // ==UserScript== // @name Inject Change Array by Copy .with() Polyfill [110] // @version 0.0.1 // @match *://*/* // @run-at document-start // @grant none // ==/UserScript== if (!Array.prototype.with) { Array.prototype.with = function (index, value) { const copy = this.slice(); copy[index] = value; return copy; }; }

I'd start with all-of-the-below then watch the Javascript Console (Ctrl-Shift-J) for items in red to provide hints for where to go from there. // ==UserScript== // @name Inject Change Array by Copy All-in-One Polyfill [110] // @version 0.0.1 // @match *://*/* // @run-at document-start // @grant none // ==/UserScript== ((arrayPrototype, typedArrayPrototype) => { "use strict"; const typedArrayLength = Function.call.bind( Object.getOwnPropertyDescriptor(typedArrayPrototype, "length").get ); function toIntegerOrInfinity(arg) { let n = Number(arg); if (Number.isNaN(n) || n === 0) { return 0; } if (n === Number.POSITIVE_INFINITY) { return Number.POSITIVE_INFINITY; } if (n === Number.NEGATIVE_INFINITY) { return Number.NEGATIVE_INFINITY; } let i = Math.floor(Math.abs(n)); if (n < 0) { i = -i; } return i; } function toObject(val) { if (val === null || val === undefined) { throw new TypeError(`${val} is not an object`); } return Object(val); } function lengthOfArrayLike(arr) { if (!(typeof arr === "object" && arr !== null)) { throw new TypeError(); } let len = toIntegerOrInfinity(arr["length"]); if (!Number.isFinite(len)) { len = 0; } return Math.max(0, Math.min(len, Number.MAX_SAFE_INTEGER)); } /** @typedef {Int8Array|Uint8Array|Uint8ClampedArray|Int16Array|Uint16Array|Int32Array|Uint32Array|Float32Array|Float64Array|BigInt64Array|BigUint64Array} TypedArray */ /** * @param {unknown} v * @returns {TypedArray} */ function assertTypedArray(v) { typedArrayPrototype.keys.call(v); // @ts-expect-error return v; } /** * @param {TypedArray} arr * @returns {TypedArray[typeof Symbol.toStringTag]} */ function typedArrayNameInternalSlot(arr) { return Object.getOwnPropertyDescriptor(typedArrayPrototype, Symbol.toStringTag) .get.call(arr); } /** * @param {TypedArray} example * @param {number} length * @returns {TypedArray} */ function typedArrayCreate(example, length) { assertTypedArray(example); const arrayName = typedArrayNameInternalSlot(example); switch (arrayName) { case 'Int8Array': return new Int8Array(length); case 'Uint8Array': return new Uint8Array(length); case 'Uint8ClampedArray': return new Uint8ClampedArray(length); case 'Int16Array': return new Int16Array(length); case 'Uint16Array': return new Uint16Array(length); case 'Int32Array': return new Int32Array(length); case 'Uint32Array': return new Uint32Array(length); case 'Float32Array': return new Float32Array(length); case 'Float64Array': return new Float64Array(length); case 'BigInt64Array': return new BigInt64Array(length); case 'BigUint64Array': return new BigUint64Array(length); default: /** @type {never} */ const n = arrayName; throw new Error(`Unexpected TypedArray name ${n}`); } } /** * @param {TypedArray} example * @returns {boolean} */ function isBigIntArray(example) { assertTypedArray(example); const arrayName = typedArrayNameInternalSlot(example); switch (arrayName) { case 'BigInt64Array': case 'BigUint64Array': return true; } return false; } function transfer({ count, src, srcStart, srcStep = 1, target, targetStart, targetStep = srcStep }) { let from = srcStart; let to = targetStart; for (let i = 0; i < count; i++) { target[to] = src[from]; from += srcStep; to += targetStep; } } /** * @param {TypedArray} example * @param {unknown} value * @description convert `value` to bigint or number based on the the type of array * @returns {bigint | number} * @throws if one of the override methods throws. e.g. `@@toPrimitive`, `valueOf`, `toString` */ function typedArrayNumberConversion(example, value) { let asNumber; { if (isBigIntArray(example)) { asNumber = 0n; } else { asNumber = -0; // important to use `-0` and not `0` } // @ts-ignore : using `+=` to emulate ToBigInt or ToNumber asNumber += value; } return asNumber; } defineArrayMethods({ toReversed() { const o = toObject(this); const len = lengthOfArrayLike(o); const a = new Array(len); transfer({ src: o, srcStart: len - 1, srcStep: -1, target: a, targetStart: 0, targetStep: 1, count: len }); return a; }, }); defineTypedArrayMethods({ toReversed() { const o = assertTypedArray(this); const len = typedArrayLength(o); const a = typedArrayCreate(o, len); transfer({ src: o, srcStart: len - 1, srcStep: -1, target: a, targetStart: 0, targetStep: 1, count: len }); return a; }, }); defineArrayMethods({ toSorted(compareFn) { if (compareFn !== void 0 && typeof compareFn !== "function") { throw new TypeError(); } const o = toObject(this); const len = lengthOfArrayLike(o); const a = new Array(len);; transfer({ src: o, srcStart: 0, target: a, targetStart: 0, count: len }); arrayPrototype.sort.call(a, compareFn); return a; }, }); defineTypedArrayMethods({ toSorted(compareFn) { if (compareFn !== void 0 && typeof compareFn !== "function") { throw new TypeError(); } const o = assertTypedArray(this); const len = typedArrayLength(o); const a = typedArrayCreate(o, len); transfer({ src: o, srcStart: 0, target: a, targetStart: 0, count: len }); typedArrayPrototype.sort.call(a, compareFn); return a; }, }); function calculateSplice({ start, len, deleteCount, values, argsCount }) { const relativeStart = toIntegerOrInfinity(start); let actualStart; if (relativeStart === -Infinity) { actualStart = 0; } else if (relativeStart < 0) { actualStart = Math.max(len + relativeStart, 0); } else { actualStart = Math.min(relativeStart, len); } const insertCount = values.length; let actualDeleteCount; if (/* start is not present */ argsCount === 0) { actualDeleteCount = 0; } else if (/* deleteCount is not present */ argsCount === 1) { actualDeleteCount = len - actualStart; } else { const dc = toIntegerOrInfinity(deleteCount); actualDeleteCount = Math.max(0, Math.min(dc, len - actualStart)); } const newLen = len + insertCount - actualDeleteCount; return { actualStart, newLen, actualDeleteCount }; } function doSplice({ src, target, actualStart, actualDeleteCount, values, newLen }) { let i = 0; while (i < actualStart) { target = src; i++; } for (const E of values) { target = E; i++; } let r = actualStart + actualDeleteCount; while (i < newLen) { let fromValue = src[r]; target = fromValue; i++; r++; } } defineArrayMethods({ toSpliced(start, deleteCount, ...values) { const o = toObject(this); const len = lengthOfArrayLike(o); const { actualStart, actualDeleteCount, newLen } = calculateSplice({ start, deleteCount, len, values, argsCount: arguments.length }); if (newLen > Number.MAX_SAFE_INTEGER) { throw new TypeError(); } const a = new Array(newLen); doSplice({ src: o, target: a, actualStart, actualDeleteCount, values, newLen }); return a; } }); defineArrayMethods({ with(index, value) { const o = toObject(this); const len = lengthOfArrayLike(o); const relativeIndex = toIntegerOrInfinity(index); const actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex; if (actualIndex < 0 || actualIndex >= len) { throw new RangeError(); } const a = new Array(len); for (let k = 0; k < len; k++) { const v = k === actualIndex ? value : o[k]; a[k] = v; } return a; } }); defineTypedArrayMethods({ with(index, value) { const o = assertTypedArray(this); const len = typedArrayLength(o); const relativeIndex = toIntegerOrInfinity(index); const actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex; const asNumber = typedArrayNumberConversion(o, value); if (actualIndex < 0 || actualIndex >= len) { throw new RangeError(); } const a = typedArrayCreate(o, len); for (let k = 0; k < len; k++) { const v = k === actualIndex ? asNumber : o[k]; a[k] = v; } return a; } }); /** @type {(def: { [N in "with" | "toReversed" | "toSorted" | "toSpliced"]?: typeof Array.prototype[N] }) => void} */ function defineArrayMethods(def) { defineMethods(arrayPrototype, def).forEach(name => { if (name !== 'with') { // 'with' is already a keyword arrayPrototype[Symbol.unscopables][name] = true; } }); } /** @type {(def: { [N in "with" | "toReversed" | "toSorted"]?: (this: TypedArray, ...args: Parameters<Uint8Array[N]>) => TypedArray }) => void} */ function defineTypedArrayMethods(def) { defineMethods(typedArrayPrototype, def); } function defineMethods(obj, def) { return Object.entries(def).map(([name, method]) => { Object.defineProperty(obj, name, { value: method, enumerable: false, configurable: true, writable: true, }); return name; }); } })(Array.prototype, Object.getPrototypeOf(Int8Array.prototype)); // ==UserScript== // @name Inject Promise.withResolvers() Polyfill [119] // @version 0.0.1 // @match *://*/* // @run-at document-start // @grant none // ==/UserScript== Promise.withResolvers || (Promise.withResolvers = function withResolvers() { var a, b, c = new this(function (resolve, reject) { a = resolve; b = reject; }); return {resolve: a, reject: b, promise: c}; }); // ==UserScript== // @name Inject structuredClone() [major] Polyfill [98] // @version 0.0.1 // @match *://*/* // @run-at document-start // @grant none // ==/UserScript== 'use strict'; const VOID = -1; const PRIMITIVE = 0; const ARRAY = 1; const OBJECT = 2; const DATE = 3; const REGEXP = 4; const MAP = 5; const SET = 6; const ERROR = 7; const BIGINT = 8; // const SYMBOL = 9; const EMPTY = ''; const {toString} = {}; const {keys} = Object; const typeOf = value => { const type = typeof value; if (type !== 'object' || !value) return [PRIMITIVE, type]; const asString = toString.call(value).slice(8, -1); switch (asString) { case 'Array': return [ARRAY, EMPTY]; case 'Object': return [OBJECT, EMPTY]; case 'Date': return [DATE, EMPTY]; case 'RegExp': return [REGEXP, EMPTY]; case 'Map': return [MAP, EMPTY]; case 'Set': return [SET, EMPTY]; } if (asString.includes('Array')) return [ARRAY, asString]; if (asString.includes('Error')) return [ERROR, asString]; return [OBJECT, asString]; }; const shouldSkip = ([TYPE, type]) => ( TYPE === PRIMITIVE && (type === 'function' || type === 'symbol') ); const serializer = (strict, json, $, _) => { const as = (out, value) => { const index = _.push(out) - 1; $.set(value, index); return index; }; const pair = value => { if ($.has(value)) return $.get(value); let [TYPE, type] = typeOf(value); switch (TYPE) { case PRIMITIVE: { let entry = value; switch (type) { case 'bigint': TYPE = BIGINT; entry = value.toString(); break; case 'function': case 'symbol': if (strict) throw new TypeError('unable to serialize ' + type); entry = null; break; case 'undefined': return as([VOID], value); } return as([TYPE, entry], value); } case ARRAY: { if (type) return as([type, [...value]], value); const arr = []; const index = as([TYPE, arr], value); for (const entry of value) arr.push(pair(entry)); return index; } case OBJECT: { if (type) { switch (type) { case 'BigInt': return as([type, value.toString()], value); case 'Boolean': case 'Number': case 'String': return as([type, value.valueOf()], value); } } if (json && ('toJSON' in value)) return pair(value.toJSON()); const entries = []; const index = as([TYPE, entries], value); for (const key of keys(value)) { if (strict || !shouldSkip(typeOf(value[key]))) entries.push([pair(key), pair(value[key])]); } return index; } case DATE: return as([TYPE, value.toISOString()], value); case REGEXP: { const {source, flags} = value; return as([TYPE, {source, flags}], value); } case MAP: { const entries = []; const index = as([TYPE, entries], value); for (const [key, entry] of value) { if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry)))) entries.push([pair(key), pair(entry)]); } return index; } case SET: { const entries = []; const index = as([TYPE, entries], value); for (const entry of value) { if (strict || !shouldSkip(typeOf(entry))) entries.push(pair(entry)); } return index; } } const {message} = value; return as([TYPE, {name: type, message}], value); }; return pair; }; /** * @typedef {Array<string,any>} Record a type representation */ /** * Returns an array of serialized Records. * @param {any} value a serializable value. * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that, * if `true`, will not throw errors on incompatible types, and behave more * like JSON stringify would behave. Symbol and Function will be discarded. * @returns {Record[]} */ const serialize = (value, {json, lossy} = {}) => { const _ = []; return serializer(!(json || lossy), !!json, new Map, _)(value), _; }; const env = typeof self === 'object' ? self : globalThis; const deserializer = ($, _) => { const as = (out, index) => { $.set(index, out); return out; }; const unpair = index => { if ($.has(index)) return $.get(index); const [type, value] = _[index]; switch (type) { case PRIMITIVE: case VOID: return as(value, index); case ARRAY: { const arr = as([], index); for (const index of value) arr.push(unpair(index)); return arr; } case OBJECT: { const object = as({}, index); for (const [key, index] of value) object[unpair(key)] = unpair(index); return object; } case DATE: return as(new Date(value), index); case REGEXP: { const {source, flags} = value; return as(new RegExp(source, flags), index); } case MAP: { const map = as(new Map, index); for (const [key, index] of value) map.set(unpair(key), unpair(index)); return map; } case SET: { const set = as(new Set, index); for (const index of value) set.add(unpair(index)); return set; } case ERROR: { const {name, message} = value; return as(new env[name](message), index); } case BIGINT: return as(BigInt(value), index); case 'BigInt': return as(Object(BigInt(value)), index); } return as(new env[type](value), index); }; return unpair; }; /** * @typedef {Array<string,any>} Record a type representation */ /** * Returns a deserialized value from a serialized array of Records. * @param {Record[]} serialized a previously serialized value. * @returns {any} */ const deserialize = serialized => deserializer(new Map, serialized)(0); if (!("structuredClone" in env)) env.structuredClone = (any, options) => deserialize(serialize(any, options));

Agreed! But that doesn't mean America is the "only" country with this hallmark. Moving on... "Toodles"...

Any luck? I do not have a Discord account so cannot 'Add Friend'. I'm always curious of growing lists of needed polyfills.

<OT reply to OT which was in turn a reply to an OT instigated by an OT> That's the FUNNY part! People like to boast how "privacy-conscious" they are. But then they will jump through hoops to be "fingerprinted" to gain access to such websites. You may already have, without knowing it. Not to the extent of my "exaggeration-for-effect" scenario, of course. Germany has an extremly high crime rate, I have no doubt that Germans are "protecting what they own". https://www.dw.com/en/germany-violent-crime-reaches-15-year-high-report/a-68758122 https://worldpopulationreview.com/country-rankings/crime-rate-by-country

True! But whether we like it or not, what the website owner is protecting belongs to them as the owner and not to us as the user. No different than Homeowner A leaving the door unlocked 24/7 because the "odds" of somebody turning the doorknob to even check is "low". Versus Homeowner B with the door locked, two deadbolts, a sliding chain, and a shotgun aimed at the entrance with the trigger pulled by a string from anywhere in the house. edit - ie, owners are allowed to protect what they own

Dig deeper. Windows 2000 "collected basic system information for diagnostic and security purposes". By definition, that "collection" is a form of 'spying' (by today's standards if not by then-standards).