polyfill-library 4.6.0 → 4.7.0

package/polyfills/__dist/structuredClone/meta.json

@@ -0,0 +1 @@
+{"dependencies":["Map","Set","Object.keys","String.prototype.includes","RegExp.prototype.flags"],"spec":"https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone","docs":"https://developer.mozilla.org/en-US/docs/Web/API/structuredClone","license":"MIT","repo":"https://github.com/ungap/structured-clone/","notes":["This polyfill currently does not support cloning: Blob, File, FileList, ImageBitmap, ImageData, and ArrayBuffer. TypedArrays are supported without major issues, but int and uint 8/16/32 are the only safely supported TypedArrays."],"browsers":{"android":"*","bb":"*","chrome":"<98","edge":"*","edge_mob":"*","firefox":"<94","firefox_mob":"<94","ie":"*","ie_mob":"*","opera":"<84","op_mob":"<68","op_mini":"*","safari":"<15.4","ios_saf":"<15.4","samsung_mob":"<18.0"},"detectSource":"\"structuredClone\"in self&&\"function\"==typeof self.structuredClone\n","baseDir":"structuredClone","hasTests":true,"isTestable":true,"isPublic":true,"size":2490}

package/polyfills/__dist/structuredClone/min.js

@@ -0,0 +1 @@
+"use strict";!function(e){function r(r,n){function t(e,n){return r.set(n,e),e}function a(u){var s,b;if(r.has(u))return r.get(u);var m=n[u][0],y=n[u][1];switch(m){case i:case c:return t(y,u);case o:var O=t([],u);for(s=0,b=y.length;s<b;++s)O.push(a(y[s]));return O;case f:var S=t({},u),d=Object.keys(y);for(s=0,b=d.length;s<b;++s){var E=y[d[s]];S[a(E[0])]=a(E[1])}return S;case g:return t(new Date(y),u);case l:return t(new RegExp(y.source,y.flags),u);case h:var j=t(new Map,u);for(s=0,b=y.length;s<b;++s){var B=y[s];j.set(a(B[0]),a(B[1]))}return j;case v:var I=t(new Set,u);for(s=0,b=y.length;s<b;++s)I.add(a(y[s]));return I;case p:return t(new e[y.name](y.message),u);case w:return t(BigInt(y),u);case"BigInt":return t(Object(BigInt(y)),u)}return t(new e[m](y),u)}return a}function n(e){return r(new Map,e)(0)}function t(e){if(e instanceof Map)return[h,b];if(e instanceof Set)return[v,b];var r=typeof e;if("object"!==r||!e)return[i,r];var n=m.toString.call(e).slice(8,-1);switch(n){case"Array":return[o,b];case"Object":return[f,b];case"Date":return[g,b];case"RegExp":return[l,b]}return-1!==n.indexOf("Array")?[o,n]:-1!==n.indexOf("Error")?[p,n]:[f,n]}function a(e){return e[0]===i&&("function"===e[1]||"symbol"===e[1])}function u(e,r){function n(n,t){var a=r.push(n)-1;return e.set(t,a),a}function u(r){if(e.has(r))return e.get(r);var s,p,b,m=t(r),y=m[0],O=m[1];switch(y){case i:var S=r;switch(O){case"bigint":y=w,S=r.toString();break;case"function":case"symbol":throw new TypeError("unable to serialize "+O);case"undefined":return n([c],r)}return n([y,S],r);case o:var d=[],E=n([O||y,d],r);if(O)for(s=0,p=r.length;s<p;++s)d.push(r[s]);else for(s=0,p=r.length;s<p;++s)d.push(u(r[s]));return E;case f:if(O)switch(O){case"BigInt":return n([O,r.toString()],r);case"Boolean":case"Number":case"String":return n([O,r.valueOf()],r)}var j=[],B=n([y,j],r);for(b=Object.keys(r),s=0,p=b.length;s<p;++s){var I=b[s];a(t(r[I]))||j.push([u(I),u(r[I])])}return B;case g:return n([y,r.toISOString()],r);case l:return n([y,{source:r.source,flags:(r.global?"g":"")+(r.ignoreCase?"i":"")+(r.multiline?"m":"")}],r);case h:var x=[],M=n([y,x],r);return r.forEach(function(e,r){a(t(r))||a(t(e))||x.push([u(r),u(e)])}),M;case v:var k=[],A=n([y,k],r);return r.forEach(function(e){a(t(e))||k.push(u(e))}),A}return n([y,{name:O,message:r.message}],r)}return u}function s(e){var r=[];return u(new Map,r)(e),r}var c=-1,i=0,o=1,f=2,g=3,l=4,h=5,v=6,p=7,w=8,b="",m={};e.structuredClone=function e(r){return n(s(r))}}(self);

package/polyfills/__dist/structuredClone/raw.js

@@ -0,0 +1,279 @@
+
+// structuredClone
+/* global Map, Set, BigInt */
+"use strict";
+
+(function (env) {
+	var VOID = -1;
+	var PRIMITIVE = 0;
+	var ARRAY = 1;
+	var OBJECT = 2;
+	var DATE = 3;
+	var REGEXP = 4;
+	var MAP = 5;
+	var SET = 6;
+	var ERROR = 7;
+	var BIGINT = 8;
+
+	function deserializer($, _) {
+		function as(out, index) {
+			$.set(index, out);
+			return out;
+		}
+
+		function unpair(index) {
+			var i, l;
+
+			if ($.has(index)) {
+				return $.get(index);
+			}
+
+			var type = _[index][0];
+			var value = _[index][1];
+
+			switch (type) {
+				case PRIMITIVE:
+				case VOID:
+					return as(value, index);
+
+				case ARRAY: {
+					var arr = as([], index);
+					for (i = 0, l = value.length; i < l; ++i) {
+						arr.push(unpair(value[i]));
+					}
+					return arr;
+				}
+
+				case OBJECT: {
+					var object = as({}, index);
+					var keys = Object.keys(value);
+					for (i = 0, l = keys.length; i < l; ++i) {
+						var entry = value[keys[i]];
+						object[unpair(entry[0])] = unpair(entry[1]);
+					}
+
+					return object;
+				}
+
+				case DATE:
+					return as(new Date(value), index);
+
+				case REGEXP: {
+					return as(new RegExp(value.source, value.flags), index);
+				}
+
+				case MAP: {
+					var map = as(new Map(), index);
+					for (i = 0, l = value.length; i < l; ++i) {
+						var mapEntry = value[i];
+						map.set(unpair(mapEntry[0]), unpair(mapEntry[1]));
+					}
+
+					return map;
+				}
+
+				case SET: {
+					var set = as(new Set(), index);
+					for (i = 0, l = value.length; i < l; ++i) {
+						set.add(unpair(value[i]));
+					}
+					return set;
+				}
+
+				case ERROR: {
+					return as(new env[value.name](value.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;
+	}
+
+	function deserialize(serialized) {
+		return deserializer(new Map(), serialized)(0);
+	}
+
+	var EMPTY = "";
+	var emptyObject = {};
+
+	function typeOf(value) {
+		if (value instanceof Map) {
+			return [MAP, EMPTY];
+		}
+
+		if (value instanceof Set) {
+			return [SET, EMPTY];
+		}
+
+		var type = typeof value;
+		if (type !== "object" || !value) {
+			return [PRIMITIVE, type];
+		}
+
+		var asString = emptyObject.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];
+		}
+
+		if (asString.indexOf("Array") !== -1) {
+			return [ARRAY, asString];
+		}
+
+		if (asString.indexOf("Error") !== -1) {
+			return [ERROR, asString];
+		}
+
+		return [OBJECT, asString];
+	}
+
+	function shouldSkip(type) {
+		return type[0] === PRIMITIVE && (type[1] === "function" || type[1] === "symbol");
+	}
+
+	function serializer($, _) {
+		function as(out, value) {
+			var index = _.push(out) - 1;
+			$.set(value, index);
+			return index;
+		}
+
+		function pair(value) {
+			if ($.has(value)) {
+				return $.get(value);
+			}
+
+			var i, l, keys;
+			var to = typeOf(value);
+			var TYPE = to[0];
+			var typeName = to[1];
+
+			switch (TYPE) {
+				case PRIMITIVE: {
+					var primitiveValue = value;
+
+					switch (typeName) {
+						case "bigint":
+							TYPE = BIGINT;
+							primitiveValue = value.toString();
+							break;
+
+						case "function":
+						case "symbol":
+							throw new TypeError("unable to serialize " + typeName);
+
+						case "undefined":
+							return as([VOID], value);
+					}
+
+					return as([TYPE, primitiveValue], value);
+				}
+
+				case ARRAY: {
+					var arr = [];
+					var arrayIndex = as([typeName || TYPE, arr], value);
+
+					if (typeName) {
+						for (i = 0, l = value.length; i < l; ++i) {
+							arr.push(value[i]);
+						}
+
+					} else {
+						for (i = 0, l = value.length; i < l; ++i) {
+							arr.push(pair(value[i]));
+						}
+					}
+					return arrayIndex;
+				}
+
+				case OBJECT: {
+					if (typeName) {
+						switch (typeName) {
+							case "BigInt":
+								return as([typeName, value.toString()], value);
+
+							case "Boolean":
+							case "Number":
+							case "String":
+								return as([typeName, value.valueOf()], value);
+						}
+					}
+
+					var objectEntries = [];
+					var index = as([TYPE, objectEntries], value);
+					keys = Object.keys(value);
+					for (i = 0, l = keys.length; i < l; ++i) {
+						var objectKey = keys[i];
+						if (!shouldSkip(typeOf(value[objectKey]))) {
+							objectEntries.push([pair(objectKey), pair(value[objectKey])]);
+						}
+					}
+					return index;
+				}
+
+				case DATE:
+					return as([TYPE, value.toISOString()], value);
+
+				case REGEXP: {
+					return as([TYPE, {source: value.source, flags: (value.global ? "g" : "") + (value.ignoreCase ? "i" : "") + (value.multiline ? "m" : "")}], value);
+				}
+
+				case MAP: {
+					var mapEntries = [];
+					var mapIndex = as([TYPE, mapEntries], value);
+					value.forEach(function (value, key) {
+						if (!(shouldSkip(typeOf(key)) || shouldSkip(typeOf(value)))) {
+							mapEntries.push([pair(key), pair(value)]);
+						}
+					})
+
+					return mapIndex;
+				}
+
+				case SET: {
+					var setEntries = [];
+					var setIndex = as([TYPE, setEntries], value);
+					value.forEach(function (value) {
+						if (!shouldSkip(typeOf(value))) {
+							setEntries.push(pair(value));
+						}
+					})
+
+					return setIndex;
+				}
+			}
+
+			return as([TYPE, {name: typeName, message: value.message}], value);
+		}
+
+		return pair;
+	}
+
+	function serialize(value) {
+		var _ = [];
+		return serializer(new Map(), _)(value), _;
+	}
+
+	env.structuredClone = function structuredClone(any) {
+		return deserialize(serialize(any));
+	};
+
+})(self);