documentation technical

technology software

cryptocurrency blockchain

real estate property

government public service

English

Domain 'polyfill-fastly.net' uses the network infrastructure generic top-level domain (.net). Count 15 characters in 'polyfill-fastly' with 3 vowels and eleven consonants; bonus characters include one hyphen. Word splitting yields four words: poly, fill, fast, ly. Average segment length settles at four characters. No strong language cues emerged from the frequency lists.

html/91/e6/91e65d49-7f2b-4a31-8905-c45b3316146a_fallback.html.gz

Fastly Polyfill

callback

filter-polyfills

default

dom4

es2015

es2016

es2017

es2018

es2019

es2020

es2021

es2022

AbortController

AggregateError

Array.from

Array.isArray

Array.of

Array.prototype.@@iterator

Array.prototype.at

Array.prototype.copyWithin

Array.prototype.entries

Array.prototype.every

Array.prototype.fill

Array.prototype.filter

Array.prototype.find

Array.prototype.findIndex

Array.prototype.flat

Array.prototype.flatMap

Array.prototype.forEach

Array.prototype.includes

Array.prototype.indexOf

Array.prototype.keys

Array.prototype.lastIndexOf

Array.prototype.map

Array.prototype.reduce

Array.prototype.reduceRight

Array.prototype.some

Array.prototype.sort

Array.prototype.values

ArrayBuffer

ArrayBuffer.isView

AudioContext

Blob

CSS.supports

CustomEvent

DOMRect

DOMRect.fromRect

DOMTokenList

DOMTokenList.prototype.@@iterator

DOMTokenList.prototype.forEach

DOMTokenList.prototype.replace

Date.now

Date.prototype.toISOString

DocumentFragment

DocumentFragment.prototype.append

DocumentFragment.prototype.prepend

Element

Element.prototype.after

Element.prototype.append

Element.prototype.before

Element.prototype.classList

Element.prototype.cloneNode

Element.prototype.closest

Element.prototype.dataset

Element.prototype.getAttributeNames

Element.prototype.inert

Element.prototype.matches

Element.prototype.nextElementSibling

Element.prototype.placeholder

Element.prototype.prepend

Element.prototype.previousElementSibling

Element.prototype.remove

Element.prototype.replaceWith

Element.prototype.toggleAttribute

Event

Event.focusin

Event.hashchange

EventSource

Function.prototype.bind

Function.prototype.name

HTMLCanvasElement.prototype.toBlob

HTMLDocument

HTMLInputElement.prototype.valueAsDate

HTMLPictureElement

HTMLSelectElement.prototype.selectedOptions

HTMLTemplateElement

IntersectionObserver

IntersectionObserverEntry

Intl.DateTimeFormat

Intl.DateTimeFormat.~timeZone.all

Intl.DateTimeFormat.~timeZone.golden

Intl.DisplayNames

Intl.ListFormat

Intl.Locale

Intl.NumberFormat

Intl.PluralRules

html/91/e6/91e65d49-7f2b-4a31-8905-c45b3316146a.html.gz

Fastly Polyfill is a service which accepts a request for a set of browser features and returns only the polyfills that are needed by the requesting browser.

description

width=device-width, initial-scale=1, shrink-to-fit=no

viewport

HSTS header missing - vulnerable to protocol downgrade attacks

CSP header missing - vulnerable to XSS attacks

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;worker-src blob: 'self';frame-ancestors 'none';

child-src https:  chrome-untrusted://new-tab-page/ chrome-untrusted://ntp-microsoft-auth/;connect-src chrome://resources chrome://theme 'self';default-src 'self';font-src chrome://resources 'self';img-src chrome://resources chrome://theme chrome://image chrome://favicon2 chrome://app-icon chrome://extension-icon chrome://fileicon blob: data: 'self';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources chrome://webui-test 'self';style-src chrome://resources chrome://theme 'self' 'unsafe-inline';trusted-types parse-html-subset sanitize-inner-html static-types webui-test-script webui-test-html polymer-html-literal polymer-template-event-attribute-policy lit-html-desktop;frame-ancestors 'none';

child-src 'none';object-src 'none';require-trusted-types-for 'script';script-src chrome://resources 'self';trusted-types;frame-ancestors 'none';

base-uri 'none';child-src https:;form-action https://ogs.google.com https://*.corp.google.com;object-src 'none';script-src 'self' 'unsafe-inline' https:;frame-ancestors chrome://new-tab-page/

MarkMonitor Inc.

POLYFILL-FASTLY.NET

Abuse Account

Fastly RIR Administrator

Fastly Network Operations

Fastly, Inc.

SKYCA-3

/* eslint-env browser */
const createPolyfillBundleURL = options => {
	const parameters = {};

	const gated = options.gated ? true : false;
	const always = options.always ? true : false;

	if (gated && always) {
		parameters.flags = "gated,always";
	} else if (gated) {
		parameters.flags = "gated";
	} else if (always) {
		parameters.flags = "always";
	}

	if (options.version) {
		parameters.version = options.version;
	}

	if (options.callback) {
		parameters.callback = options.callback;
	}

	if (options.rum) {
		parameters.rum = options.rum;
	}

	if (options.features.length > 0) {
		parameters.features = options.features.join(",");
	}

	const minified = options.minified ? true : false;
	const extension = minified ? ".min.js" : ".js";

	return Object.keys(parameters).length > 0 ? `${location.protocol}//${location.host}/v3/polyfill${extension}?${new URLSearchParams(parameters).toString()}` : `${location.protocol}//${location.host}/v3/polyfill${extension}`;
};

const updatePolyfillBundle = options => {
	const bundleURLNode = document.querySelector("#polyfill-bundle-url");
	bundleURLNode.textContent = createPolyfillBundleURL(options);
};

const defaultPolyfillBundleOptions = {
	minified: true,
	gated: false,
	always: false,
	rum: 0,
	features: [],
	callback: "",
	version: ""
};

const polyfillBundleOptions = Object.assign({}, defaultPolyfillBundleOptions);

const renderFeatureList = ({ polyfillAliases, polyfills }) => {
	let html = "";
	for (const [alias, polyfills] of Object.entries(polyfillAliases)) {
		html += `<div class="feature">
            <label for="${alias}">
                <input type="checkbox" id="${alias}" name="${alias}">
                ${alias}
            </label>
            <details class="alias">
                <summary>Included Polyfills</summary>
                <ul>
                    ${polyfills.map(polyfill => `<li>${polyfill}</li>`).join('')}
                </ul>
            </details>
        </div>`;
	}
	for (const polyfill of polyfills) {
		html += `<div class="feature">
            <label for="${polyfill}">
                <input type="checkbox" id="${polyfill}" name="${polyfill}">
                ${polyfill}
            </label>
        </div>`;
	}
	return html;
};

const libraryVersionInput = document.querySelector("#library-version");
if (libraryVersionInput) {
	libraryVersionInput.addEventListener("change", async event => {
		const version = event.target.value;
		// if version is not selected, get the data for the latest version
		const response = await fetch(`/v3/json/library-${version || event.target.options[1].value}.json`);
		if (response.ok) {
			const data = await response.json();
			featuresList.innerHTML = renderFeatureList(data);
			[...featuresList.querySelectorAll("input")].forEach(node => {
				node.addEventListener("change", updateFeaturesListFromEvent);
			});
			polyfillBundleOptions.features = [];
			polyfillBundleOptions.version = version;
			updatePolyfillBundle(polyfillBundleOptions);

			// reset the polyfill name filter.
			document.querySelector("#filter-polyfills").value = '';
		}
	});
}

function featureNodes() {
	return [...document.querySelectorAll("#features-list .feature")]
}

function resetFeaturesList() {
	return featureNodes().forEach(function(node) {
		node.style.display="";
	});
}

function filterFeatures(event) {
	let inputValue = event.target.value;

	if (event.type === "paste") {
		const clipboardData = event.clipboardData || window.clipboardData;
		inputValue = clipboardData.getData("Text");
	}

	if (inputValue === "") {
		resetFeaturesList();
	} else {
		const featuresByName = {}
		const featuresRows = featureNodes();

		featuresRows.forEach(node => {
			featuresByName[node.children[0].getAttribute('for')] = node;
		});
		Object.entries(featuresByName).forEach(function([key, node]) {
			if (key.toLowerCase().includes(inputValue.toLowerCase())) {
				node.style.display="";
			} else {
				node.style.display="none";
			}
		});
	}
}

const filterInput = document.querySelector("#filter-polyfills");
filterInput?.addEventListener("keyup", filterFeatures);
filterInput?.addEventListener("paste", filterFeatures);

const callbackInput = document.querySelector("#callback");
callbackInput?.addEventListener("keyup", updateCallback);
callbackInput?.addEventListener("paste", updateCallback);

function updateCallback(event) {
	let inputValue = event.target.value;

	if (event.type === "paste") {
		const clipboardData = event.clipboardData || window.clipboardData;
		inputValue = clipboardData.getData("Text");
	}

	polyfillBundleOptions.callback = inputValue;
	updatePolyfillBundle(polyfillBundleOptions);
}

const addFeatureToList = (list, feature) => {
	if (!list.includes(feature)) {
		list.push(feature);
	}
};

const removeFeatureToList = (list, feature) => {
	const index = list.indexOf(feature);

	if (index !== -1) {
		list.splice(index, 1);
	}
};

const updateFeaturesListFromEvent = event => {
	if (event.target.checked) {
		addFeatureToList(polyfillBundleOptions.features, event.target.name);
	} else {
		removeFeatureToList(polyfillBundleOptions.features, event.target.name);
	}
	updatePolyfillBundle(polyfillBundleOptions);
};

const featuresList = document.querySelector("#features-list");
if (featuresList) {
	[...featuresList.querySelectorAll("input")].forEach(node => {
		node.addEventListener("change", updateFeaturesListFromEvent);
	});
}


'use strict';
    !function () {
        var e = {
            _scheme: 'auto',
            change: {
                light: '<i>Turn on dark mode</i>',
                dark: '<i>Turn off dark mode</i>'
            },
            buttonsTarget: '.theme-switcher',
            localStorageKey: 'picoPreferredColorScheme',
            init() {
                this.scheme = this.schemeFromLocalStorage,
                    this.initSwitchers()
            },
            get schemeFromLocalStorage() {
                return void 0 !== window.localStorage &&
                    null !== window.localStorage.getItem(this.localStorageKey) ? window.localStorage.getItem(this.localStorageKey) : this._scheme
            },
            get preferredColorScheme() {
                return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light'
            },
            initSwitchers() {
                document.querySelectorAll(this.buttonsTarget).forEach(e => {
                    e.addEventListener('click', () => {
                        'dark' == this.scheme ? this.scheme = 'light' : this.scheme = 'dark'
                    }, !1)
                })
            },
            addButton(e) {
                var t = document.createElement(e.tag);
                t.className = e.class,
                    document.querySelector(e.target).appendChild(t)
            },
            set scheme(e) {
                'auto' == e ? 'dark' == this.preferredColorScheme ? this._scheme = 'dark' : this._scheme = 'light' : 'dark' != e &&
                    'light' != e ||
                    (this._scheme = e),
                    this.applyScheme(),
                    this.schemeToLocalStorage()
            },
            get scheme() {
                return this._scheme
            },
            applyScheme() {
                document.querySelector('html').setAttribute('data-theme', this.scheme),
                    document.querySelectorAll(this.buttonsTarget).forEach(e => {
                        var t = 'dark' == this.scheme ? this.change.dark : this.change.light;
                        e.innerHTML = t,
                            e.setAttribute('aria-label', t.replace(/<[^>]*>?/gm, ''))
                    })
            },
            schemeToLocalStorage() {
                void 0 !== window.localStorage &&
                    window.localStorage.setItem(this.localStorageKey, this.scheme)
            }
        };
        e.addButton({
            tag: 'BUTTON',
            class: 'contrast switcher theme-switcher',
            target: 'body'
        }),
            e.init()
    }();

HSTS

✅ Low Risk - https://polyfill-fastly.net/

Security Scan: Fastly Polyfill

Requests	IP Address	Location	AS Autonomous System
3	151.101.129.91	San Francisco, California, United States	AS54113FASTLY
3	151.101.193.91	San Francisco, California, United States	AS54113FASTLY
0	151.101.65.91	San Francisco, California, United States	AS54113FASTLY
0	151.101.1.91	San Francisco, California, United States	AS54113FASTLY
0	2a04:4e42:400::347	United States	AS54113FASTLY
0	2a04:4e42::347	United States	AS54113FASTLY
0	2a04:4e42:200::347	United States	AS54113FASTLY
0	2a04:4e42:600::347	United States	AS54113FASTLY
3	8	-	-

Security Scan Report: polyfill-fastly.net

Summary

AI Security Verdict

Safe Website

Safety Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies1

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History