appscms-tools-theme 3.2.0 → 3.2.2

Sign up to get free protection for your applications and to get access to all the features.
Files changed (11) hide show
  1. checksums.yaml +4 -4
  2. data/_includes/head/index.html +1 -1
  3. data/assets/js/partytown/debug/partytown-atomics.js +908 -551
  4. data/assets/js/partytown/debug/partytown-sandbox-sw.js +900 -539
  5. data/assets/js/partytown/debug/partytown-ww-atomics.js +2617 -1794
  6. data/assets/js/partytown/debug/partytown-ww-sw.js +2609 -1786
  7. data/assets/js/partytown/debug/partytown.js +108 -69
  8. data/assets/js/partytown/partytown-atomics.js +599 -1
  9. data/assets/js/partytown/partytown-sw.js +49 -1
  10. data/assets/js/theme.js +44 -27
  11. metadata +2 -2
data/assets/js/partytown/debug/partytown-ww-sw.js CHANGED
@@ -1,1868 +1,2691 @@
1
1
  /* Partytown 0.7.5 - MIT builder.io */
2
- (self => {
3
- const WinIdKey = Symbol();
4
- const InstanceIdKey = Symbol();
5
- const InstanceDataKey = Symbol();
6
- const NamespaceKey = Symbol();
7
- const ApplyPathKey = Symbol();
8
- const InstanceStateKey = Symbol();
9
- const HookContinue = Symbol();
10
- const HookPrevent = Symbol();
11
- const webWorkerInstances = new Map;
12
- const webWorkerRefsByRefId = {};
13
- const webWorkerRefIdsByRef = new WeakMap;
14
- const postMessages = [];
15
- const webWorkerCtx = {};
16
- const webWorkerlocalStorage = new Map;
17
- const webWorkerSessionStorage = new Map;
18
- const environments = {};
19
- const cachedDimensions = new Map;
20
- const cachedStructure = new Map;
21
- const commaSplit = str => str.split(",");
22
- const partytownLibUrl = url => {
23
- url = webWorkerCtx.$libPath$ + url;
24
- if (new URL(url).origin != location.origin) {
25
- throw "Invalid " + url;
26
- }
27
- return url;
28
- };
29
- const getterDimensionPropNames = commaSplit("clientWidth,clientHeight,clientTop,clientLeft,innerWidth,innerHeight,offsetWidth,offsetHeight,offsetTop,offsetLeft,outerWidth,outerHeight,pageXOffset,pageYOffset,scrollWidth,scrollHeight,scrollTop,scrollLeft");
30
- const elementStructurePropNames = commaSplit("childElementCount,children,firstElementChild,lastElementChild,nextElementSibling,previousElementSibling");
31
- const structureChangingMethodNames = commaSplit("insertBefore,remove,removeChild,replaceChild");
32
- const dimensionChangingSetterNames = commaSplit("className,width,height,hidden,innerHTML,innerText,textContent");
33
- const dimensionChangingMethodNames = commaSplit("setAttribute,setAttributeNS,setProperty");
34
- const eventTargetMethods = commaSplit("addEventListener,dispatchEvent,removeEventListener");
35
- const nonBlockingMethods = eventTargetMethods.concat(dimensionChangingMethodNames, commaSplit("add,observe,remove,unobserve"));
36
- const IS_TAG_REG = /^[A-Z_]([A-Z0-9-]*[A-Z0-9])?$/;
37
- const noop = () => {};
38
- const len = obj => obj.length;
39
- const getConstructorName = obj => {
40
- var _a, _b, _c;
41
- try {
42
- const constructorName = null === (_a = null == obj ? void 0 : obj.constructor) || void 0 === _a ? void 0 : _a.name;
43
- if (constructorName) {
44
- return constructorName;
45
- }
46
- } catch (e) {}
47
- try {
48
- const zoneJsConstructorName = null === (_c = null === (_b = null == obj ? void 0 : obj.__zone_symbol__originalInstance) || void 0 === _b ? void 0 : _b.constructor) || void 0 === _c ? void 0 : _c.name;
49
- if (zoneJsConstructorName) {
50
- return zoneJsConstructorName;
51
- }
52
- } catch (e) {}
53
- return "";
54
- };
55
- const EMPTY_ARRAY = [];
56
- const randomId = () => Math.round(Math.random() * Number.MAX_SAFE_INTEGER).toString(36);
57
- const SCRIPT_TYPE = "text/partytown";
58
- const defineProperty = (obj, memberName, descriptor) => Object.defineProperty(obj, memberName, {
59
- ...descriptor,
60
- configurable: true
2
+ ((self) => {
3
+ const WinIdKey = Symbol();
4
+ const InstanceIdKey = Symbol();
5
+ const InstanceDataKey = Symbol();
6
+ const NamespaceKey = Symbol();
7
+ const ApplyPathKey = Symbol();
8
+ const InstanceStateKey = Symbol();
9
+ const HookContinue = Symbol();
10
+ const HookPrevent = Symbol();
11
+ const webWorkerInstances = new Map();
12
+ const webWorkerRefsByRefId = {};
13
+ const webWorkerRefIdsByRef = new WeakMap();
14
+ const postMessages = [];
15
+ const webWorkerCtx = {};
16
+ const webWorkerlocalStorage = new Map();
17
+ const webWorkerSessionStorage = new Map();
18
+ const environments = {};
19
+ const cachedDimensions = new Map();
20
+ const cachedStructure = new Map();
21
+ const commaSplit = (str) => str.split(",");
22
+ const partytownLibUrl = (url) => {
23
+ url = webWorkerCtx.$libPath$ + url;
24
+ if (new URL(url).origin != location.origin) {
25
+ throw "Invalid " + url;
26
+ }
27
+ return url;
28
+ };
29
+ const getterDimensionPropNames = commaSplit(
30
+ "clientWidth,clientHeight,clientTop,clientLeft,innerWidth,innerHeight,offsetWidth,offsetHeight,offsetTop,offsetLeft,outerWidth,outerHeight,pageXOffset,pageYOffset,scrollWidth,scrollHeight,scrollTop,scrollLeft"
31
+ );
32
+ const elementStructurePropNames = commaSplit(
33
+ "childElementCount,children,firstElementChild,lastElementChild,nextElementSibling,previousElementSibling"
34
+ );
35
+ const structureChangingMethodNames = commaSplit(
36
+ "insertBefore,remove,removeChild,replaceChild"
37
+ );
38
+ const dimensionChangingSetterNames = commaSplit(
39
+ "className,width,height,hidden,innerHTML,innerText,textContent"
40
+ );
41
+ const dimensionChangingMethodNames = commaSplit(
42
+ "setAttribute,setAttributeNS,setProperty"
43
+ );
44
+ const eventTargetMethods = commaSplit(
45
+ "addEventListener,dispatchEvent,removeEventListener"
46
+ );
47
+ const nonBlockingMethods = eventTargetMethods.concat(
48
+ dimensionChangingMethodNames,
49
+ commaSplit("add,observe,remove,unobserve")
50
+ );
51
+ const IS_TAG_REG = /^[A-Z_]([A-Z0-9-]*[A-Z0-9])?$/;
52
+ const noop = () => {};
53
+ const len = (obj) => obj.length;
54
+ const getConstructorName = (obj) => {
55
+ var _a, _b, _c;
56
+ try {
57
+ const constructorName =
58
+ null === (_a = null == obj ? void 0 : obj.constructor) || void 0 === _a
59
+ ? void 0
60
+ : _a.name;
61
+ if (constructorName) {
62
+ return constructorName;
63
+ }
64
+ } catch (e) {}
65
+ try {
66
+ const zoneJsConstructorName =
67
+ null ===
68
+ (_c =
69
+ null ===
70
+ (_b =
71
+ null == obj ? void 0 : obj.__zone_symbol__originalInstance) ||
72
+ void 0 === _b
73
+ ? void 0
74
+ : _b.constructor) || void 0 === _c
75
+ ? void 0
76
+ : _c.name;
77
+ if (zoneJsConstructorName) {
78
+ return zoneJsConstructorName;
79
+ }
80
+ } catch (e) {}
81
+ return "";
82
+ };
83
+ const EMPTY_ARRAY = [];
84
+ const randomId = () =>
85
+ Math.round(Math.random() * Number.MAX_SAFE_INTEGER).toString(36);
86
+ const SCRIPT_TYPE = "text/partytown";
87
+ const defineProperty = (obj, memberName, descriptor) =>
88
+ Object.defineProperty(obj, memberName, {
89
+ ...descriptor,
90
+ configurable: true,
61
91
  });
62
- const defineConstructorName = (Cstr, value) => defineProperty(Cstr, "name", {
63
- value: value
92
+ const defineConstructorName = (Cstr, value) =>
93
+ defineProperty(Cstr, "name", {
94
+ value: value,
64
95
  });
65
- const definePrototypeProperty = (Cstr, memberName, descriptor) => defineProperty(Cstr.prototype, memberName, descriptor);
66
- const definePrototypePropertyDescriptor = (Cstr, propertyDescriptorMap) => Object.defineProperties(Cstr.prototype, propertyDescriptorMap);
67
- const definePrototypeValue = (Cstr, memberName, value) => definePrototypeProperty(Cstr, memberName, {
68
- value: value,
69
- writable: true
96
+ const definePrototypeProperty = (Cstr, memberName, descriptor) =>
97
+ defineProperty(Cstr.prototype, memberName, descriptor);
98
+ const definePrototypePropertyDescriptor = (Cstr, propertyDescriptorMap) =>
99
+ Object.defineProperties(Cstr.prototype, propertyDescriptorMap);
100
+ const definePrototypeValue = (Cstr, memberName, value) =>
101
+ definePrototypeProperty(Cstr, memberName, {
102
+ value: value,
103
+ writable: true,
70
104
  });
71
- const hasInstanceStateValue = (instance, stateKey) => stateKey in instance[InstanceStateKey];
72
- const getInstanceStateValue = (instance, stateKey) => instance[InstanceStateKey][stateKey];
73
- const setInstanceStateValue = (instance, stateKey, stateValue) => instance[InstanceStateKey][stateKey] = stateValue;
74
- const setWorkerRef = (ref, refId) => {
75
- if (!(refId = webWorkerRefIdsByRef.get(ref))) {
76
- webWorkerRefIdsByRef.set(ref, refId = randomId());
77
- webWorkerRefsByRefId[refId] = ref;
78
- }
79
- return refId;
80
- };
81
- const getOrCreateNodeInstance = (winId, instanceId, nodeName, namespace, instance) => {
82
- instance = webWorkerInstances.get(instanceId);
83
- if (!instance && nodeName && environments[winId]) {
84
- instance = environments[winId].$createNode$(nodeName, instanceId, namespace);
85
- webWorkerInstances.set(instanceId, instance);
86
- }
87
- return instance;
88
- };
89
- const definePrototypeNodeType = (Cstr, nodeType) => definePrototypeValue(Cstr, "nodeType", nodeType);
90
- const cachedTreeProps = (Cstr, treeProps) => treeProps.map((propName => definePrototypeProperty(Cstr, propName, {
105
+ const hasInstanceStateValue = (instance, stateKey) =>
106
+ stateKey in instance[InstanceStateKey];
107
+ const getInstanceStateValue = (instance, stateKey) =>
108
+ instance[InstanceStateKey][stateKey];
109
+ const setInstanceStateValue = (instance, stateKey, stateValue) =>
110
+ (instance[InstanceStateKey][stateKey] = stateValue);
111
+ const setWorkerRef = (ref, refId) => {
112
+ if (!(refId = webWorkerRefIdsByRef.get(ref))) {
113
+ webWorkerRefIdsByRef.set(ref, (refId = randomId()));
114
+ webWorkerRefsByRefId[refId] = ref;
115
+ }
116
+ return refId;
117
+ };
118
+ const getOrCreateNodeInstance = (
119
+ winId,
120
+ instanceId,
121
+ nodeName,
122
+ namespace,
123
+ instance
124
+ ) => {
125
+ instance = webWorkerInstances.get(instanceId);
126
+ if (!instance && nodeName && environments[winId]) {
127
+ instance = environments[winId].$createNode$(
128
+ nodeName,
129
+ instanceId,
130
+ namespace
131
+ );
132
+ webWorkerInstances.set(instanceId, instance);
133
+ }
134
+ return instance;
135
+ };
136
+ const definePrototypeNodeType = (Cstr, nodeType) =>
137
+ definePrototypeValue(Cstr, "nodeType", nodeType);
138
+ const cachedTreeProps = (Cstr, treeProps) =>
139
+ treeProps.map((propName) =>
140
+ definePrototypeProperty(Cstr, propName, {
91
141
  get() {
92
- let cacheKey = getInstanceCacheKey(this, propName);
93
- let result = cachedStructure.get(cacheKey);
94
- if (!result) {
95
- result = getter(this, [ propName ]);
96
- cachedStructure.set(cacheKey, result);
97
- }
98
- return result;
99
- }
100
- })));
101
- const getInstanceCacheKey = (instance, memberName, args) => [ instance[WinIdKey], instance[InstanceIdKey], memberName, ...(args || EMPTY_ARRAY).map((arg => String(arg && arg[WinIdKey] ? arg[InstanceIdKey] : arg))) ].join(".");
102
- const cachedProps = (Cstr, propNames) => commaSplit(propNames).map((propName => definePrototypeProperty(Cstr, propName, {
142
+ let cacheKey = getInstanceCacheKey(this, propName);
143
+ let result = cachedStructure.get(cacheKey);
144
+ if (!result) {
145
+ result = getter(this, [propName]);
146
+ cachedStructure.set(cacheKey, result);
147
+ }
148
+ return result;
149
+ },
150
+ })
151
+ );
152
+ const getInstanceCacheKey = (instance, memberName, args) =>
153
+ [
154
+ instance[WinIdKey],
155
+ instance[InstanceIdKey],
156
+ memberName,
157
+ ...(args || EMPTY_ARRAY).map((arg) =>
158
+ String(arg && arg[WinIdKey] ? arg[InstanceIdKey] : arg)
159
+ ),
160
+ ].join(".");
161
+ const cachedProps = (Cstr, propNames) =>
162
+ commaSplit(propNames).map((propName) =>
163
+ definePrototypeProperty(Cstr, propName, {
103
164
  get() {
104
- hasInstanceStateValue(this, propName) || setInstanceStateValue(this, propName, getter(this, [ propName ]));
105
- return getInstanceStateValue(this, propName);
165
+ hasInstanceStateValue(this, propName) ||
166
+ setInstanceStateValue(this, propName, getter(this, [propName]));
167
+ return getInstanceStateValue(this, propName);
106
168
  },
107
169
  set(val) {
108
- getInstanceStateValue(this, propName) !== val && setter(this, [ propName ], val);
109
- setInstanceStateValue(this, propName, val);
110
- }
111
- })));
112
- const cachedDimensionProps = Cstr => getterDimensionPropNames.map((propName => definePrototypeProperty(Cstr, propName, {
170
+ getInstanceStateValue(this, propName) !== val &&
171
+ setter(this, [propName], val);
172
+ setInstanceStateValue(this, propName, val);
173
+ },
174
+ })
175
+ );
176
+ const cachedDimensionProps = (Cstr) =>
177
+ getterDimensionPropNames.map((propName) =>
178
+ definePrototypeProperty(Cstr, propName, {
113
179
  get() {
114
- const dimension = cachedDimensions.get(getInstanceCacheKey(this, propName));
115
- if ("number" == typeof dimension) {
116
- return dimension;
117
- }
118
- const groupedDimensions = getter(this, [ propName ], getterDimensionPropNames);
119
- if (groupedDimensions && "object" == typeof groupedDimensions) {
120
- Object.entries(groupedDimensions).map((([dimensionPropName, value]) => cachedDimensions.set(getInstanceCacheKey(this, dimensionPropName), value)));
121
- return groupedDimensions[propName];
122
- }
123
- return groupedDimensions;
124
- }
125
- })));
126
- const cachedDimensionMethods = (Cstr, dimensionMethodNames) => dimensionMethodNames.map((methodName => {
127
- Cstr.prototype[methodName] = function(...args) {
128
- let cacheKey = getInstanceCacheKey(this, methodName, args);
129
- let dimensions = cachedDimensions.get(cacheKey);
130
- if (!dimensions) {
131
- dimensions = callMethod(this, [ methodName ], args);
132
- cachedDimensions.set(cacheKey, dimensions);
133
- }
134
- return dimensions;
135
- };
136
- }));
137
- const serializeForMain = ($winId$, $instanceId$, value, added, type) => void 0 !== value && (type = typeof value) ? "string" === type || "boolean" === type || "number" === type || null == value ? [ 0, value ] : "function" === type ? [ 4, {
138
- $winId$: $winId$,
139
- $instanceId$: $instanceId$,
140
- $refId$: setWorkerRef(value)
141
- } ] : (added = added || new Set) && Array.isArray(value) ? added.has(value) ? [ 1, [] ] : added.add(value) && [ 1, value.map((v => serializeForMain($winId$, $instanceId$, v, added))) ] : "object" === type ? value[InstanceIdKey] ? [ 3, [ value[WinIdKey], value[InstanceIdKey] ] ] : value instanceof Event ? [ 5, serializeObjectForMain($winId$, $instanceId$, value, false, added) ] : supportsTrustedHTML && value instanceof TrustedHTML ? [ 0, value.toString() ] : value instanceof ArrayBuffer ? [ 8, value ] : ArrayBuffer.isView(value) ? [ 9, value.buffer, getConstructorName(value) ] : [ 2, serializeObjectForMain($winId$, $instanceId$, value, true, added) ] : void 0 : value;
142
- const supportsTrustedHTML = "undefined" != typeof TrustedHTML;
143
- const serializeObjectForMain = (winId, instanceId, obj, includeFunctions, added, serializedObj, propName, propValue) => {
144
- serializedObj = {};
145
- if (!added.has(obj)) {
146
- added.add(obj);
147
- for (propName in obj) {
148
- propValue = obj[propName];
149
- (includeFunctions || "function" != typeof propValue) && (serializedObj[propName] = serializeForMain(winId, instanceId, propValue, added));
150
- }
151
- }
152
- return serializedObj;
153
- };
154
- const serializeInstanceForMain = (instance, value) => instance ? serializeForMain(instance[WinIdKey], instance[InstanceIdKey], value) : [ 0, value ];
155
- const deserializeFromMain = (winId, instanceId, applyPath, serializedValueTransfer, serializedType, serializedValue, obj, key) => {
156
- if (serializedValueTransfer) {
157
- serializedType = serializedValueTransfer[0];
158
- serializedValue = serializedValueTransfer[1];
159
- if (0 === serializedType || 11 === serializedType || 12 === serializedType) {
160
- return serializedValue;
161
- }
162
- if (4 === serializedType) {
163
- return deserializeRefFromMain(applyPath, serializedValue);
164
- }
165
- if (6 === serializedType) {
166
- return winId && applyPath.length > 0 ? (...args) => callMethod(environments[winId].$window$, applyPath, args, 1) : noop;
167
- }
168
- if (3 === serializedType) {
169
- return getOrCreateSerializedInstance(serializedValue);
170
- }
171
- if (7 === serializedType) {
172
- return new NodeList(serializedValue.map(getOrCreateSerializedInstance));
173
- }
174
- if (10 === serializedType) {
175
- return new Attr(serializedValue);
176
- }
177
- if (1 === serializedType) {
178
- return serializedValue.map((v => deserializeFromMain(winId, instanceId, applyPath, v)));
179
- }
180
- if (14 === serializedType) {
181
- return new CustomError(serializedValue);
182
- }
183
- obj = {};
184
- for (key in serializedValue) {
185
- obj[key] = deserializeFromMain(winId, instanceId, [ ...applyPath, key ], serializedValue[key]);
186
- }
187
- if (13 === serializedType) {
188
- return new environments[winId].$window$.CSSStyleDeclaration(winId, instanceId, applyPath, obj);
189
- }
190
- if (5 === serializedType) {
191
- if ("message" === obj.type && obj.origin) {
192
- let postMessageKey = JSON.stringify(obj.data);
193
- let postMessageData = postMessages.find((pm => pm.$data$ === postMessageKey));
194
- let env;
195
- if (postMessageData) {
196
- env = environments[postMessageData.$winId$];
197
- if (env) {
198
- obj.source = env.$window$;
199
- obj.origin = env.$location$.origin;
200
- }
201
- }
202
- }
203
- return new Proxy(new Event(obj.type, obj), {
204
- get: (target, propName) => propName in obj ? obj[propName] : "function" == typeof target[String(propName)] ? noop : target[String(propName)]
205
- });
206
- }
207
- if (2 === serializedType) {
208
- return obj;
209
- }
210
- }
211
- };
212
- const getOrCreateSerializedInstance = ([winId, instanceId, nodeName]) => instanceId === winId && environments[winId] ? environments[winId].$window$ : getOrCreateNodeInstance(winId, instanceId, nodeName);
213
- const deserializeRefFromMain = (applyPath, {$winId$: $winId$, $instanceId$: $instanceId$, $nodeName$: $nodeName$, $refId$: $refId$}) => {
214
- webWorkerRefsByRefId[$refId$] || webWorkerRefIdsByRef.set(webWorkerRefsByRefId[$refId$] = function(...args) {
215
- const instance = getOrCreateNodeInstance($winId$, $instanceId$, $nodeName$);
216
- return callMethod(instance, applyPath, args);
217
- }, $refId$);
218
- return webWorkerRefsByRefId[$refId$];
219
- };
220
- class CustomError extends Error {
221
- constructor(errorObject) {
222
- super(errorObject.message);
223
- this.name = errorObject.name;
224
- this.message = errorObject.message;
225
- this.stack = errorObject.stack;
180
+ const dimension = cachedDimensions.get(
181
+ getInstanceCacheKey(this, propName)
182
+ );
183
+ if ("number" == typeof dimension) {
184
+ return dimension;
185
+ }
186
+ const groupedDimensions = getter(
187
+ this,
188
+ [propName],
189
+ getterDimensionPropNames
190
+ );
191
+ if (groupedDimensions && "object" == typeof groupedDimensions) {
192
+ Object.entries(groupedDimensions).map(
193
+ ([dimensionPropName, value]) =>
194
+ cachedDimensions.set(
195
+ getInstanceCacheKey(this, dimensionPropName),
196
+ value
197
+ )
198
+ );
199
+ return groupedDimensions[propName];
200
+ }
201
+ return groupedDimensions;
202
+ },
203
+ })
204
+ );
205
+ const cachedDimensionMethods = (Cstr, dimensionMethodNames) =>
206
+ dimensionMethodNames.map((methodName) => {
207
+ Cstr.prototype[methodName] = function (...args) {
208
+ let cacheKey = getInstanceCacheKey(this, methodName, args);
209
+ let dimensions = cachedDimensions.get(cacheKey);
210
+ if (!dimensions) {
211
+ dimensions = callMethod(this, [methodName], args);
212
+ cachedDimensions.set(cacheKey, dimensions);
226
213
  }
214
+ return dimensions;
215
+ };
216
+ });
217
+ const serializeForMain = ($winId$, $instanceId$, value, added, type) =>
218
+ void 0 !== value && (type = typeof value)
219
+ ? "string" === type ||
220
+ "boolean" === type ||
221
+ "number" === type ||
222
+ null == value
223
+ ? [0, value]
224
+ : "function" === type
225
+ ? [
226
+ 4,
227
+ {
228
+ $winId$: $winId$,
229
+ $instanceId$: $instanceId$,
230
+ $refId$: setWorkerRef(value),
231
+ },
232
+ ]
233
+ : (added = added || new Set()) && Array.isArray(value)
234
+ ? added.has(value)
235
+ ? [1, []]
236
+ : added.add(value) && [
237
+ 1,
238
+ value.map((v) =>
239
+ serializeForMain($winId$, $instanceId$, v, added)
240
+ ),
241
+ ]
242
+ : "object" === type
243
+ ? value[InstanceIdKey]
244
+ ? [3, [value[WinIdKey], value[InstanceIdKey]]]
245
+ : value instanceof Event
246
+ ? [
247
+ 5,
248
+ serializeObjectForMain(
249
+ $winId$,
250
+ $instanceId$,
251
+ value,
252
+ false,
253
+ added
254
+ ),
255
+ ]
256
+ : supportsTrustedHTML && value instanceof TrustedHTML
257
+ ? [0, value.toString()]
258
+ : value instanceof ArrayBuffer
259
+ ? [8, value]
260
+ : ArrayBuffer.isView(value)
261
+ ? [9, value.buffer, getConstructorName(value)]
262
+ : [
263
+ 2,
264
+ serializeObjectForMain($winId$, $instanceId$, value, true, added),
265
+ ]
266
+ : void 0
267
+ : value;
268
+ const supportsTrustedHTML = "undefined" != typeof TrustedHTML;
269
+ const serializeObjectForMain = (
270
+ winId,
271
+ instanceId,
272
+ obj,
273
+ includeFunctions,
274
+ added,
275
+ serializedObj,
276
+ propName,
277
+ propValue
278
+ ) => {
279
+ serializedObj = {};
280
+ if (!added.has(obj)) {
281
+ added.add(obj);
282
+ for (propName in obj) {
283
+ propValue = obj[propName];
284
+ (includeFunctions || "function" != typeof propValue) &&
285
+ (serializedObj[propName] = serializeForMain(
286
+ winId,
287
+ instanceId,
288
+ propValue,
289
+ added
290
+ ));
291
+ }
227
292
  }
228
- class NodeList {
229
- constructor(nodes) {
230
- (this._ = nodes).map(((node, index) => this[index] = node));
231
- }
232
- entries() {
233
- return this._.entries();
234
- }
235
- forEach(cb, thisArg) {
236
- this._.map(cb, thisArg);
237
- }
238
- item(index) {
239
- return this[index];
240
- }
241
- keys() {
242
- return this._.keys();
243
- }
244
- get length() {
245
- return len(this._);
246
- }
247
- values() {
248
- return this._.values();
249
- }
250
- [Symbol.iterator]() {
251
- return this._[Symbol.iterator]();
293
+ return serializedObj;
294
+ };
295
+ const serializeInstanceForMain = (instance, value) =>
296
+ instance
297
+ ? serializeForMain(instance[WinIdKey], instance[InstanceIdKey], value)
298
+ : [0, value];
299
+ const deserializeFromMain = (
300
+ winId,
301
+ instanceId,
302
+ applyPath,
303
+ serializedValueTransfer,
304
+ serializedType,
305
+ serializedValue,
306
+ obj,
307
+ key
308
+ ) => {
309
+ if (serializedValueTransfer) {
310
+ serializedType = serializedValueTransfer[0];
311
+ serializedValue = serializedValueTransfer[1];
312
+ if (
313
+ 0 === serializedType ||
314
+ 11 === serializedType ||
315
+ 12 === serializedType
316
+ ) {
317
+ return serializedValue;
318
+ }
319
+ if (4 === serializedType) {
320
+ return deserializeRefFromMain(applyPath, serializedValue);
321
+ }
322
+ if (6 === serializedType) {
323
+ return winId && applyPath.length > 0
324
+ ? (...args) =>
325
+ callMethod(environments[winId].$window$, applyPath, args, 1)
326
+ : noop;
327
+ }
328
+ if (3 === serializedType) {
329
+ return getOrCreateSerializedInstance(serializedValue);
330
+ }
331
+ if (7 === serializedType) {
332
+ return new NodeList(serializedValue.map(getOrCreateSerializedInstance));
333
+ }
334
+ if (10 === serializedType) {
335
+ return new Attr(serializedValue);
336
+ }
337
+ if (1 === serializedType) {
338
+ return serializedValue.map((v) =>
339
+ deserializeFromMain(winId, instanceId, applyPath, v)
340
+ );
341
+ }
342
+ if (14 === serializedType) {
343
+ return new CustomError(serializedValue);
344
+ }
345
+ obj = {};
346
+ for (key in serializedValue) {
347
+ obj[key] = deserializeFromMain(
348
+ winId,
349
+ instanceId,
350
+ [...applyPath, key],
351
+ serializedValue[key]
352
+ );
353
+ }
354
+ if (13 === serializedType) {
355
+ return new environments[winId].$window$.CSSStyleDeclaration(
356
+ winId,
357
+ instanceId,
358
+ applyPath,
359
+ obj
360
+ );
361
+ }
362
+ if (5 === serializedType) {
363
+ if ("message" === obj.type && obj.origin) {
364
+ let postMessageKey = JSON.stringify(obj.data);
365
+ let postMessageData = postMessages.find(
366
+ (pm) => pm.$data$ === postMessageKey
367
+ );
368
+ let env;
369
+ if (postMessageData) {
370
+ env = environments[postMessageData.$winId$];
371
+ if (env) {
372
+ obj.source = env.$window$;
373
+ obj.origin = env.$location$.origin;
374
+ }
375
+ }
252
376
  }
377
+ return new Proxy(new Event(obj.type, obj), {
378
+ get: (target, propName) =>
379
+ propName in obj
380
+ ? obj[propName]
381
+ : "function" == typeof target[String(propName)]
382
+ ? noop
383
+ : target[String(propName)],
384
+ });
385
+ }
386
+ if (2 === serializedType) {
387
+ return obj;
388
+ }
389
+ }
390
+ };
391
+ const getOrCreateSerializedInstance = ([winId, instanceId, nodeName]) =>
392
+ instanceId === winId && environments[winId]
393
+ ? environments[winId].$window$
394
+ : getOrCreateNodeInstance(winId, instanceId, nodeName);
395
+ const deserializeRefFromMain = (
396
+ applyPath,
397
+ {
398
+ $winId$: $winId$,
399
+ $instanceId$: $instanceId$,
400
+ $nodeName$: $nodeName$,
401
+ $refId$: $refId$,
402
+ }
403
+ ) => {
404
+ webWorkerRefsByRefId[$refId$] ||
405
+ webWorkerRefIdsByRef.set(
406
+ (webWorkerRefsByRefId[$refId$] = function (...args) {
407
+ const instance = getOrCreateNodeInstance(
408
+ $winId$,
409
+ $instanceId$,
410
+ $nodeName$
411
+ );
412
+ return callMethod(instance, applyPath, args);
413
+ }),
414
+ $refId$
415
+ );
416
+ return webWorkerRefsByRefId[$refId$];
417
+ };
418
+ class CustomError extends Error {
419
+ constructor(errorObject) {
420
+ super(errorObject.message);
421
+ this.name = errorObject.name;
422
+ this.message = errorObject.message;
423
+ this.stack = errorObject.stack;
424
+ }
425
+ }
426
+ class NodeList {
427
+ constructor(nodes) {
428
+ (this._ = nodes).map((node, index) => (this[index] = node));
429
+ }
430
+ entries() {
431
+ return this._.entries();
432
+ }
433
+ forEach(cb, thisArg) {
434
+ this._.map(cb, thisArg);
435
+ }
436
+ item(index) {
437
+ return this[index];
438
+ }
439
+ keys() {
440
+ return this._.keys();
441
+ }
442
+ get length() {
443
+ return len(this._);
444
+ }
445
+ values() {
446
+ return this._.values();
253
447
  }
254
- const Attr = class {
255
- constructor(serializedAttr) {
256
- this.name = serializedAttr[0];
257
- this.value = serializedAttr[1];
448
+ [Symbol.iterator]() {
449
+ return this._[Symbol.iterator]();
450
+ }
451
+ }
452
+ const Attr = class {
453
+ constructor(serializedAttr) {
454
+ this.name = serializedAttr[0];
455
+ this.value = serializedAttr[1];
456
+ }
457
+ get nodeName() {
458
+ return this.name;
459
+ }
460
+ get nodeType() {
461
+ return 2;
462
+ }
463
+ };
464
+ const warnCrossOrgin = (apiType, apiName, env) =>
465
+ console.warn(
466
+ `Partytown unable to ${apiType} cross-origin ${apiName}: ` +
467
+ env.$location$
468
+ );
469
+ const logWorker = (msg, winId) => {
470
+ try {
471
+ const config = webWorkerCtx.$config$;
472
+ if (config.logStackTraces) {
473
+ const frames = new Error().stack.split("\n");
474
+ const i = frames.findIndex((f) => f.includes("logWorker"));
475
+ msg += "\n" + frames.slice(i + 1).join("\n");
476
+ }
477
+ let prefix;
478
+ let color;
479
+ if (winId) {
480
+ prefix = `Worker (${normalizedWinId(winId)}) 🎉`;
481
+ color = winColor(winId);
482
+ } else {
483
+ prefix = self.name;
484
+ color = "#9844bf";
485
+ }
486
+ if (webWorkerCtx.lastLog !== msg) {
487
+ webWorkerCtx.lastLog = msg;
488
+ console.debug.apply(console, [
489
+ `%c${prefix}`,
490
+ `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`,
491
+ msg,
492
+ ]);
493
+ }
494
+ } catch (e) {}
495
+ };
496
+ const winIds = [];
497
+ const normalizedWinId = (winId) => {
498
+ winIds.includes(winId) || winIds.push(winId);
499
+ return winIds.indexOf(winId) + 1;
500
+ };
501
+ const winColor = (winId) => {
502
+ const colors = ["#00309e", "#ea3655", "#eea727"];
503
+ const index = normalizedWinId(winId) - 1;
504
+ return colors[index] || colors[colors.length - 1];
505
+ };
506
+ const getTargetProp = (target, applyPath) => {
507
+ let n = "";
508
+ if (target) {
509
+ const cstrName = getConstructorName(target);
510
+ if ("Window" === cstrName) {
511
+ n = "";
512
+ } else if ("string" == typeof target[InstanceDataKey]) {
513
+ let nodeName = target[InstanceDataKey];
514
+ n =
515
+ "#text" === nodeName
516
+ ? "textNode."
517
+ : "#comment" === nodeName
518
+ ? "commentNode."
519
+ : "#document" === nodeName
520
+ ? "document."
521
+ : "html" === nodeName
522
+ ? "doctype."
523
+ : nodeName.toLowerCase() + ".";
524
+ } else {
525
+ n =
526
+ "nodeType" in target && 2 === target.nodeType
527
+ ? "attributes."
528
+ : "CanvasRenderingContext2D" === cstrName
529
+ ? "context2D."
530
+ : "CanvasRenderingContextWebGL" === cstrName
531
+ ? "contextWebGL."
532
+ : "CSSStyleDeclaration" === cstrName
533
+ ? "style."
534
+ : "MutationObserver" === cstrName
535
+ ? "mutationObserver."
536
+ : "NamedNodeMap" === cstrName
537
+ ? "namedNodeMap."
538
+ : "ResizeObserver" === cstrName
539
+ ? "resizeObserver."
540
+ : cstrName.substring(0, 1).toLowerCase() +
541
+ cstrName.substring(1) +
542
+ ".";
543
+ }
544
+ target[ApplyPathKey] &&
545
+ target[ApplyPathKey].length &&
546
+ (n += [...target[ApplyPathKey]].join(".") + ".");
547
+ }
548
+ if (applyPath.length > 1) {
549
+ const first = applyPath.slice(0, applyPath.length - 1);
550
+ const last = applyPath[applyPath.length - 1];
551
+ if (!isNaN(last)) {
552
+ return n + `${first.join(".")}[${last}]`;
553
+ }
554
+ }
555
+ return n + applyPath.join(".");
556
+ };
557
+ const getLogValue = (applyPath, v) => {
558
+ const type = typeof v;
559
+ if (void 0 === v) {
560
+ return "undefined";
561
+ }
562
+ if ("boolean" === type || "number" === type || null == v) {
563
+ return JSON.stringify(v);
564
+ }
565
+ if ("string" === type) {
566
+ return applyPath.includes("cookie")
567
+ ? JSON.stringify(v.slice(0, 10) + "...")
568
+ : JSON.stringify(v.length > 50 ? v.slice(0, 40) + "..." : v);
569
+ }
570
+ if (Array.isArray(v)) {
571
+ return `[${v.map(getLogValue).join(", ")}]`;
572
+ }
573
+ if ("object" === type) {
574
+ const instanceId = v[InstanceIdKey];
575
+ const cstrName = getConstructorName(v);
576
+ if ("string" == typeof instanceId) {
577
+ if ("Window" === cstrName) {
578
+ return "window";
258
579
  }
259
- get nodeName() {
260
- return this.name;
580
+ if ("string" == typeof v[InstanceDataKey]) {
581
+ if (1 === v.nodeType) {
582
+ return `<${v[InstanceDataKey].toLowerCase()}>`;
583
+ }
584
+ if (10 === v.nodeType) {
585
+ return `<!DOCTYPE ${v[InstanceDataKey]}>`;
586
+ }
587
+ if (v.nodeType <= 11) {
588
+ return v[InstanceDataKey];
589
+ }
261
590
  }
262
- get nodeType() {
263
- return 2;
591
+ return "¯\\_(ツ)_/¯ instance obj";
592
+ }
593
+ return v[Symbol.iterator]
594
+ ? `[${Array.from(v)
595
+ .map((i) => getLogValue(applyPath, i))
596
+ .join(", ")}]`
597
+ : "value" in v
598
+ ? "string" == typeof v.value
599
+ ? `"${v.value}"`
600
+ : objToString(v.value)
601
+ : objToString(v);
602
+ }
603
+ return ((v) => "object" == typeof v && v && v.then)(v)
604
+ ? "Promise"
605
+ : "function" === type
606
+ ? `ƒ() ${v.name || ""}`.trim()
607
+ : `¯\\_(ツ)_/¯ ${String(v)}`.trim();
608
+ };
609
+ const objToString = (obj) => {
610
+ const s = [];
611
+ for (let key in obj) {
612
+ const value = obj[key];
613
+ const type = typeof value;
614
+ "string" === type
615
+ ? s.push(`${key}: "${value}"`)
616
+ : "function" === type
617
+ ? s.push(`${key}: ƒ`)
618
+ : Array.isArray(type)
619
+ ? s.push(`${key}: [..]`)
620
+ : "object" === type && value
621
+ ? s.push(`${key}: {..}`)
622
+ : s.push(`${key}: ${String(value)}`);
623
+ }
624
+ let str = s.join(", ");
625
+ str.length > 200 && (str = str.substring(0, 200) + "..");
626
+ return `{ ${str} }`;
627
+ };
628
+ const logDimensionCacheClearStyle = (target, propName) => {
629
+ (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logSetters) &&
630
+ logWorker(
631
+ `Dimension cache cleared from style.${propName} setter`,
632
+ target[WinIdKey]
633
+ );
634
+ };
635
+ const logDimensionCacheClearMethod = (target, methodName) => {
636
+ (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logCalls) &&
637
+ logWorker(
638
+ `Dimension cache cleared from method call ${methodName}()`,
639
+ target[WinIdKey]
640
+ );
641
+ };
642
+ const taskQueue = [];
643
+ const queue = (
644
+ instance,
645
+ $applyPath$,
646
+ callType,
647
+ $assignInstanceId$,
648
+ $groupedGetters$,
649
+ buffer
650
+ ) => {
651
+ if (instance[ApplyPathKey]) {
652
+ taskQueue.push({
653
+ $winId$: instance[WinIdKey],
654
+ $instanceId$: instance[InstanceIdKey],
655
+ $applyPath$: [...instance[ApplyPathKey], ...$applyPath$],
656
+ $assignInstanceId$: $assignInstanceId$,
657
+ $groupedGetters$: $groupedGetters$,
658
+ });
659
+ taskQueue[len(taskQueue) - 1].$debug$ = ((
660
+ target,
661
+ applyPath,
662
+ callType
663
+ ) => {
664
+ let m = getTargetProp(target, applyPath);
665
+ 1 === callType
666
+ ? (m += " (blocking)")
667
+ : 2 === callType
668
+ ? (m += " (non-blocking)")
669
+ : 3 === callType && (m += " (non-blocking, no-side-effect)");
670
+ return m.trim();
671
+ })(instance, $applyPath$, callType);
672
+ buffer &&
673
+ 3 !== callType &&
674
+ console.error("buffer must be sent NonBlockingNoSideEffect");
675
+ if (3 === callType) {
676
+ webWorkerCtx.$postMessage$(
677
+ [
678
+ 12,
679
+ {
680
+ $msgId$: randomId(),
681
+ $tasks$: [...taskQueue],
682
+ },
683
+ ],
684
+ buffer
685
+ ? [buffer instanceof ArrayBuffer ? buffer : buffer.buffer]
686
+ : void 0
687
+ );
688
+ taskQueue.length = 0;
689
+ } else if (1 === callType) {
690
+ return sendToMain(true);
691
+ }
692
+ webWorkerCtx.$asyncMsgTimer$ = setTimeout(sendToMain, 20);
693
+ }
694
+ };
695
+ const sendToMain = (isBlocking) => {
696
+ clearTimeout(webWorkerCtx.$asyncMsgTimer$);
697
+ if (len(taskQueue)) {
698
+ webWorkerCtx.$config$.logMainAccess &&
699
+ logWorker(`Main access, tasks sent: ${taskQueue.length}`);
700
+ const endTask = taskQueue[len(taskQueue) - 1];
701
+ const accessReq = {
702
+ $msgId$: randomId(),
703
+ $tasks$: [...taskQueue],
704
+ };
705
+ taskQueue.length = 0;
706
+ if (isBlocking) {
707
+ const accessRsp = ((webWorkerCtx, accessReq) => {
708
+ const xhr = new XMLHttpRequest();
709
+ xhr.open("POST", partytownLibUrl("proxytown"), false);
710
+ xhr.send(JSON.stringify(accessReq));
711
+ return JSON.parse(xhr.responseText);
712
+ })(0, accessReq);
713
+ const isPromise = accessRsp.$isPromise$;
714
+ const rtnValue = deserializeFromMain(
715
+ endTask.$winId$,
716
+ endTask.$instanceId$,
717
+ endTask.$applyPath$,
718
+ accessRsp.$rtnValue$
719
+ );
720
+ if (accessRsp.$error$) {
721
+ if (isPromise) {
722
+ return Promise.reject(accessRsp.$error$);
723
+ }
724
+ throw new Error(accessRsp.$error$);
264
725
  }
265
- };
266
- const warnCrossOrgin = (apiType, apiName, env) => console.warn(`Partytown unable to ${apiType} cross-origin ${apiName}: ` + env.$location$);
267
- const logWorker = (msg, winId) => {
726
+ return isPromise ? Promise.resolve(rtnValue) : rtnValue;
727
+ }
728
+ webWorkerCtx.$postMessage$([12, accessReq]);
729
+ }
730
+ };
731
+ const getter = (instance, applyPath, groupedGetters, rtnValue) => {
732
+ if (webWorkerCtx.$config$.get) {
733
+ rtnValue = webWorkerCtx.$config$.get(
734
+ createHookOptions(instance, applyPath)
735
+ );
736
+ if (rtnValue !== HookContinue) {
737
+ return rtnValue;
738
+ }
739
+ }
740
+ rtnValue = queue(instance, applyPath, 1, void 0, groupedGetters);
741
+ ((
742
+ target,
743
+ applyPath,
744
+ rtnValue,
745
+ restrictedToWorker = false,
746
+ groupedGetters = false
747
+ ) => {
748
+ if (webWorkerCtx.$config$.logGetters) {
268
749
  try {
269
- const config = webWorkerCtx.$config$;
270
- if (config.logStackTraces) {
271
- const frames = (new Error).stack.split("\n");
272
- const i = frames.findIndex((f => f.includes("logWorker")));
273
- msg += "\n" + frames.slice(i + 1).join("\n");
274
- }
275
- let prefix;
276
- let color;
277
- if (winId) {
278
- prefix = `Worker (${normalizedWinId(winId)}) 🎉`;
279
- color = winColor(winId);
280
- } else {
281
- prefix = self.name;
282
- color = "#9844bf";
283
- }
284
- if (webWorkerCtx.lastLog !== msg) {
285
- webWorkerCtx.lastLog = msg;
286
- console.debug.apply(console, [ `%c${prefix}`, `background: ${color}; color: white; padding: 2px 3px; border-radius: 2px; font-size: 0.8em;`, msg ]);
287
- }
750
+ const msg = `Get ${getTargetProp(
751
+ target,
752
+ applyPath
753
+ )}, returned: ${getLogValue(applyPath, rtnValue)}${
754
+ restrictedToWorker ? " (restricted to worker)" : ""
755
+ }${groupedGetters ? " (grouped getter)" : ""}`;
756
+ msg.includes("Symbol(") || logWorker(msg, target[WinIdKey]);
288
757
  } catch (e) {}
758
+ }
759
+ })(instance, applyPath, rtnValue, false, !!groupedGetters);
760
+ return rtnValue;
761
+ };
762
+ const setter = (instance, applyPath, value, hookSetterValue) => {
763
+ if (webWorkerCtx.$config$.set) {
764
+ hookSetterValue = webWorkerCtx.$config$.set({
765
+ value: value,
766
+ prevent: HookPrevent,
767
+ ...createHookOptions(instance, applyPath),
768
+ });
769
+ if (hookSetterValue === HookPrevent) {
770
+ return;
771
+ }
772
+ hookSetterValue !== HookContinue && (value = hookSetterValue);
773
+ }
774
+ if (dimensionChangingSetterNames.some((s) => applyPath.includes(s))) {
775
+ cachedDimensions.clear();
776
+ ((target, propName) => {
777
+ (webWorkerCtx.$config$.logGetters ||
778
+ webWorkerCtx.$config$.logSetters) &&
779
+ logWorker(
780
+ `Dimension cache cleared from setter "${propName}"`,
781
+ target[WinIdKey]
782
+ );
783
+ })(instance, applyPath[applyPath.length - 1]);
784
+ }
785
+ applyPath = [...applyPath, serializeInstanceForMain(instance, value), 0];
786
+ ((target, applyPath, value, restrictedToWorker = false) => {
787
+ if (webWorkerCtx.$config$.logSetters) {
788
+ try {
789
+ applyPath = applyPath.slice(0, applyPath.length - 2);
790
+ logWorker(
791
+ `Set ${getTargetProp(target, applyPath)}, value: ${getLogValue(
792
+ applyPath,
793
+ value
794
+ )}${restrictedToWorker ? " (restricted to worker)" : ""}`,
795
+ target[WinIdKey]
796
+ );
797
+ } catch (e) {}
798
+ }
799
+ })(instance, applyPath, value);
800
+ queue(instance, applyPath, 2);
801
+ };
802
+ const callMethod = (
803
+ instance,
804
+ applyPath,
805
+ args,
806
+ callType,
807
+ assignInstanceId,
808
+ buffer,
809
+ rtnValue,
810
+ methodName
811
+ ) => {
812
+ if (webWorkerCtx.$config$.apply) {
813
+ rtnValue = webWorkerCtx.$config$.apply({
814
+ args: args,
815
+ ...createHookOptions(instance, applyPath),
816
+ });
817
+ if (rtnValue !== HookContinue) {
818
+ return rtnValue;
819
+ }
820
+ }
821
+ methodName = applyPath[len(applyPath) - 1];
822
+ applyPath = [...applyPath, serializeInstanceForMain(instance, args)];
823
+ callType = callType || (nonBlockingMethods.includes(methodName) ? 2 : 1);
824
+ if (
825
+ "setAttribute" === methodName &&
826
+ hasInstanceStateValue(instance, args[0])
827
+ ) {
828
+ setInstanceStateValue(instance, args[0], args[1]);
829
+ } else if (structureChangingMethodNames.includes(methodName)) {
830
+ cachedDimensions.clear();
831
+ cachedStructure.clear();
832
+ ((target, methodName) => {
833
+ (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logCalls) &&
834
+ logWorker(
835
+ `Dimension and DOM structure cache cleared from method call ${methodName}()`,
836
+ target[WinIdKey]
837
+ );
838
+ })(instance, methodName);
839
+ } else if (dimensionChangingMethodNames.includes(methodName)) {
840
+ callType = 2;
841
+ cachedDimensions.clear();
842
+ logDimensionCacheClearMethod(instance, methodName);
843
+ }
844
+ rtnValue = queue(
845
+ instance,
846
+ applyPath,
847
+ callType,
848
+ assignInstanceId,
849
+ void 0,
850
+ buffer
851
+ );
852
+ ((target, applyPath, args, rtnValue) => {
853
+ if (webWorkerCtx.$config$.logCalls) {
854
+ try {
855
+ applyPath = applyPath.slice(0, applyPath.length - 1);
856
+ logWorker(
857
+ `Call ${getTargetProp(target, applyPath)}(${args
858
+ .map((v) => getLogValue(applyPath, v))
859
+ .join(", ")}), returned: ${getLogValue(applyPath, rtnValue)}`,
860
+ target[WinIdKey]
861
+ );
862
+ } catch (e) {}
863
+ }
864
+ })(instance, applyPath, args, rtnValue);
865
+ return rtnValue;
866
+ };
867
+ const constructGlobal = (instance, cstrName, args) => {
868
+ ((target, cstrName, args) => {
869
+ if (webWorkerCtx.$config$.logCalls) {
870
+ try {
871
+ logWorker(
872
+ `Construct new ${cstrName}(${args
873
+ .map((v) => getLogValue([], v))
874
+ .join(", ")})`,
875
+ target[WinIdKey]
876
+ );
877
+ } catch (e) {}
878
+ }
879
+ })(instance, cstrName, args);
880
+ queue(instance, [1, cstrName, serializeInstanceForMain(instance, args)], 1);
881
+ };
882
+ const createHookOptions = (instance, applyPath) => ({
883
+ name: applyPath.join("."),
884
+ continue: HookContinue,
885
+ nodeName: instance[InstanceDataKey],
886
+ constructor: getConstructorName(instance),
887
+ instance: instance,
888
+ window: environments[instance[WinIdKey]].$window$,
889
+ });
890
+ const addStorageApi = (win, storageName, storages, isSameOrigin, env) => {
891
+ let getItems = (items) => {
892
+ items = storages.get(win.origin);
893
+ items || storages.set(win.origin, (items = []));
894
+ return items;
289
895
  };
290
- const winIds = [];
291
- const normalizedWinId = winId => {
292
- winIds.includes(winId) || winIds.push(winId);
293
- return winIds.indexOf(winId) + 1;
294
- };
295
- const winColor = winId => {
296
- const colors = [ "#00309e", "#ea3655", "#eea727" ];
297
- const index = normalizedWinId(winId) - 1;
298
- return colors[index] || colors[colors.length - 1];
896
+ let getIndexByKey = (key) =>
897
+ getItems().findIndex((i) => i[STORAGE_KEY] === key);
898
+ let index;
899
+ let item;
900
+ let storage = {
901
+ getItem(key) {
902
+ index = getIndexByKey(key);
903
+ return index > -1 ? getItems()[index][STORAGE_VALUE] : null;
904
+ },
905
+ setItem(key, value) {
906
+ index = getIndexByKey(key);
907
+ index > -1
908
+ ? (getItems()[index][STORAGE_VALUE] = value)
909
+ : getItems().push([key, value]);
910
+ isSameOrigin
911
+ ? callMethod(win, [storageName, "setItem"], [key, value], 2)
912
+ : warnCrossOrgin("set", storageName, env);
913
+ },
914
+ removeItem(key) {
915
+ index = getIndexByKey(key);
916
+ index > -1 && getItems().splice(index, 1);
917
+ isSameOrigin
918
+ ? callMethod(win, [storageName, "removeItem"], [key], 2)
919
+ : warnCrossOrgin("remove", storageName, env);
920
+ },
921
+ key(index) {
922
+ item = getItems()[index];
923
+ return item ? item[STORAGE_KEY] : null;
924
+ },
925
+ clear() {
926
+ getItems().length = 0;
927
+ isSameOrigin
928
+ ? callMethod(win, [storageName, "clear"], EMPTY_ARRAY, 2)
929
+ : warnCrossOrgin("clear", storageName, env);
930
+ },
931
+ get length() {
932
+ return getItems().length;
933
+ },
299
934
  };
300
- const getTargetProp = (target, applyPath) => {
301
- let n = "";
302
- if (target) {
303
- const cstrName = getConstructorName(target);
304
- if ("Window" === cstrName) {
305
- n = "";
306
- } else if ("string" == typeof target[InstanceDataKey]) {
307
- let nodeName = target[InstanceDataKey];
308
- n = "#text" === nodeName ? "textNode." : "#comment" === nodeName ? "commentNode." : "#document" === nodeName ? "document." : "html" === nodeName ? "doctype." : nodeName.toLowerCase() + ".";
309
- } else {
310
- n = "nodeType" in target && 2 === target.nodeType ? "attributes." : "CanvasRenderingContext2D" === cstrName ? "context2D." : "CanvasRenderingContextWebGL" === cstrName ? "contextWebGL." : "CSSStyleDeclaration" === cstrName ? "style." : "MutationObserver" === cstrName ? "mutationObserver." : "NamedNodeMap" === cstrName ? "namedNodeMap." : "ResizeObserver" === cstrName ? "resizeObserver." : cstrName.substring(0, 1).toLowerCase() + cstrName.substring(1) + ".";
311
- }
312
- target[ApplyPathKey] && target[ApplyPathKey].length && (n += [ ...target[ApplyPathKey] ].join(".") + ".");
313
- }
314
- if (applyPath.length > 1) {
315
- const first = applyPath.slice(0, applyPath.length - 1);
316
- const last = applyPath[applyPath.length - 1];
317
- if (!isNaN(last)) {
318
- return n + `${first.join(".")}[${last}]`;
319
- }
935
+ win[storageName] = new Proxy(storage, {
936
+ get: (target, key) =>
937
+ Reflect.has(target, key)
938
+ ? Reflect.get(target, key)
939
+ : target.getItem(key),
940
+ set(target, key, value) {
941
+ target.setItem(key, value);
942
+ return true;
943
+ },
944
+ has: (target, key) =>
945
+ !!Reflect.has(target, key) ||
946
+ ("string" == typeof key && null !== target.getItem(key)),
947
+ deleteProperty(target, key) {
948
+ target.removeItem(key);
949
+ return true;
950
+ },
951
+ });
952
+ };
953
+ const STORAGE_KEY = 0;
954
+ const STORAGE_VALUE = 1;
955
+ const createCSSStyleDeclarationCstr = (win, WorkerBase, cstrName) => {
956
+ win[cstrName] = defineConstructorName(
957
+ class extends WorkerBase {
958
+ constructor(winId, instanceId, applyPath, styles) {
959
+ super(winId, instanceId, applyPath, styles || {});
960
+ return new Proxy(this, {
961
+ get(target, propName) {
962
+ if (target[propName]) {
963
+ return target[propName];
964
+ }
965
+ target[propName] ||
966
+ "string" != typeof propName ||
967
+ target[InstanceDataKey][propName] ||
968
+ (target[InstanceDataKey][propName] = getter(target, [
969
+ propName,
970
+ ]));
971
+ return target[InstanceDataKey][propName];
972
+ },
973
+ set(target, propName, propValue) {
974
+ target[InstanceDataKey][propName] = propValue;
975
+ setter(target, [propName], propValue);
976
+ logDimensionCacheClearStyle(target, propName);
977
+ cachedDimensions.clear();
978
+ return true;
979
+ },
980
+ });
320
981
  }
321
- return n + applyPath.join(".");
322
- };
323
- const getLogValue = (applyPath, v) => {
324
- const type = typeof v;
325
- if (void 0 === v) {
326
- return "undefined";
982
+ setProperty(...args) {
983
+ this[InstanceDataKey][args[0]] = args[1];
984
+ callMethod(this, ["setProperty"], args, 2);
985
+ logDimensionCacheClearStyle(this, args[0]);
986
+ cachedDimensions.clear();
327
987
  }
328
- if ("boolean" === type || "number" === type || null == v) {
329
- return JSON.stringify(v);
988
+ getPropertyValue(propName) {
989
+ return this[propName];
330
990
  }
331
- if ("string" === type) {
332
- return applyPath.includes("cookie") ? JSON.stringify(v.slice(0, 10) + "...") : JSON.stringify(v.length > 50 ? v.slice(0, 40) + "..." : v);
991
+ removeProperty(propName) {
992
+ let value = this[InstanceDataKey][propName];
993
+ callMethod(this, ["removeProperty"], [propName], 2);
994
+ logDimensionCacheClearStyle(this, propName);
995
+ cachedDimensions.clear();
996
+ this[InstanceDataKey][propName] = void 0;
997
+ return value;
333
998
  }
334
- if (Array.isArray(v)) {
335
- return `[${v.map(getLogValue).join(", ")}]`;
999
+ },
1000
+ cstrName
1001
+ );
1002
+ };
1003
+ const createCSSStyleSheetConstructor = (win, cssStyleSheetCstrName) => {
1004
+ win[cssStyleSheetCstrName] = defineConstructorName(
1005
+ class {
1006
+ constructor(ownerNode) {
1007
+ this.ownerNode = ownerNode;
336
1008
  }
337
- if ("object" === type) {
338
- const instanceId = v[InstanceIdKey];
339
- const cstrName = getConstructorName(v);
340
- if ("string" == typeof instanceId) {
341
- if ("Window" === cstrName) {
342
- return "window";
343
- }
344
- if ("string" == typeof v[InstanceDataKey]) {
345
- if (1 === v.nodeType) {
346
- return `<${v[InstanceDataKey].toLowerCase()}>`;
347
- }
348
- if (10 === v.nodeType) {
349
- return `<!DOCTYPE ${v[InstanceDataKey]}>`;
350
- }
351
- if (v.nodeType <= 11) {
352
- return v[InstanceDataKey];
353
- }
354
- }
355
- return "¯\\_(ツ)_/¯ instance obj";
356
- }
357
- return v[Symbol.iterator] ? `[${Array.from(v).map((i => getLogValue(applyPath, i))).join(", ")}]` : "value" in v ? "string" == typeof v.value ? `"${v.value}"` : objToString(v.value) : objToString(v);
1009
+ get cssRules() {
1010
+ const ownerNode = this.ownerNode;
1011
+ return new Proxy(
1012
+ {},
1013
+ {
1014
+ get(target, propKey) {
1015
+ const propName = String(propKey);
1016
+ return "item" === propName
1017
+ ? (index) => getCssRule(ownerNode, index)
1018
+ : "length" === propName
1019
+ ? getCssRules(ownerNode).length
1020
+ : isNaN(propName)
1021
+ ? target[propKey]
1022
+ : getCssRule(ownerNode, propName);
1023
+ },
1024
+ }
1025
+ );
358
1026
  }
359
- return (v => "object" == typeof v && v && v.then)(v) ? "Promise" : "function" === type ? `ƒ() ${v.name || ""}`.trim() : `¯\\_(ツ)_/¯ ${String(v)}`.trim();
360
- };
361
- const objToString = obj => {
362
- const s = [];
363
- for (let key in obj) {
364
- const value = obj[key];
365
- const type = typeof value;
366
- "string" === type ? s.push(`${key}: "${value}"`) : "function" === type ? s.push(`${key}: ƒ`) : Array.isArray(type) ? s.push(`${key}: [..]`) : "object" === type && value ? s.push(`${key}: {..}`) : s.push(`${key}: ${String(value)}`);
1027
+ insertRule(ruleText, index) {
1028
+ const cssRules = getCssRules(this.ownerNode);
1029
+ index = void 0 === index ? 0 : index;
1030
+ if (index >= 0 && index <= cssRules.length) {
1031
+ callMethod(
1032
+ this.ownerNode,
1033
+ ["sheet", "insertRule"],
1034
+ [ruleText, index],
1035
+ 2
1036
+ );
1037
+ cssRules.splice(index, 0, 0);
1038
+ }
1039
+ logDimensionCacheClearMethod(this.ownerNode, "insertRule");
1040
+ cachedDimensions.clear();
1041
+ return index;
367
1042
  }
368
- let str = s.join(", ");
369
- str.length > 200 && (str = str.substring(0, 200) + "..");
370
- return `{ ${str} }`;
371
- };
372
- const logDimensionCacheClearStyle = (target, propName) => {
373
- (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logSetters) && logWorker(`Dimension cache cleared from style.${propName} setter`, target[WinIdKey]);
374
- };
375
- const logDimensionCacheClearMethod = (target, methodName) => {
376
- (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logCalls) && logWorker(`Dimension cache cleared from method call ${methodName}()`, target[WinIdKey]);
377
- };
378
- const taskQueue = [];
379
- const queue = (instance, $applyPath$, callType, $assignInstanceId$, $groupedGetters$, buffer) => {
380
- if (instance[ApplyPathKey]) {
381
- taskQueue.push({
382
- $winId$: instance[WinIdKey],
383
- $instanceId$: instance[InstanceIdKey],
384
- $applyPath$: [ ...instance[ApplyPathKey], ...$applyPath$ ],
385
- $assignInstanceId$: $assignInstanceId$,
386
- $groupedGetters$: $groupedGetters$
387
- });
388
- taskQueue[len(taskQueue) - 1].$debug$ = ((target, applyPath, callType) => {
389
- let m = getTargetProp(target, applyPath);
390
- 1 === callType ? m += " (blocking)" : 2 === callType ? m += " (non-blocking)" : 3 === callType && (m += " (non-blocking, no-side-effect)");
391
- return m.trim();
392
- })(instance, $applyPath$, callType);
393
- buffer && 3 !== callType && console.error("buffer must be sent NonBlockingNoSideEffect");
394
- if (3 === callType) {
395
- webWorkerCtx.$postMessage$([ 12, {
396
- $msgId$: randomId(),
397
- $tasks$: [ ...taskQueue ]
398
- } ], buffer ? [ buffer instanceof ArrayBuffer ? buffer : buffer.buffer ] : void 0);
399
- taskQueue.length = 0;
400
- } else if (1 === callType) {
401
- return sendToMain(true);
402
- }
403
- webWorkerCtx.$asyncMsgTimer$ = setTimeout(sendToMain, 20);
1043
+ deleteRule(index) {
1044
+ callMethod(this.ownerNode, ["sheet", "deleteRule"], [index], 2);
1045
+ getCssRules(this.ownerNode).splice(index, 1);
1046
+ logDimensionCacheClearMethod(this.ownerNode, "deleteRule");
1047
+ cachedDimensions.clear();
404
1048
  }
405
- };
406
- const sendToMain = isBlocking => {
407
- clearTimeout(webWorkerCtx.$asyncMsgTimer$);
408
- if (len(taskQueue)) {
409
- webWorkerCtx.$config$.logMainAccess && logWorker(`Main access, tasks sent: ${taskQueue.length}`);
410
- const endTask = taskQueue[len(taskQueue) - 1];
411
- const accessReq = {
412
- $msgId$: randomId(),
413
- $tasks$: [ ...taskQueue ]
414
- };
415
- taskQueue.length = 0;
416
- if (isBlocking) {
417
- const accessRsp = ((webWorkerCtx, accessReq) => {
418
- const xhr = new XMLHttpRequest;
419
- xhr.open("POST", partytownLibUrl("proxytown"), false);
420
- xhr.send(JSON.stringify(accessReq));
421
- return JSON.parse(xhr.responseText);
422
- })(0, accessReq);
423
- const isPromise = accessRsp.$isPromise$;
424
- const rtnValue = deserializeFromMain(endTask.$winId$, endTask.$instanceId$, endTask.$applyPath$, accessRsp.$rtnValue$);
425
- if (accessRsp.$error$) {
426
- if (isPromise) {
427
- return Promise.reject(accessRsp.$error$);
428
- }
429
- throw new Error(accessRsp.$error$);
430
- }
431
- return isPromise ? Promise.resolve(rtnValue) : rtnValue;
432
- }
433
- webWorkerCtx.$postMessage$([ 12, accessReq ]);
1049
+ get type() {
1050
+ return "text/css";
434
1051
  }
1052
+ },
1053
+ cssStyleSheetCstrName
1054
+ );
1055
+ const HTMLStyleDescriptorMap = {
1056
+ sheet: {
1057
+ get() {
1058
+ return new win[cssStyleSheetCstrName](this);
1059
+ },
1060
+ },
435
1061
  };
436
- const getter = (instance, applyPath, groupedGetters, rtnValue) => {
437
- if (webWorkerCtx.$config$.get) {
438
- rtnValue = webWorkerCtx.$config$.get(createHookOptions(instance, applyPath));
439
- if (rtnValue !== HookContinue) {
440
- return rtnValue;
441
- }
442
- }
443
- rtnValue = queue(instance, applyPath, 1, void 0, groupedGetters);
444
- ((target, applyPath, rtnValue, restrictedToWorker = false, groupedGetters = false) => {
445
- if (webWorkerCtx.$config$.logGetters) {
446
- try {
447
- const msg = `Get ${getTargetProp(target, applyPath)}, returned: ${getLogValue(applyPath, rtnValue)}${restrictedToWorker ? " (restricted to worker)" : ""}${groupedGetters ? " (grouped getter)" : ""}`;
448
- msg.includes("Symbol(") || logWorker(msg, target[WinIdKey]);
449
- } catch (e) {}
450
- }
451
- })(instance, applyPath, rtnValue, false, !!groupedGetters);
452
- return rtnValue;
1062
+ definePrototypePropertyDescriptor(
1063
+ win.HTMLStyleElement,
1064
+ HTMLStyleDescriptorMap
1065
+ );
1066
+ };
1067
+ const getCssRules = (ownerNode, cssRules) => {
1068
+ cssRules = getInstanceStateValue(ownerNode, 2);
1069
+ if (!cssRules) {
1070
+ cssRules = getter(ownerNode, ["sheet", "cssRules"]);
1071
+ setInstanceStateValue(ownerNode, 2, cssRules);
1072
+ }
1073
+ return cssRules;
1074
+ };
1075
+ const getCssRule = (ownerNode, index, cssRules) => {
1076
+ cssRules = getCssRules(ownerNode);
1077
+ 0 === cssRules[index] &&
1078
+ (cssRules[index] = getter(ownerNode, [
1079
+ "sheet",
1080
+ "cssRules",
1081
+ parseInt(index, 10),
1082
+ ]));
1083
+ return cssRules[index];
1084
+ };
1085
+ const runScriptContent = (
1086
+ env,
1087
+ instanceId,
1088
+ scriptContent,
1089
+ winId,
1090
+ errorMsg
1091
+ ) => {
1092
+ try {
1093
+ webWorkerCtx.$config$.logScriptExecution &&
1094
+ logWorker(
1095
+ `Execute script: ${scriptContent
1096
+ .substring(0, 100)
1097
+ .split("\n")
1098
+ .map((l) => l.trim())
1099
+ .join(" ")
1100
+ .trim()
1101
+ .substring(0, 60)}...`,
1102
+ winId
1103
+ );
1104
+ env.$currentScriptId$ = instanceId;
1105
+ run(env, scriptContent);
1106
+ } catch (contentError) {
1107
+ console.error(scriptContent, contentError);
1108
+ errorMsg = String(contentError.stack || contentError);
1109
+ }
1110
+ env.$currentScriptId$ = "";
1111
+ return errorMsg;
1112
+ };
1113
+ const run = (env, scriptContent, scriptUrl) => {
1114
+ env.$runWindowLoadEvent$ = 1;
1115
+ scriptContent =
1116
+ `with(this){${scriptContent
1117
+ .replace(/\bthis\b/g, "(thi$(this)?window:this)")
1118
+ .replace(/\/\/# so/g, "//Xso")}\n;function thi$(t){return t===this}};${(
1119
+ webWorkerCtx.$config$.globalFns || []
1120
+ )
1121
+ .filter((globalFnName) => /[a-zA-Z_$][0-9a-zA-Z_$]*/.test(globalFnName))
1122
+ .map((g) => `(typeof ${g}=='function'&&(this.${g}=${g}))`)
1123
+ .join(";")};` + (scriptUrl ? "\n//# sourceURL=" + scriptUrl : "");
1124
+ env.$isSameOrigin$ ||
1125
+ (scriptContent = scriptContent.replace(
1126
+ /.postMessage\(/g,
1127
+ `.postMessage('${env.$winId$}',`
1128
+ ));
1129
+ new Function(scriptContent).call(env.$window$);
1130
+ env.$runWindowLoadEvent$ = 0;
1131
+ };
1132
+ const runStateLoadHandlers = (instance, type, handlers) => {
1133
+ handlers = getInstanceStateValue(instance, type);
1134
+ handlers &&
1135
+ setTimeout(() =>
1136
+ handlers.map((cb) =>
1137
+ cb({
1138
+ type: type,
1139
+ })
1140
+ )
1141
+ );
1142
+ };
1143
+ const resolveToUrl = (
1144
+ env,
1145
+ url,
1146
+ type,
1147
+ baseLocation,
1148
+ resolvedUrl,
1149
+ configResolvedUrl
1150
+ ) => {
1151
+ baseLocation = env.$location$;
1152
+ while (!baseLocation.host) {
1153
+ env = environments[env.$parentWinId$];
1154
+ baseLocation = env.$location$;
1155
+ if (env.$winId$ === env.$parentWinId$) {
1156
+ break;
1157
+ }
1158
+ }
1159
+ resolvedUrl = new URL(url || "", baseLocation);
1160
+ if (type && webWorkerCtx.$config$.resolveUrl) {
1161
+ configResolvedUrl = webWorkerCtx.$config$.resolveUrl(
1162
+ resolvedUrl,
1163
+ baseLocation,
1164
+ type
1165
+ );
1166
+ if (configResolvedUrl) {
1167
+ return configResolvedUrl;
1168
+ }
1169
+ }
1170
+ return resolvedUrl;
1171
+ };
1172
+ const resolveUrl = (env, url, type) => resolveToUrl(env, url, type) + "";
1173
+ const getPartytownScript = () =>
1174
+ `<script src="${partytownLibUrl("partytown.js?v=0.7.5")}"><\/script>`;
1175
+ const createImageConstructor = (env) =>
1176
+ class HTMLImageElement {
1177
+ constructor() {
1178
+ this.s = "";
1179
+ this.l = [];
1180
+ this.e = [];
1181
+ this.style = {};
1182
+ }
1183
+ get src() {
1184
+ return this.s;
1185
+ }
1186
+ set src(src) {
1187
+ webWorkerCtx.$config$.logImageRequests &&
1188
+ logWorker(
1189
+ `Image() request: ${resolveUrl(env, src, "image")}`,
1190
+ env.$winId$
1191
+ );
1192
+ this.s = src;
1193
+ fetch(resolveUrl(env, src, "image"), {
1194
+ mode: "no-cors",
1195
+ credentials: "include",
1196
+ keepalive: true,
1197
+ }).then(
1198
+ (rsp) => {
1199
+ rsp.ok || 0 === rsp.status
1200
+ ? this.l.map((cb) =>
1201
+ cb({
1202
+ type: "load",
1203
+ })
1204
+ )
1205
+ : this.e.map((cb) =>
1206
+ cb({
1207
+ type: "error",
1208
+ })
1209
+ );
1210
+ },
1211
+ () =>
1212
+ this.e.forEach((cb) =>
1213
+ cb({
1214
+ type: "error",
1215
+ })
1216
+ )
1217
+ );
1218
+ }
1219
+ addEventListener(eventName, cb) {
1220
+ "load" === eventName && this.l.push(cb);
1221
+ "error" === eventName && this.e.push(cb);
1222
+ }
1223
+ get onload() {
1224
+ return this.l[0];
1225
+ }
1226
+ set onload(cb) {
1227
+ this.l = [cb];
1228
+ }
1229
+ get onerror() {
1230
+ return this.e[0];
1231
+ }
1232
+ set onerror(cb) {
1233
+ this.e = [cb];
1234
+ }
453
1235
  };
454
- const setter = (instance, applyPath, value, hookSetterValue) => {
455
- if (webWorkerCtx.$config$.set) {
456
- hookSetterValue = webWorkerCtx.$config$.set({
457
- value: value,
458
- prevent: HookPrevent,
459
- ...createHookOptions(instance, applyPath)
460
- });
461
- if (hookSetterValue === HookPrevent) {
462
- return;
463
- }
464
- hookSetterValue !== HookContinue && (value = hookSetterValue);
465
- }
466
- if (dimensionChangingSetterNames.some((s => applyPath.includes(s)))) {
467
- cachedDimensions.clear();
468
- ((target, propName) => {
469
- (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logSetters) && logWorker(`Dimension cache cleared from setter "${propName}"`, target[WinIdKey]);
470
- })(instance, applyPath[applyPath.length - 1]);
471
- }
472
- applyPath = [ ...applyPath, serializeInstanceForMain(instance, value), 0 ];
473
- ((target, applyPath, value, restrictedToWorker = false) => {
474
- if (webWorkerCtx.$config$.logSetters) {
475
- try {
476
- applyPath = applyPath.slice(0, applyPath.length - 2);
477
- logWorker(`Set ${getTargetProp(target, applyPath)}, value: ${getLogValue(applyPath, value)}${restrictedToWorker ? " (restricted to worker)" : ""}`, target[WinIdKey]);
478
- } catch (e) {}
479
- }
480
- })(instance, applyPath, value);
481
- queue(instance, applyPath, 2);
1236
+ const HTMLSrcElementDescriptorMap = {
1237
+ addEventListener: {
1238
+ value(...args) {
1239
+ const eventName = args[0];
1240
+ const callbacks = getInstanceStateValue(this, eventName) || [];
1241
+ callbacks.push(args[1]);
1242
+ setInstanceStateValue(this, eventName, callbacks);
1243
+ },
1244
+ },
1245
+ async: {
1246
+ get: noop,
1247
+ set: noop,
1248
+ },
1249
+ defer: {
1250
+ get: noop,
1251
+ set: noop,
1252
+ },
1253
+ onload: {
1254
+ get() {
1255
+ let callbacks = getInstanceStateValue(this, "load");
1256
+ return (callbacks && callbacks[0]) || null;
1257
+ },
1258
+ set(cb) {
1259
+ setInstanceStateValue(this, "load", cb ? [cb] : null);
1260
+ },
1261
+ },
1262
+ onerror: {
1263
+ get() {
1264
+ let callbacks = getInstanceStateValue(this, "error");
1265
+ return (callbacks && callbacks[0]) || null;
1266
+ },
1267
+ set(cb) {
1268
+ setInstanceStateValue(this, "error", cb ? [cb] : null);
1269
+ },
1270
+ },
1271
+ getAttribute: {
1272
+ value(attrName) {
1273
+ return "src" === attrName
1274
+ ? this.src
1275
+ : callMethod(this, ["getAttribute"], [attrName]);
1276
+ },
1277
+ },
1278
+ setAttribute: {
1279
+ value(attrName, attrValue) {
1280
+ scriptAttrPropNames.includes(attrName)
1281
+ ? (this[attrName] = attrValue)
1282
+ : callMethod(this, ["setAttribute"], [attrName, attrValue]);
1283
+ },
1284
+ },
1285
+ };
1286
+ const scriptAttrPropNames = commaSplit("src,type");
1287
+ const patchHTMLScriptElement = (WorkerHTMLScriptElement, env) => {
1288
+ const HTMLScriptDescriptorMap = {
1289
+ innerHTML: innerHTMLDescriptor,
1290
+ innerText: innerHTMLDescriptor,
1291
+ src: {
1292
+ get() {
1293
+ return getInstanceStateValue(this, 4) || "";
1294
+ },
1295
+ set(url) {
1296
+ const orgUrl = resolveUrl(env, url, null);
1297
+ const config = webWorkerCtx.$config$;
1298
+ url = resolveUrl(env, url, "script");
1299
+ setInstanceStateValue(this, 4, url);
1300
+ setter(this, ["src"], url);
1301
+ orgUrl !== url && setter(this, ["dataset", "ptsrc"], orgUrl);
1302
+ if (this.type && config.loadScriptsOnMainThread) {
1303
+ const shouldExecuteScriptViaMainThread =
1304
+ config.loadScriptsOnMainThread.some(
1305
+ (scriptUrl) => scriptUrl === url
1306
+ );
1307
+ shouldExecuteScriptViaMainThread &&
1308
+ setter(this, ["type"], "text/javascript");
1309
+ }
1310
+ },
1311
+ },
1312
+ textContent: innerHTMLDescriptor,
1313
+ type: {
1314
+ get() {
1315
+ return getter(this, ["type"]);
1316
+ },
1317
+ set(type) {
1318
+ if (!isScriptJsType(type)) {
1319
+ setInstanceStateValue(this, 5, type);
1320
+ setter(this, ["type"], type);
1321
+ }
1322
+ },
1323
+ },
1324
+ ...HTMLSrcElementDescriptorMap,
482
1325
  };
483
- const callMethod = (instance, applyPath, args, callType, assignInstanceId, buffer, rtnValue, methodName) => {
484
- if (webWorkerCtx.$config$.apply) {
485
- rtnValue = webWorkerCtx.$config$.apply({
486
- args: args,
487
- ...createHookOptions(instance, applyPath)
488
- });
489
- if (rtnValue !== HookContinue) {
490
- return rtnValue;
491
- }
492
- }
493
- methodName = applyPath[len(applyPath) - 1];
494
- applyPath = [ ...applyPath, serializeInstanceForMain(instance, args) ];
495
- callType = callType || (nonBlockingMethods.includes(methodName) ? 2 : 1);
496
- if ("setAttribute" === methodName && hasInstanceStateValue(instance, args[0])) {
497
- setInstanceStateValue(instance, args[0], args[1]);
498
- } else if (structureChangingMethodNames.includes(methodName)) {
499
- cachedDimensions.clear();
500
- cachedStructure.clear();
501
- ((target, methodName) => {
502
- (webWorkerCtx.$config$.logGetters || webWorkerCtx.$config$.logCalls) && logWorker(`Dimension and DOM structure cache cleared from method call ${methodName}()`, target[WinIdKey]);
503
- })(instance, methodName);
504
- } else if (dimensionChangingMethodNames.includes(methodName)) {
505
- callType = 2;
506
- cachedDimensions.clear();
507
- logDimensionCacheClearMethod(instance, methodName);
1326
+ definePrototypePropertyDescriptor(
1327
+ WorkerHTMLScriptElement,
1328
+ HTMLScriptDescriptorMap
1329
+ );
1330
+ };
1331
+ const innerHTMLDescriptor = {
1332
+ get() {
1333
+ const type = getter(this, ["type"]);
1334
+ return isScriptJsType(type)
1335
+ ? getInstanceStateValue(this, 3) || ""
1336
+ : getter(this, ["innerHTML"]);
1337
+ },
1338
+ set(scriptContent) {
1339
+ setInstanceStateValue(this, 3, scriptContent);
1340
+ },
1341
+ };
1342
+ const isScriptJsType = (scriptType) =>
1343
+ !scriptType || "text/javascript" === scriptType;
1344
+ const createNodeCstr = (win, env, WorkerBase) => {
1345
+ const config = webWorkerCtx.$config$;
1346
+ const WorkerNode = defineConstructorName(
1347
+ class extends WorkerBase {
1348
+ appendChild(node) {
1349
+ return this.insertBefore(node, null);
508
1350
  }
509
- rtnValue = queue(instance, applyPath, callType, assignInstanceId, void 0, buffer);
510
- ((target, applyPath, args, rtnValue) => {
511
- if (webWorkerCtx.$config$.logCalls) {
512
- try {
513
- applyPath = applyPath.slice(0, applyPath.length - 1);
514
- logWorker(`Call ${getTargetProp(target, applyPath)}(${args.map((v => getLogValue(applyPath, v))).join(", ")}), returned: ${getLogValue(applyPath, rtnValue)}`, target[WinIdKey]);
515
- } catch (e) {}
516
- }
517
- })(instance, applyPath, args, rtnValue);
518
- return rtnValue;
519
- };
520
- const constructGlobal = (instance, cstrName, args) => {
521
- ((target, cstrName, args) => {
522
- if (webWorkerCtx.$config$.logCalls) {
523
- try {
524
- logWorker(`Construct new ${cstrName}(${args.map((v => getLogValue([], v))).join(", ")})`, target[WinIdKey]);
525
- } catch (e) {}
526
- }
527
- })(instance, cstrName, args);
528
- queue(instance, [ 1, cstrName, serializeInstanceForMain(instance, args) ], 1);
529
- };
530
- const createHookOptions = (instance, applyPath) => ({
531
- name: applyPath.join("."),
532
- continue: HookContinue,
533
- nodeName: instance[InstanceDataKey],
534
- constructor: getConstructorName(instance),
535
- instance: instance,
536
- window: environments[instance[WinIdKey]].$window$
537
- });
538
- const addStorageApi = (win, storageName, storages, isSameOrigin, env) => {
539
- let getItems = items => {
540
- items = storages.get(win.origin);
541
- items || storages.set(win.origin, items = []);
542
- return items;
543
- };
544
- let getIndexByKey = key => getItems().findIndex((i => i[STORAGE_KEY] === key));
545
- let index;
546
- let item;
547
- let storage = {
548
- getItem(key) {
549
- index = getIndexByKey(key);
550
- return index > -1 ? getItems()[index][STORAGE_VALUE] : null;
551
- },
552
- setItem(key, value) {
553
- index = getIndexByKey(key);
554
- index > -1 ? getItems()[index][STORAGE_VALUE] = value : getItems().push([ key, value ]);
555
- isSameOrigin ? callMethod(win, [ storageName, "setItem" ], [ key, value ], 2) : warnCrossOrgin("set", storageName, env);
556
- },
557
- removeItem(key) {
558
- index = getIndexByKey(key);
559
- index > -1 && getItems().splice(index, 1);
560
- isSameOrigin ? callMethod(win, [ storageName, "removeItem" ], [ key ], 2) : warnCrossOrgin("remove", storageName, env);
561
- },
562
- key(index) {
563
- item = getItems()[index];
564
- return item ? item[STORAGE_KEY] : null;
565
- },
566
- clear() {
567
- getItems().length = 0;
568
- isSameOrigin ? callMethod(win, [ storageName, "clear" ], EMPTY_ARRAY, 2) : warnCrossOrgin("clear", storageName, env);
569
- },
570
- get length() {
571
- return getItems().length;
572
- }
573
- };
574
- win[storageName] = new Proxy(storage, {
575
- get: (target, key) => Reflect.has(target, key) ? Reflect.get(target, key) : target.getItem(key),
576
- set(target, key, value) {
577
- target.setItem(key, value);
578
- return true;
579
- },
580
- has: (target, key) => !!Reflect.has(target, key) || "string" == typeof key && null !== target.getItem(key),
581
- deleteProperty(target, key) {
582
- target.removeItem(key);
583
- return true;
584
- }
585
- });
586
- };
587
- const STORAGE_KEY = 0;
588
- const STORAGE_VALUE = 1;
589
- const createCSSStyleDeclarationCstr = (win, WorkerBase, cstrName) => {
590
- win[cstrName] = defineConstructorName(class extends WorkerBase {
591
- constructor(winId, instanceId, applyPath, styles) {
592
- super(winId, instanceId, applyPath, styles || {});
593
- return new Proxy(this, {
594
- get(target, propName) {
595
- if (target[propName]) {
596
- return target[propName];
597
- }
598
- target[propName] || "string" != typeof propName || target[InstanceDataKey][propName] || (target[InstanceDataKey][propName] = getter(target, [ propName ]));
599
- return target[InstanceDataKey][propName];
600
- },
601
- set(target, propName, propValue) {
602
- target[InstanceDataKey][propName] = propValue;
603
- setter(target, [ propName ], propValue);
604
- logDimensionCacheClearStyle(target, propName);
605
- cachedDimensions.clear();
606
- return true;
607
- }
608
- });
609
- }
610
- setProperty(...args) {
611
- this[InstanceDataKey][args[0]] = args[1];
612
- callMethod(this, [ "setProperty" ], args, 2);
613
- logDimensionCacheClearStyle(this, args[0]);
614
- cachedDimensions.clear();
615
- }
616
- getPropertyValue(propName) {
617
- return this[propName];
618
- }
619
- removeProperty(propName) {
620
- let value = this[InstanceDataKey][propName];
621
- callMethod(this, [ "removeProperty" ], [ propName ], 2);
622
- logDimensionCacheClearStyle(this, propName);
623
- cachedDimensions.clear();
624
- this[InstanceDataKey][propName] = void 0;
625
- return value;
626
- }
627
- }, cstrName);
628
- };
629
- const createCSSStyleSheetConstructor = (win, cssStyleSheetCstrName) => {
630
- win[cssStyleSheetCstrName] = defineConstructorName(class {
631
- constructor(ownerNode) {
632
- this.ownerNode = ownerNode;
633
- }
634
- get cssRules() {
635
- const ownerNode = this.ownerNode;
636
- return new Proxy({}, {
637
- get(target, propKey) {
638
- const propName = String(propKey);
639
- return "item" === propName ? index => getCssRule(ownerNode, index) : "length" === propName ? getCssRules(ownerNode).length : isNaN(propName) ? target[propKey] : getCssRule(ownerNode, propName);
640
- }
641
- });
642
- }
643
- insertRule(ruleText, index) {
644
- const cssRules = getCssRules(this.ownerNode);
645
- index = void 0 === index ? 0 : index;
646
- if (index >= 0 && index <= cssRules.length) {
647
- callMethod(this.ownerNode, [ "sheet", "insertRule" ], [ ruleText, index ], 2);
648
- cssRules.splice(index, 0, 0);
1351
+ get href() {}
1352
+ set href(_) {}
1353
+ insertBefore(newNode, referenceNode) {
1354
+ var _a, _b;
1355
+ const winId = (newNode[WinIdKey] = this[WinIdKey]);
1356
+ const instanceId = newNode[InstanceIdKey];
1357
+ const nodeName = newNode[InstanceDataKey];
1358
+ const isScript = "SCRIPT" === nodeName;
1359
+ const isIFrame = "INPUT" === nodeName;
1360
+ if (isScript) {
1361
+ const scriptContent = getInstanceStateValue(newNode, 3);
1362
+ const scriptType = getInstanceStateValue(newNode, 5);
1363
+ if (scriptContent) {
1364
+ if (isScriptJsType(scriptType)) {
1365
+ const scriptId = newNode.id;
1366
+ const loadOnMainThread =
1367
+ scriptId &&
1368
+ (null ===
1369
+ (_b =
1370
+ null === (_a = config.loadScriptsOnMainThread) ||
1371
+ void 0 === _a
1372
+ ? void 0
1373
+ : _a.includes) || void 0 === _b
1374
+ ? void 0
1375
+ : _b.call(_a, scriptId));
1376
+ if (loadOnMainThread) {
1377
+ setter(newNode, ["type"], "text/javascript");
1378
+ } else {
1379
+ const errorMsg = runScriptContent(
1380
+ env,
1381
+ instanceId,
1382
+ scriptContent,
1383
+ winId,
1384
+ ""
1385
+ );
1386
+ const datasetType = errorMsg ? "pterror" : "ptid";
1387
+ const datasetValue = errorMsg || instanceId;
1388
+ setter(newNode, ["type"], "text/partytown-x");
1389
+ setter(newNode, ["dataset", datasetType], datasetValue);
649
1390
  }
650
- logDimensionCacheClearMethod(this.ownerNode, "insertRule");
651
- cachedDimensions.clear();
652
- return index;
653
- }
654
- deleteRule(index) {
655
- callMethod(this.ownerNode, [ "sheet", "deleteRule" ], [ index ], 2);
656
- getCssRules(this.ownerNode).splice(index, 1);
657
- logDimensionCacheClearMethod(this.ownerNode, "deleteRule");
658
- cachedDimensions.clear();
659
- }
660
- get type() {
661
- return "text/css";
662
- }
663
- }, cssStyleSheetCstrName);
664
- const HTMLStyleDescriptorMap = {
665
- sheet: {
666
- get() {
667
- return new win[cssStyleSheetCstrName](this);
1391
+ }
1392
+ setter(newNode, ["innerHTML"], scriptContent);
1393
+ }
1394
+ }
1395
+ callMethod(this, ["insertBefore"], [newNode, referenceNode], 2);
1396
+ if (isIFrame) {
1397
+ const src = getInstanceStateValue(newNode, 0);
1398
+ if (src && src.startsWith("javascript:")) {
1399
+ const scriptContent = src.split("javascript:")[1];
1400
+ runScriptContent(env, instanceId, scriptContent, winId, "");
1401
+ }
1402
+ ((winId, iframe) => {
1403
+ let i = 0;
1404
+ let type;
1405
+ let handlers;
1406
+ let callback = () => {
1407
+ if (
1408
+ environments[winId] &&
1409
+ environments[winId].$isInitialized$ &&
1410
+ !environments[winId].$isLoading$
1411
+ ) {
1412
+ type = getInstanceStateValue(iframe, 1) ? "error" : "load";
1413
+ handlers = getInstanceStateValue(iframe, type);
1414
+ handlers &&
1415
+ handlers.map((handler) =>
1416
+ handler({
1417
+ type: type,
1418
+ })
1419
+ );
1420
+ } else if (i++ > 2e3) {
1421
+ handlers = getInstanceStateValue(iframe, "error");
1422
+ handlers &&
1423
+ handlers.map((handler) =>
1424
+ handler({
1425
+ type: "error",
1426
+ })
1427
+ );
1428
+ } else {
1429
+ setTimeout(callback, 9);
668
1430
  }
669
- }
670
- };
671
- definePrototypePropertyDescriptor(win.HTMLStyleElement, HTMLStyleDescriptorMap);
672
- };
673
- const getCssRules = (ownerNode, cssRules) => {
674
- cssRules = getInstanceStateValue(ownerNode, 2);
675
- if (!cssRules) {
676
- cssRules = getter(ownerNode, [ "sheet", "cssRules" ]);
677
- setInstanceStateValue(ownerNode, 2, cssRules);
678
- }
679
- return cssRules;
680
- };
681
- const getCssRule = (ownerNode, index, cssRules) => {
682
- cssRules = getCssRules(ownerNode);
683
- 0 === cssRules[index] && (cssRules[index] = getter(ownerNode, [ "sheet", "cssRules", parseInt(index, 10) ]));
684
- return cssRules[index];
685
- };
686
- const runScriptContent = (env, instanceId, scriptContent, winId, errorMsg) => {
687
- try {
688
- webWorkerCtx.$config$.logScriptExecution && logWorker(`Execute script: ${scriptContent.substring(0, 100).split("\n").map((l => l.trim())).join(" ").trim().substring(0, 60)}...`, winId);
689
- env.$currentScriptId$ = instanceId;
690
- run(env, scriptContent);
691
- } catch (contentError) {
692
- console.error(scriptContent, contentError);
693
- errorMsg = String(contentError.stack || contentError);
694
- }
695
- env.$currentScriptId$ = "";
696
- return errorMsg;
697
- };
698
- const run = (env, scriptContent, scriptUrl) => {
699
- env.$runWindowLoadEvent$ = 1;
700
- scriptContent = `with(this){${scriptContent.replace(/\bthis\b/g, "(thi$(this)?window:this)").replace(/\/\/# so/g, "//Xso")}\n;function thi$(t){return t===this}};${(webWorkerCtx.$config$.globalFns || []).filter((globalFnName => /[a-zA-Z_$][0-9a-zA-Z_$]*/.test(globalFnName))).map((g => `(typeof ${g}=='function'&&(this.${g}=${g}))`)).join(";")};` + (scriptUrl ? "\n//# sourceURL=" + scriptUrl : "");
701
- env.$isSameOrigin$ || (scriptContent = scriptContent.replace(/.postMessage\(/g, `.postMessage('${env.$winId$}',`));
702
- new Function(scriptContent).call(env.$window$);
703
- env.$runWindowLoadEvent$ = 0;
704
- };
705
- const runStateLoadHandlers = (instance, type, handlers) => {
706
- handlers = getInstanceStateValue(instance, type);
707
- handlers && setTimeout((() => handlers.map((cb => cb({
708
- type: type
709
- })))));
710
- };
711
- const resolveToUrl = (env, url, type, baseLocation, resolvedUrl, configResolvedUrl) => {
712
- baseLocation = env.$location$;
713
- while (!baseLocation.host) {
714
- env = environments[env.$parentWinId$];
715
- baseLocation = env.$location$;
716
- if (env.$winId$ === env.$parentWinId$) {
717
- break;
718
- }
719
- }
720
- resolvedUrl = new URL(url || "", baseLocation);
721
- if (type && webWorkerCtx.$config$.resolveUrl) {
722
- configResolvedUrl = webWorkerCtx.$config$.resolveUrl(resolvedUrl, baseLocation, type);
723
- if (configResolvedUrl) {
724
- return configResolvedUrl;
725
- }
726
- }
727
- return resolvedUrl;
728
- };
729
- const resolveUrl = (env, url, type) => resolveToUrl(env, url, type) + "";
730
- const getPartytownScript = () => `<script src="${partytownLibUrl("partytown.js?v=0.7.5")}"><\/script>`;
731
- const createImageConstructor = env => class HTMLImageElement {
732
- constructor() {
733
- this.s = "";
734
- this.l = [];
735
- this.e = [];
736
- this.style = {};
737
- }
738
- get src() {
739
- return this.s;
740
- }
741
- set src(src) {
742
- webWorkerCtx.$config$.logImageRequests && logWorker(`Image() request: ${resolveUrl(env, src, "image")}`, env.$winId$);
743
- this.s = src;
744
- fetch(resolveUrl(env, src, "image"), {
745
- mode: "no-cors",
746
- credentials: "include",
747
- keepalive: true
748
- }).then((rsp => {
749
- rsp.ok || 0 === rsp.status ? this.l.map((cb => cb({
750
- type: "load"
751
- }))) : this.e.map((cb => cb({
752
- type: "error"
753
- })));
754
- }), (() => this.e.forEach((cb => cb({
755
- type: "error"
756
- })))));
757
- }
758
- addEventListener(eventName, cb) {
759
- "load" === eventName && this.l.push(cb);
760
- "error" === eventName && this.e.push(cb);
1431
+ };
1432
+ callback();
1433
+ })(instanceId, newNode);
1434
+ }
1435
+ if (isScript) {
1436
+ sendToMain(true);
1437
+ webWorkerCtx.$postMessage$([7, winId]);
1438
+ }
1439
+ return newNode;
761
1440
  }
762
- get onload() {
763
- return this.l[0];
764
- }
765
- set onload(cb) {
766
- this.l = [ cb ];
1441
+ get nodeName() {
1442
+ return "#s" === this[InstanceDataKey]
1443
+ ? "#document-fragment"
1444
+ : this[InstanceDataKey];
767
1445
  }
768
- get onerror() {
769
- return this.e[0];
1446
+ get nodeType() {
1447
+ return 3;
770
1448
  }
771
- set onerror(cb) {
772
- this.e = [ cb ];
1449
+ get ownerDocument() {
1450
+ return env.$document$;
773
1451
  }
774
- };
775
- const HTMLSrcElementDescriptorMap = {
776
- addEventListener: {
777
- value(...args) {
778
- const eventName = args[0];
779
- const callbacks = getInstanceStateValue(this, eventName) || [];
780
- callbacks.push(args[1]);
781
- setInstanceStateValue(this, eventName, callbacks);
782
- }
1452
+ },
1453
+ "Node"
1454
+ );
1455
+ cachedTreeProps(
1456
+ WorkerNode,
1457
+ commaSplit(
1458
+ "childNodes,firstChild,isConnected,lastChild,nextSibling,parentElement,parentNode,previousSibling"
1459
+ )
1460
+ );
1461
+ win.Node = WorkerNode;
1462
+ };
1463
+ const htmlMedia = commaSplit("AUDIO,CANVAS,VIDEO");
1464
+ const windowMediaConstructors = commaSplit("Audio,MediaSource");
1465
+ const patchDocument = (WorkerDocument, env, isDocumentImplementation) => {
1466
+ const DocumentDescriptorMap = {
1467
+ body: {
1468
+ get: () => env.$body$,
1469
+ },
1470
+ cookie: {
1471
+ get() {
1472
+ if (env.$isSameOrigin$) {
1473
+ return getter(this, ["cookie"]);
1474
+ }
1475
+ warnCrossOrgin("get", "cookie", env);
1476
+ return "";
783
1477
  },
784
- async: {
785
- get: noop,
786
- set: noop
1478
+ set(value) {
1479
+ if (env.$isSameOrigin$) {
1480
+ setter(this, ["cookie"], value);
1481
+ } else {
1482
+ warnCrossOrgin("set", "cookie", env);
1483
+ }
787
1484
  },
788
- defer: {
789
- get: noop,
790
- set: noop
1485
+ },
1486
+ createElement: {
1487
+ value(tagName) {
1488
+ tagName = tagName.toUpperCase();
1489
+ if (!IS_TAG_REG.test(tagName)) {
1490
+ throw tagName + " not valid";
1491
+ }
1492
+ const isIframe = "IFRAME" === tagName;
1493
+ const winId = this[WinIdKey];
1494
+ const instanceId = (isIframe ? "f_" : "") + randomId();
1495
+ callMethod(this, ["createElement"], [tagName], 2, instanceId);
1496
+ const elm = getOrCreateNodeInstance(winId, instanceId, tagName);
1497
+ if (isIframe) {
1498
+ const env = createEnvironment(
1499
+ {
1500
+ $winId$: instanceId,
1501
+ $parentWinId$: winId,
1502
+ $url$: "about:blank",
1503
+ },
1504
+ true
1505
+ );
1506
+ env.$window$.fetch = fetch;
1507
+ setter(elm, ["srcdoc"], getPartytownScript());
1508
+ } else if ("SCRIPT" === tagName) {
1509
+ const scriptType = getInstanceStateValue(elm, 5);
1510
+ isScriptJsType(scriptType) &&
1511
+ setter(elm, ["type"], "text/partytown");
1512
+ }
1513
+ return elm;
791
1514
  },
792
- onload: {
793
- get() {
794
- let callbacks = getInstanceStateValue(this, "load");
795
- return callbacks && callbacks[0] || null;
796
- },
797
- set(cb) {
798
- setInstanceStateValue(this, "load", cb ? [ cb ] : null);
799
- }
1515
+ },
1516
+ createElementNS: {
1517
+ value(namespace, tagName) {
1518
+ const instanceId = randomId();
1519
+ const nsElm = getOrCreateNodeInstance(
1520
+ this[WinIdKey],
1521
+ instanceId,
1522
+ tagName,
1523
+ namespace
1524
+ );
1525
+ callMethod(
1526
+ this,
1527
+ ["createElementNS"],
1528
+ [namespace, tagName],
1529
+ 2,
1530
+ instanceId
1531
+ );
1532
+ return nsElm;
800
1533
  },
801
- onerror: {
802
- get() {
803
- let callbacks = getInstanceStateValue(this, "error");
804
- return callbacks && callbacks[0] || null;
805
- },
806
- set(cb) {
807
- setInstanceStateValue(this, "error", cb ? [ cb ] : null);
808
- }
1534
+ },
1535
+ createTextNode: {
1536
+ value(text) {
1537
+ const winId = this[WinIdKey];
1538
+ const instanceId = randomId();
1539
+ const textNode = getOrCreateNodeInstance(winId, instanceId, "#text");
1540
+ callMethod(this, ["createTextNode"], [text], 2, instanceId);
1541
+ return textNode;
809
1542
  },
810
- getAttribute: {
811
- value(attrName) {
812
- return "src" === attrName ? this.src : callMethod(this, [ "getAttribute" ], [ attrName ]);
813
- }
1543
+ },
1544
+ createEvent: {
1545
+ value: (type) => new Event(type),
1546
+ },
1547
+ currentScript: {
1548
+ get() {
1549
+ return env.$currentScriptId$
1550
+ ? getOrCreateNodeInstance(
1551
+ this[WinIdKey],
1552
+ env.$currentScriptId$,
1553
+ "SCRIPT"
1554
+ )
1555
+ : null;
814
1556
  },
815
- setAttribute: {
816
- value(attrName, attrValue) {
817
- scriptAttrPropNames.includes(attrName) ? this[attrName] = attrValue : callMethod(this, [ "setAttribute" ], [ attrName, attrValue ]);
818
- }
819
- }
820
- };
821
- const scriptAttrPropNames = commaSplit("src,type");
822
- const patchHTMLScriptElement = (WorkerHTMLScriptElement, env) => {
823
- const HTMLScriptDescriptorMap = {
824
- innerHTML: innerHTMLDescriptor,
825
- innerText: innerHTMLDescriptor,
826
- src: {
827
- get() {
828
- return getInstanceStateValue(this, 4) || "";
829
- },
830
- set(url) {
831
- const orgUrl = resolveUrl(env, url, null);
832
- const config = webWorkerCtx.$config$;
833
- url = resolveUrl(env, url, "script");
834
- setInstanceStateValue(this, 4, url);
835
- setter(this, [ "src" ], url);
836
- orgUrl !== url && setter(this, [ "dataset", "ptsrc" ], orgUrl);
837
- if (this.type && config.loadScriptsOnMainThread) {
838
- const shouldExecuteScriptViaMainThread = config.loadScriptsOnMainThread.some((scriptUrl => scriptUrl === url));
839
- shouldExecuteScriptViaMainThread && setter(this, [ "type" ], "text/javascript");
840
- }
1557
+ },
1558
+ defaultView: {
1559
+ get: () => (isDocumentImplementation ? null : env.$window$),
1560
+ },
1561
+ documentElement: {
1562
+ get: () => env.$documentElement$,
1563
+ },
1564
+ getElementsByTagName: {
1565
+ value(tagName) {
1566
+ tagName = tagName.toUpperCase();
1567
+ return "BODY" === tagName
1568
+ ? [env.$body$]
1569
+ : "HEAD" === tagName
1570
+ ? [env.$head$]
1571
+ : callMethod(this, ["getElementsByTagName"], [tagName]);
1572
+ },
1573
+ },
1574
+ head: {
1575
+ get: () => env.$head$,
1576
+ },
1577
+ images: {
1578
+ get() {
1579
+ return getter(this, ["images"]);
1580
+ },
1581
+ },
1582
+ implementation: {
1583
+ get() {
1584
+ return {
1585
+ hasFeature: () => true,
1586
+ createHTMLDocument: (title) => {
1587
+ const $winId$ = randomId();
1588
+ callMethod(
1589
+ this,
1590
+ ["implementation", "createHTMLDocument"],
1591
+ [title],
1592
+ 1,
1593
+ {
1594
+ $winId$: $winId$,
841
1595
  }
842
- },
843
- textContent: innerHTMLDescriptor,
844
- type: {
845
- get() {
846
- return getter(this, [ "type" ]);
1596
+ );
1597
+ const docEnv = createEnvironment(
1598
+ {
1599
+ $winId$: $winId$,
1600
+ $parentWinId$: $winId$,
1601
+ $url$: env.$location$ + "",
1602
+ $visibilityState$: "hidden",
847
1603
  },
848
- set(type) {
849
- if (!isScriptJsType(type)) {
850
- setInstanceStateValue(this, 5, type);
851
- setter(this, [ "type" ], type);
852
- }
853
- }
1604
+ true,
1605
+ true
1606
+ );
1607
+ return docEnv.$document$;
854
1608
  },
855
- ...HTMLSrcElementDescriptorMap
856
- };
857
- definePrototypePropertyDescriptor(WorkerHTMLScriptElement, HTMLScriptDescriptorMap);
1609
+ };
1610
+ },
1611
+ },
1612
+ location: {
1613
+ get: () => env.$location$,
1614
+ set(url) {
1615
+ env.$location$.href = url + "";
1616
+ },
1617
+ },
1618
+ nodeType: {
1619
+ value: 9,
1620
+ },
1621
+ parentNode: {
1622
+ value: null,
1623
+ },
1624
+ parentElement: {
1625
+ value: null,
1626
+ },
1627
+ readyState: {
1628
+ value: "complete",
1629
+ },
1630
+ visibilityState: {
1631
+ get: () => env.$visibilityState$ || "visible",
1632
+ },
858
1633
  };
859
- const innerHTMLDescriptor = {
1634
+ definePrototypePropertyDescriptor(WorkerDocument, DocumentDescriptorMap);
1635
+ cachedProps(WorkerDocument, "compatMode,referrer,forms");
1636
+ };
1637
+ const patchDocumentElementChild = (WokerDocumentElementChild, env) => {
1638
+ const DocumentElementChildDescriptorMap = {
1639
+ parentElement: {
860
1640
  get() {
861
- const type = getter(this, [ "type" ]);
862
- return isScriptJsType(type) ? getInstanceStateValue(this, 3) || "" : getter(this, [ "innerHTML" ]);
1641
+ return this.parentNode;
863
1642
  },
864
- set(scriptContent) {
865
- setInstanceStateValue(this, 3, scriptContent);
866
- }
1643
+ },
1644
+ parentNode: {
1645
+ get: () => env.$documentElement$,
1646
+ },
867
1647
  };
868
- const isScriptJsType = scriptType => !scriptType || "text/javascript" === scriptType;
869
- const createNodeCstr = (win, env, WorkerBase) => {
870
- const config = webWorkerCtx.$config$;
871
- const WorkerNode = defineConstructorName(class extends WorkerBase {
872
- appendChild(node) {
873
- return this.insertBefore(node, null);
874
- }
875
- get href() {}
876
- set href(_) {}
877
- insertBefore(newNode, referenceNode) {
878
- var _a, _b;
879
- const winId = newNode[WinIdKey] = this[WinIdKey];
880
- const instanceId = newNode[InstanceIdKey];
881
- const nodeName = newNode[InstanceDataKey];
882
- const isScript = "SCRIPT" === nodeName;
883
- const isIFrame = "IFRAME" === nodeName;
884
- if (isScript) {
885
- const scriptContent = getInstanceStateValue(newNode, 3);
886
- const scriptType = getInstanceStateValue(newNode, 5);
887
- if (scriptContent) {
888
- if (isScriptJsType(scriptType)) {
889
- const scriptId = newNode.id;
890
- const loadOnMainThread = scriptId && (null === (_b = null === (_a = config.loadScriptsOnMainThread) || void 0 === _a ? void 0 : _a.includes) || void 0 === _b ? void 0 : _b.call(_a, scriptId));
891
- if (loadOnMainThread) {
892
- setter(newNode, [ "type" ], "text/javascript");
893
- } else {
894
- const errorMsg = runScriptContent(env, instanceId, scriptContent, winId, "");
895
- const datasetType = errorMsg ? "pterror" : "ptid";
896
- const datasetValue = errorMsg || instanceId;
897
- setter(newNode, [ "type" ], "text/partytown-x");
898
- setter(newNode, [ "dataset", datasetType ], datasetValue);
899
- }
900
- }
901
- setter(newNode, [ "innerHTML" ], scriptContent);
902
- }
903
- }
904
- callMethod(this, [ "insertBefore" ], [ newNode, referenceNode ], 2);
905
- if (isIFrame) {
906
- const src = getInstanceStateValue(newNode, 0);
907
- if (src && src.startsWith("javascript:")) {
908
- const scriptContent = src.split("javascript:")[1];
909
- runScriptContent(env, instanceId, scriptContent, winId, "");
910
- }
911
- ((winId, iframe) => {
912
- let i = 0;
913
- let type;
914
- let handlers;
915
- let callback = () => {
916
- if (environments[winId] && environments[winId].$isInitialized$ && !environments[winId].$isLoading$) {
917
- type = getInstanceStateValue(iframe, 1) ? "error" : "load";
918
- handlers = getInstanceStateValue(iframe, type);
919
- handlers && handlers.map((handler => handler({
920
- type: type
921
- })));
922
- } else if (i++ > 2e3) {
923
- handlers = getInstanceStateValue(iframe, "error");
924
- handlers && handlers.map((handler => handler({
925
- type: "error"
926
- })));
927
- } else {
928
- setTimeout(callback, 9);
929
- }
930
- };
931
- callback();
932
- })(instanceId, newNode);
933
- }
934
- if (isScript) {
935
- sendToMain(true);
936
- webWorkerCtx.$postMessage$([ 7, winId ]);
937
- }
938
- return newNode;
939
- }
940
- get nodeName() {
941
- return "#s" === this[InstanceDataKey] ? "#document-fragment" : this[InstanceDataKey];
942
- }
943
- get nodeType() {
944
- return 3;
945
- }
946
- get ownerDocument() {
947
- return env.$document$;
948
- }
949
- }, "Node");
950
- cachedTreeProps(WorkerNode, commaSplit("childNodes,firstChild,isConnected,lastChild,nextSibling,parentElement,parentNode,previousSibling"));
951
- win.Node = WorkerNode;
1648
+ definePrototypePropertyDescriptor(
1649
+ WokerDocumentElementChild,
1650
+ DocumentElementChildDescriptorMap
1651
+ );
1652
+ };
1653
+ const patchElement = (WorkerElement, WorkerHTMLElement) => {
1654
+ const ElementDescriptorMap = {
1655
+ localName: {
1656
+ get() {
1657
+ return this[InstanceDataKey].toLowerCase();
1658
+ },
1659
+ },
1660
+ namespaceURI: {
1661
+ get() {
1662
+ return this[NamespaceKey] || "http://www.w3.org/1999/xhtml";
1663
+ },
1664
+ },
1665
+ nodeType: {
1666
+ value: 1,
1667
+ },
1668
+ tagName: {
1669
+ get() {
1670
+ return this[InstanceDataKey];
1671
+ },
1672
+ },
952
1673
  };
953
- const htmlMedia = commaSplit("AUDIO,CANVAS,VIDEO");
954
- const windowMediaConstructors = commaSplit("Audio,MediaSource");
955
- const patchDocument = (WorkerDocument, env, isDocumentImplementation) => {
956
- const DocumentDescriptorMap = {
957
- body: {
958
- get: () => env.$body$
959
- },
960
- cookie: {
961
- get() {
962
- if (env.$isSameOrigin$) {
963
- return getter(this, [ "cookie" ]);
964
- }
965
- warnCrossOrgin("get", "cookie", env);
966
- return "";
967
- },
968
- set(value) {
969
- if (env.$isSameOrigin$) {
970
- setter(this, [ "cookie" ], value);
971
- } else {
972
- warnCrossOrgin("set", "cookie", env);
973
- }
974
- }
975
- },
976
- createElement: {
977
- value(tagName) {
978
- tagName = tagName.toUpperCase();
979
- if (!IS_TAG_REG.test(tagName)) {
980
- throw tagName + " not valid";
981
- }
982
- const isIframe = "IFRAME" === tagName;
983
- const winId = this[WinIdKey];
984
- const instanceId = (isIframe ? "f_" : "") + randomId();
985
- callMethod(this, [ "createElement" ], [ tagName ], 2, instanceId);
986
- const elm = getOrCreateNodeInstance(winId, instanceId, tagName);
987
- if (isIframe) {
988
- const env = createEnvironment({
989
- $winId$: instanceId,
990
- $parentWinId$: winId,
991
- $url$: "about:blank"
992
- }, true);
993
- env.$window$.fetch = fetch;
994
- setter(elm, [ "srcdoc" ], getPartytownScript());
995
- } else if ("SCRIPT" === tagName) {
996
- const scriptType = getInstanceStateValue(elm, 5);
997
- isScriptJsType(scriptType) && setter(elm, [ "type" ], "text/partytown");
998
- }
999
- return elm;
1000
- }
1001
- },
1002
- createElementNS: {
1003
- value(namespace, tagName) {
1004
- const instanceId = randomId();
1005
- const nsElm = getOrCreateNodeInstance(this[WinIdKey], instanceId, tagName, namespace);
1006
- callMethod(this, [ "createElementNS" ], [ namespace, tagName ], 2, instanceId);
1007
- return nsElm;
1008
- }
1009
- },
1010
- createTextNode: {
1011
- value(text) {
1012
- const winId = this[WinIdKey];
1013
- const instanceId = randomId();
1014
- const textNode = getOrCreateNodeInstance(winId, instanceId, "#text");
1015
- callMethod(this, [ "createTextNode" ], [ text ], 2, instanceId);
1016
- return textNode;
1017
- }
1018
- },
1019
- createEvent: {
1020
- value: type => new Event(type)
1021
- },
1022
- currentScript: {
1023
- get() {
1024
- return env.$currentScriptId$ ? getOrCreateNodeInstance(this[WinIdKey], env.$currentScriptId$, "SCRIPT") : null;
1025
- }
1026
- },
1027
- defaultView: {
1028
- get: () => isDocumentImplementation ? null : env.$window$
1029
- },
1030
- documentElement: {
1031
- get: () => env.$documentElement$
1032
- },
1033
- getElementsByTagName: {
1034
- value(tagName) {
1035
- tagName = tagName.toUpperCase();
1036
- return "BODY" === tagName ? [ env.$body$ ] : "HEAD" === tagName ? [ env.$head$ ] : callMethod(this, [ "getElementsByTagName" ], [ tagName ]);
1037
- }
1038
- },
1039
- head: {
1040
- get: () => env.$head$
1041
- },
1042
- images: {
1043
- get() {
1044
- return getter(this, [ "images" ]);
1674
+ definePrototypePropertyDescriptor(WorkerElement, ElementDescriptorMap);
1675
+ cachedTreeProps(WorkerElement, elementStructurePropNames);
1676
+ cachedProps(WorkerElement, "id");
1677
+ cachedDimensionProps(WorkerHTMLElement);
1678
+ cachedDimensionMethods(
1679
+ WorkerHTMLElement,
1680
+ commaSplit("getClientRects,getBoundingClientRect")
1681
+ );
1682
+ };
1683
+ const patchHTMLAnchorElement = (WorkerHTMLAnchorElement, env) => {
1684
+ const HTMLAnchorDescriptorMap = {};
1685
+ commaSplit(
1686
+ "hash,host,hostname,href,origin,pathname,port,protocol,search"
1687
+ ).map((anchorProp) => {
1688
+ HTMLAnchorDescriptorMap[anchorProp] = {
1689
+ get() {
1690
+ let value = getInstanceStateValue(this, 4);
1691
+ let href;
1692
+ if ("string" != typeof value) {
1693
+ href = getter(this, ["href"]);
1694
+ setInstanceStateValue(this, 4, href);
1695
+ value = new URL(href)[anchorProp];
1696
+ }
1697
+ return resolveToUrl(env, value, null)[anchorProp];
1698
+ },
1699
+ set(value) {
1700
+ let url;
1701
+ if ("href" === anchorProp) {
1702
+ if (
1703
+ ((url) => {
1704
+ try {
1705
+ new URL(url);
1706
+ return true;
1707
+ } catch (_) {
1708
+ return false;
1045
1709
  }
1046
- },
1047
- implementation: {
1048
- get() {
1049
- return {
1050
- hasFeature: () => true,
1051
- createHTMLDocument: title => {
1052
- const $winId$ = randomId();
1053
- callMethod(this, [ "implementation", "createHTMLDocument" ], [ title ], 1, {
1054
- $winId$: $winId$
1055
- });
1056
- const docEnv = createEnvironment({
1057
- $winId$: $winId$,
1058
- $parentWinId$: $winId$,
1059
- $url$: env.$location$ + "",
1060
- $visibilityState$: "hidden"
1061
- }, true, true);
1062
- return docEnv.$document$;
1710
+ })(value)
1711
+ ) {
1712
+ url = new URL(value);
1713
+ } else {
1714
+ const baseHref = env.$location$.href;
1715
+ url = resolveToUrl(env, baseHref, null);
1716
+ url.href = new URL(value + "", url.href);
1717
+ }
1718
+ } else {
1719
+ url = resolveToUrl(env, this.href, null);
1720
+ url[anchorProp] = value;
1721
+ }
1722
+ setInstanceStateValue(this, 4, url.href);
1723
+ setter(this, ["href"], url.href);
1724
+ },
1725
+ };
1726
+ });
1727
+ definePrototypePropertyDescriptor(
1728
+ WorkerHTMLAnchorElement,
1729
+ HTMLAnchorDescriptorMap
1730
+ );
1731
+ };
1732
+ const patchHTMLIFrameElement = (WorkerHTMLIFrameElement, env) => {
1733
+ const HTMLIFrameDescriptorMap = {
1734
+ contentDocument: {
1735
+ get() {
1736
+ return getIframeEnv(this).$document$;
1737
+ },
1738
+ },
1739
+ contentWindow: {
1740
+ get() {
1741
+ return getIframeEnv(this).$window$;
1742
+ },
1743
+ },
1744
+ src: {
1745
+ get() {
1746
+ let src = getInstanceStateValue(this, 0);
1747
+ if (src && src.startsWith("javascript:")) {
1748
+ return src;
1749
+ }
1750
+ src = getIframeEnv(this).$location$.href;
1751
+ return src.startsWith("about:") ? "" : src;
1752
+ },
1753
+ set(src) {
1754
+ if (src) {
1755
+ if (src.startsWith("javascript:")) {
1756
+ setInstanceStateValue(this, 0, src);
1757
+ } else if (!src.startsWith("about:")) {
1758
+ let xhr = new XMLHttpRequest();
1759
+ let xhrStatus;
1760
+ let env = getIframeEnv(this);
1761
+ env.$location$.href = src = resolveUrl(env, src, "input");
1762
+ env.$isLoading$ = 1;
1763
+ setInstanceStateValue(this, 1, void 0);
1764
+ xhr.open("GET", src, false);
1765
+ xhr.send();
1766
+ xhrStatus = xhr.status;
1767
+ if (xhrStatus > 199 && xhrStatus < 300) {
1768
+ setter(
1769
+ this,
1770
+ ["srcdoc"],
1771
+ `<base href="${src}">` +
1772
+ (function (text) {
1773
+ return text.replace(SCRIPT_TAG_REGEXP, (_, attrs) => {
1774
+ const parts = [];
1775
+ let hasType = false;
1776
+ let match;
1777
+ while ((match = ATTR_REGEXP.exec(attrs))) {
1778
+ let [keyValue] = match;
1779
+ if (keyValue.startsWith("type=")) {
1780
+ hasType = true;
1781
+ keyValue = keyValue.replace(
1782
+ /(application|text)\/javascript/,
1783
+ SCRIPT_TYPE
1784
+ );
1785
+ }
1786
+ parts.push(keyValue);
1063
1787
  }
1064
- };
1065
- }
1066
- },
1067
- location: {
1068
- get: () => env.$location$,
1069
- set(url) {
1070
- env.$location$.href = url + "";
1071
- }
1072
- },
1073
- nodeType: {
1074
- value: 9
1075
- },
1076
- parentNode: {
1077
- value: null
1078
- },
1079
- parentElement: {
1080
- value: null
1081
- },
1082
- readyState: {
1083
- value: "complete"
1084
- },
1085
- visibilityState: {
1086
- get: () => env.$visibilityState$ || "visible"
1087
- }
1088
- };
1089
- definePrototypePropertyDescriptor(WorkerDocument, DocumentDescriptorMap);
1090
- cachedProps(WorkerDocument, "compatMode,referrer,forms");
1091
- };
1092
- const patchDocumentElementChild = (WokerDocumentElementChild, env) => {
1093
- const DocumentElementChildDescriptorMap = {
1094
- parentElement: {
1095
- get() {
1096
- return this.parentNode;
1097
- }
1098
- },
1099
- parentNode: {
1100
- get: () => env.$documentElement$
1101
- }
1102
- };
1103
- definePrototypePropertyDescriptor(WokerDocumentElementChild, DocumentElementChildDescriptorMap);
1788
+ hasType || parts.push('type="text/partytown"');
1789
+ return `<script ${parts.join(" ")}>`;
1790
+ });
1791
+ })(xhr.responseText) +
1792
+ getPartytownScript()
1793
+ );
1794
+ sendToMain(true);
1795
+ webWorkerCtx.$postMessage$([7, env.$winId$]);
1796
+ } else {
1797
+ setInstanceStateValue(this, 1, xhrStatus);
1798
+ env.$isLoading$ = 0;
1799
+ }
1800
+ }
1801
+ }
1802
+ },
1803
+ },
1804
+ ...HTMLSrcElementDescriptorMap,
1104
1805
  };
1105
- const patchElement = (WorkerElement, WorkerHTMLElement) => {
1106
- const ElementDescriptorMap = {
1107
- localName: {
1108
- get() {
1109
- return this[InstanceDataKey].toLowerCase();
1110
- }
1111
- },
1112
- namespaceURI: {
1113
- get() {
1114
- return this[NamespaceKey] || "http://www.w3.org/1999/xhtml";
1115
- }
1116
- },
1117
- nodeType: {
1118
- value: 1
1119
- },
1120
- tagName: {
1121
- get() {
1122
- return this[InstanceDataKey];
1123
- }
1124
- }
1125
- };
1126
- definePrototypePropertyDescriptor(WorkerElement, ElementDescriptorMap);
1127
- cachedTreeProps(WorkerElement, elementStructurePropNames);
1128
- cachedProps(WorkerElement, "id");
1129
- cachedDimensionProps(WorkerHTMLElement);
1130
- cachedDimensionMethods(WorkerHTMLElement, commaSplit("getClientRects,getBoundingClientRect"));
1806
+ definePrototypePropertyDescriptor(
1807
+ WorkerHTMLIFrameElement,
1808
+ HTMLIFrameDescriptorMap
1809
+ );
1810
+ };
1811
+ const ATTR_REGEXP_STR =
1812
+ "((?:\\w|-)+(?:=(?:(?:\\w|-)+|'[^']*'|\"[^\"]*\")?)?)";
1813
+ const SCRIPT_TAG_REGEXP = new RegExp(
1814
+ `<script\\s*((${ATTR_REGEXP_STR}\\s*)*)>`,
1815
+ "mg"
1816
+ );
1817
+ const ATTR_REGEXP = new RegExp(ATTR_REGEXP_STR, "mg");
1818
+ const getIframeEnv = (iframe) => {
1819
+ const $winId$ = iframe[InstanceIdKey];
1820
+ environments[$winId$] ||
1821
+ createEnvironment(
1822
+ {
1823
+ $winId$: $winId$,
1824
+ $parentWinId$: iframe[WinIdKey],
1825
+ $url$: getter(iframe, ["src"]) || "about:blank",
1826
+ },
1827
+ true
1828
+ );
1829
+ return environments[$winId$];
1830
+ };
1831
+ const patchSvgElement = (WorkerSVGGraphicsElement) => {
1832
+ const getMatrix = (elm, methodName) => {
1833
+ const {
1834
+ a: a,
1835
+ b: b,
1836
+ c: c,
1837
+ d: d,
1838
+ e: e,
1839
+ f: f,
1840
+ } = callMethod(elm, [methodName], EMPTY_ARRAY);
1841
+ return new DOMMatrixReadOnly([a, b, c, d, e, f]);
1131
1842
  };
1132
- const patchHTMLAnchorElement = (WorkerHTMLAnchorElement, env) => {
1133
- const HTMLAnchorDescriptorMap = {};
1134
- commaSplit("hash,host,hostname,href,origin,pathname,port,protocol,search").map((anchorProp => {
1135
- HTMLAnchorDescriptorMap[anchorProp] = {
1136
- get() {
1137
- let value = getInstanceStateValue(this, 4);
1138
- let href;
1139
- if ("string" != typeof value) {
1140
- href = getter(this, [ "href" ]);
1141
- setInstanceStateValue(this, 4, href);
1142
- value = new URL(href)[anchorProp];
1143
- }
1144
- return resolveToUrl(env, value, null)[anchorProp];
1145
- },
1146
- set(value) {
1147
- let url;
1148
- if ("href" === anchorProp) {
1149
- if ((url => {
1150
- try {
1151
- new URL(url);
1152
- return true;
1153
- } catch (_) {
1154
- return false;
1155
- }
1156
- })(value)) {
1157
- url = new URL(value);
1158
- } else {
1159
- const baseHref = env.$location$.href;
1160
- url = resolveToUrl(env, baseHref, null);
1161
- url.href = new URL(value + "", url.href);
1162
- }
1163
- } else {
1164
- url = resolveToUrl(env, this.href, null);
1165
- url[anchorProp] = value;
1166
- }
1167
- setInstanceStateValue(this, 4, url.href);
1168
- setter(this, [ "href" ], url.href);
1169
- }
1170
- };
1171
- }));
1172
- definePrototypePropertyDescriptor(WorkerHTMLAnchorElement, HTMLAnchorDescriptorMap);
1843
+ const SVGGraphicsElementDescriptorMap = {
1844
+ ...WorkerSVGGraphicsElement,
1845
+ getCTM: {
1846
+ value: function () {
1847
+ return getMatrix(this, "getCTM");
1848
+ },
1849
+ },
1850
+ getScreenCTM: {
1851
+ value: function () {
1852
+ return getMatrix(this, "getScreenCTM");
1853
+ },
1854
+ },
1173
1855
  };
1174
- const patchHTMLIFrameElement = (WorkerHTMLIFrameElement, env) => {
1175
- const HTMLIFrameDescriptorMap = {
1176
- contentDocument: {
1177
- get() {
1178
- return getIframeEnv(this).$document$;
1179
- }
1180
- },
1181
- contentWindow: {
1182
- get() {
1183
- return getIframeEnv(this).$window$;
1184
- }
1856
+ definePrototypePropertyDescriptor(
1857
+ WorkerSVGGraphicsElement,
1858
+ SVGGraphicsElementDescriptorMap
1859
+ );
1860
+ };
1861
+ const createNamedNodeMapCstr = (win, WorkerBase) => {
1862
+ win.NamedNodeMap = defineConstructorName(
1863
+ class NamedNodeMap extends WorkerBase {
1864
+ constructor(winId, instanceId, applyPath) {
1865
+ super(winId, instanceId, applyPath);
1866
+ return new Proxy(this, {
1867
+ get(target, propName) {
1868
+ const handler = NAMED_NODE_MAP_HANDLERS[propName];
1869
+ return handler
1870
+ ? handler.bind(target, [propName])
1871
+ : getter(target, [propName]);
1185
1872
  },
1186
- src: {
1187
- get() {
1188
- let src = getInstanceStateValue(this, 0);
1189
- if (src && src.startsWith("javascript:")) {
1190
- return src;
1191
- }
1192
- src = getIframeEnv(this).$location$.href;
1193
- return src.startsWith("about:") ? "" : src;
1194
- },
1195
- set(src) {
1196
- if (src) {
1197
- if (src.startsWith("javascript:")) {
1198
- setInstanceStateValue(this, 0, src);
1199
- } else if (!src.startsWith("about:")) {
1200
- let xhr = new XMLHttpRequest;
1201
- let xhrStatus;
1202
- let env = getIframeEnv(this);
1203
- env.$location$.href = src = resolveUrl(env, src, "iframe");
1204
- env.$isLoading$ = 1;
1205
- setInstanceStateValue(this, 1, void 0);
1206
- xhr.open("GET", src, false);
1207
- xhr.send();
1208
- xhrStatus = xhr.status;
1209
- if (xhrStatus > 199 && xhrStatus < 300) {
1210
- setter(this, [ "srcdoc" ], `<base href="${src}">` + function(text) {
1211
- return text.replace(SCRIPT_TAG_REGEXP, ((_, attrs) => {
1212
- const parts = [];
1213
- let hasType = false;
1214
- let match;
1215
- while (match = ATTR_REGEXP.exec(attrs)) {
1216
- let [keyValue] = match;
1217
- if (keyValue.startsWith("type=")) {
1218
- hasType = true;
1219
- keyValue = keyValue.replace(/(application|text)\/javascript/, SCRIPT_TYPE);
1220
- }
1221
- parts.push(keyValue);
1222
- }
1223
- hasType || parts.push('type="text/partytown"');
1224
- return `<script ${parts.join(" ")}>`;
1225
- }));
1226
- }(xhr.responseText) + getPartytownScript());
1227
- sendToMain(true);
1228
- webWorkerCtx.$postMessage$([ 7, env.$winId$ ]);
1229
- } else {
1230
- setInstanceStateValue(this, 1, xhrStatus);
1231
- env.$isLoading$ = 0;
1232
- }
1233
- }
1234
- }
1235
- }
1873
+ set(target, propName, propValue) {
1874
+ const handler = NAMED_NODE_MAP_HANDLERS[propName];
1875
+ if (handler) {
1876
+ throw new Error(
1877
+ "Can't set read-only property: " + String(propName)
1878
+ );
1879
+ }
1880
+ setter(target, [propName], propValue);
1881
+ return true;
1236
1882
  },
1237
- ...HTMLSrcElementDescriptorMap
1238
- };
1239
- definePrototypePropertyDescriptor(WorkerHTMLIFrameElement, HTMLIFrameDescriptorMap);
1883
+ });
1884
+ }
1885
+ },
1886
+ "NamedNodeMap"
1887
+ );
1888
+ };
1889
+ function method(applyPath, ...args) {
1890
+ return callMethod(this, applyPath, args, 1);
1891
+ }
1892
+ const NAMED_NODE_MAP_HANDLERS = {
1893
+ getNamedItem: method,
1894
+ getNamedItemNS: method,
1895
+ item: method,
1896
+ removeNamedItem: method,
1897
+ removeNamedItemNS: method,
1898
+ setNamedItem: method,
1899
+ setNamedItemNS: method,
1900
+ };
1901
+ const createWindow = (
1902
+ $winId$,
1903
+ $parentWinId$,
1904
+ url,
1905
+ $visibilityState$,
1906
+ isIframeWindow,
1907
+ isDocumentImplementation
1908
+ ) => {
1909
+ let cstrInstanceId;
1910
+ let cstrNodeName;
1911
+ let cstrNamespace;
1912
+ const WorkerBase = class {
1913
+ constructor(winId, instanceId, applyPath, instanceData, namespace) {
1914
+ this[WinIdKey] = winId || $winId$;
1915
+ this[InstanceIdKey] = instanceId || cstrInstanceId || randomId();
1916
+ this[ApplyPathKey] = applyPath || [];
1917
+ this[InstanceDataKey] = instanceData || cstrNodeName;
1918
+ this[NamespaceKey] = namespace || cstrNamespace;
1919
+ this[InstanceStateKey] = {};
1920
+ cstrInstanceId = cstrNodeName = cstrNamespace = void 0;
1921
+ }
1240
1922
  };
1241
- const ATTR_REGEXP_STR = "((?:\\w|-)+(?:=(?:(?:\\w|-)+|'[^']*'|\"[^\"]*\")?)?)";
1242
- const SCRIPT_TAG_REGEXP = new RegExp(`<script\\s*((${ATTR_REGEXP_STR}\\s*)*)>`, "mg");
1243
- const ATTR_REGEXP = new RegExp(ATTR_REGEXP_STR, "mg");
1244
- const getIframeEnv = iframe => {
1245
- const $winId$ = iframe[InstanceIdKey];
1246
- environments[$winId$] || createEnvironment({
1247
- $winId$: $winId$,
1248
- $parentWinId$: iframe[WinIdKey],
1249
- $url$: getter(iframe, [ "src" ]) || "about:blank"
1250
- }, true);
1251
- return environments[$winId$];
1923
+ const WorkerLocation = defineConstructorName(
1924
+ class extends URL {
1925
+ assign() {
1926
+ logWorker("location.assign(), noop");
1927
+ }
1928
+ reload() {
1929
+ logWorker("location.reload(), noop");
1930
+ }
1931
+ replace() {
1932
+ logWorker("location.replace(), noop");
1933
+ }
1934
+ },
1935
+ "Location"
1936
+ );
1937
+ const $location$ = new WorkerLocation(url);
1938
+ const $isSameOrigin$ =
1939
+ $location$.origin === webWorkerCtx.$origin$ ||
1940
+ "about:blank" === $location$.origin;
1941
+ const $isTopWindow$ = $parentWinId$ === $winId$;
1942
+ const env = {};
1943
+ const getChildEnvs = () => {
1944
+ let childEnv = [];
1945
+ let envWinId;
1946
+ let otherEnv;
1947
+ for (envWinId in environments) {
1948
+ otherEnv = environments[envWinId];
1949
+ otherEnv.$parentWinId$ !== $winId$ ||
1950
+ otherEnv.$isTopWindow$ ||
1951
+ childEnv.push(otherEnv);
1952
+ }
1953
+ return childEnv;
1252
1954
  };
1253
- const patchSvgElement = WorkerSVGGraphicsElement => {
1254
- const getMatrix = (elm, methodName) => {
1255
- const {a: a, b: b, c: c, d: d, e: e, f: f} = callMethod(elm, [ methodName ], EMPTY_ARRAY);
1256
- return new DOMMatrixReadOnly([ a, b, c, d, e, f ]);
1257
- };
1258
- const SVGGraphicsElementDescriptorMap = {
1259
- ...WorkerSVGGraphicsElement,
1260
- getCTM: {
1261
- value: function() {
1262
- return getMatrix(this, "getCTM");
1955
+ const WorkerWindow = defineConstructorName(
1956
+ class extends WorkerBase {
1957
+ constructor() {
1958
+ super($winId$, $winId$);
1959
+ let win = this;
1960
+ let value;
1961
+ let historyState;
1962
+ let hasInitializedMedia = 0;
1963
+ let initWindowMedia = () => {
1964
+ if (!hasInitializedMedia) {
1965
+ (() => {
1966
+ if (!webWorkerCtx.$initWindowMedia$) {
1967
+ self.$bridgeToMedia$ = [
1968
+ getter,
1969
+ setter,
1970
+ callMethod,
1971
+ constructGlobal,
1972
+ definePrototypePropertyDescriptor,
1973
+ randomId,
1974
+ WinIdKey,
1975
+ InstanceIdKey,
1976
+ ApplyPathKey,
1977
+ ];
1978
+ webWorkerCtx.$importScripts$(
1979
+ partytownLibUrl("partytown-media.js?v=0.7.5")
1980
+ );
1981
+ webWorkerCtx.$initWindowMedia$ = self.$bridgeFromMedia$;
1982
+ delete self.$bridgeFromMedia$;
1263
1983
  }
1264
- },
1265
- getScreenCTM: {
1266
- value: function() {
1267
- return getMatrix(this, "getScreenCTM");
1984
+ return webWorkerCtx.$initWindowMedia$;
1985
+ })()(
1986
+ WorkerBase,
1987
+ WorkerEventTargetProxy,
1988
+ env,
1989
+ win,
1990
+ windowMediaConstructors
1991
+ );
1992
+ hasInitializedMedia = 1;
1993
+ }
1994
+ };
1995
+ let nodeCstrs = {};
1996
+ let $createNode$ = (nodeName, instanceId, namespace) => {
1997
+ htmlMedia.includes(nodeName) && initWindowMedia();
1998
+ const NodeCstr = nodeCstrs[nodeName]
1999
+ ? nodeCstrs[nodeName]
2000
+ : nodeName.includes("-")
2001
+ ? nodeCstrs.UNKNOWN
2002
+ : nodeCstrs.I;
2003
+ cstrInstanceId = instanceId;
2004
+ cstrNodeName = nodeName;
2005
+ cstrNamespace = namespace;
2006
+ return new NodeCstr();
2007
+ };
2008
+ win.Window = WorkerWindow;
2009
+ win.name = name + `${normalizedWinId($winId$)} (${$winId$})`;
2010
+ createNodeCstr(win, env, WorkerBase);
2011
+ ((win) => {
2012
+ win.NodeList = defineConstructorName(NodeList, "NodeList");
2013
+ })(win);
2014
+ createNamedNodeMapCstr(win, WorkerBase);
2015
+ createCSSStyleDeclarationCstr(win, WorkerBase, "CSSStyleDeclaration");
2016
+ ((win, WorkerBase, cstrName) => {
2017
+ win[cstrName] = defineConstructorName(
2018
+ class extends WorkerBase {
2019
+ now() {
2020
+ return performance.now();
1268
2021
  }
1269
- }
1270
- };
1271
- definePrototypePropertyDescriptor(WorkerSVGGraphicsElement, SVGGraphicsElementDescriptorMap);
1272
- };
1273
- const createNamedNodeMapCstr = (win, WorkerBase) => {
1274
- win.NamedNodeMap = defineConstructorName(class NamedNodeMap extends WorkerBase {
1275
- constructor(winId, instanceId, applyPath) {
1276
- super(winId, instanceId, applyPath);
1277
- return new Proxy(this, {
1278
- get(target, propName) {
1279
- const handler = NAMED_NODE_MAP_HANDLERS[propName];
1280
- return handler ? handler.bind(target, [ propName ]) : getter(target, [ propName ]);
1281
- },
1282
- set(target, propName, propValue) {
1283
- const handler = NAMED_NODE_MAP_HANDLERS[propName];
1284
- if (handler) {
1285
- throw new Error("Can't set read-only property: " + String(propName));
1286
- }
1287
- setter(target, [ propName ], propValue);
1288
- return true;
1289
- }
1290
- });
1291
- }
1292
- }, "NamedNodeMap");
1293
- };
1294
- function method(applyPath, ...args) {
1295
- return callMethod(this, applyPath, args, 1);
1296
- }
1297
- const NAMED_NODE_MAP_HANDLERS = {
1298
- getNamedItem: method,
1299
- getNamedItemNS: method,
1300
- item: method,
1301
- removeNamedItem: method,
1302
- removeNamedItemNS: method,
1303
- setNamedItem: method,
1304
- setNamedItemNS: method
1305
- };
1306
- const createWindow = ($winId$, $parentWinId$, url, $visibilityState$, isIframeWindow, isDocumentImplementation) => {
1307
- let cstrInstanceId;
1308
- let cstrNodeName;
1309
- let cstrNamespace;
1310
- const WorkerBase = class {
1311
- constructor(winId, instanceId, applyPath, instanceData, namespace) {
1312
- this[WinIdKey] = winId || $winId$;
1313
- this[InstanceIdKey] = instanceId || cstrInstanceId || randomId();
1314
- this[ApplyPathKey] = applyPath || [];
1315
- this[InstanceDataKey] = instanceData || cstrNodeName;
1316
- this[NamespaceKey] = namespace || cstrNamespace;
1317
- this[InstanceStateKey] = {};
1318
- cstrInstanceId = cstrNodeName = cstrNamespace = void 0;
1319
- }
1320
- };
1321
- const WorkerLocation = defineConstructorName(class extends URL {
1322
- assign() {
1323
- logWorker("location.assign(), noop");
1324
- }
1325
- reload() {
1326
- logWorker("location.reload(), noop");
1327
- }
1328
- replace() {
1329
- logWorker("location.replace(), noop");
1330
- }
1331
- }, "Location");
1332
- const $location$ = new WorkerLocation(url);
1333
- const $isSameOrigin$ = $location$.origin === webWorkerCtx.$origin$ || "about:blank" === $location$.origin;
1334
- const $isTopWindow$ = $parentWinId$ === $winId$;
1335
- const env = {};
1336
- const getChildEnvs = () => {
1337
- let childEnv = [];
1338
- let envWinId;
1339
- let otherEnv;
1340
- for (envWinId in environments) {
1341
- otherEnv = environments[envWinId];
1342
- otherEnv.$parentWinId$ !== $winId$ || otherEnv.$isTopWindow$ || childEnv.push(otherEnv);
1343
- }
1344
- return childEnv;
1345
- };
1346
- const WorkerWindow = defineConstructorName(class extends WorkerBase {
1347
- constructor() {
1348
- super($winId$, $winId$);
1349
- let win = this;
1350
- let value;
1351
- let historyState;
1352
- let hasInitializedMedia = 0;
1353
- let initWindowMedia = () => {
1354
- if (!hasInitializedMedia) {
1355
- (() => {
1356
- if (!webWorkerCtx.$initWindowMedia$) {
1357
- self.$bridgeToMedia$ = [ getter, setter, callMethod, constructGlobal, definePrototypePropertyDescriptor, randomId, WinIdKey, InstanceIdKey, ApplyPathKey ];
1358
- webWorkerCtx.$importScripts$(partytownLibUrl("partytown-media.js?v=0.7.5"));
1359
- webWorkerCtx.$initWindowMedia$ = self.$bridgeFromMedia$;
1360
- delete self.$bridgeFromMedia$;
1361
- }
1362
- return webWorkerCtx.$initWindowMedia$;
1363
- })()(WorkerBase, WorkerEventTargetProxy, env, win, windowMediaConstructors);
1364
- hasInitializedMedia = 1;
2022
+ },
2023
+ cstrName
2024
+ );
2025
+ })(win, WorkerBase, "Performance");
2026
+ ((win, nodeCstrs) => {
2027
+ const registry = new Map();
2028
+ win.customElements = {
2029
+ define(tagName, Cstr, opts) {
2030
+ registry.set(tagName, Cstr);
2031
+ nodeCstrs[tagName.toUpperCase()] = Cstr;
2032
+ const ceData = [Cstr.name, Cstr.observedAttributes];
2033
+ callMethod(
2034
+ win,
2035
+ ["customElements", "define"],
2036
+ [tagName, ceData, opts]
2037
+ );
2038
+ },
2039
+ get: (tagName) =>
2040
+ registry.get(tagName) ||
2041
+ callMethod(win, ["customElements", "get"], [tagName]),
2042
+ whenDefined: (tagName) =>
2043
+ registry.has(tagName)
2044
+ ? Promise.resolve()
2045
+ : callMethod(
2046
+ win,
2047
+ ["customElements", "whenDefined"],
2048
+ [tagName]
2049
+ ),
2050
+ upgrade: (elm) =>
2051
+ callMethod(win, ["customElements", "upgrade"], [elm]),
2052
+ };
2053
+ })(win, nodeCstrs);
2054
+ webWorkerCtx.$interfaces$.map(
2055
+ ([cstrName, superCstrName, members, interfaceType, nodeName]) => {
2056
+ const SuperCstr = TrapConstructors[cstrName]
2057
+ ? WorkerTrapProxy
2058
+ : "EventTarget" === superCstrName
2059
+ ? WorkerEventTargetProxy
2060
+ : "Object" === superCstrName
2061
+ ? WorkerBase
2062
+ : win[superCstrName];
2063
+ const Cstr = (win[cstrName] = defineConstructorName(
2064
+ 12 === interfaceType
2065
+ ? class extends WorkerBase {
2066
+ constructor(...args) {
2067
+ super();
2068
+ constructGlobal(this, cstrName, args);
2069
+ }
1365
2070
  }
1366
- };
1367
- let nodeCstrs = {};
1368
- let $createNode$ = (nodeName, instanceId, namespace) => {
1369
- htmlMedia.includes(nodeName) && initWindowMedia();
1370
- const NodeCstr = nodeCstrs[nodeName] ? nodeCstrs[nodeName] : nodeName.includes("-") ? nodeCstrs.UNKNOWN : nodeCstrs.I;
1371
- cstrInstanceId = instanceId;
1372
- cstrNodeName = nodeName;
1373
- cstrNamespace = namespace;
1374
- return new NodeCstr;
1375
- };
1376
- win.Window = WorkerWindow;
1377
- win.name = name + `${normalizedWinId($winId$)} (${$winId$})`;
1378
- createNodeCstr(win, env, WorkerBase);
1379
- (win => {
1380
- win.NodeList = defineConstructorName(NodeList, "NodeList");
1381
- })(win);
1382
- createNamedNodeMapCstr(win, WorkerBase);
1383
- createCSSStyleDeclarationCstr(win, WorkerBase, "CSSStyleDeclaration");
1384
- ((win, WorkerBase, cstrName) => {
1385
- win[cstrName] = defineConstructorName(class extends WorkerBase {
1386
- now() {
1387
- return performance.now();
1388
- }
1389
- }, cstrName);
1390
- })(win, WorkerBase, "Performance");
1391
- ((win, nodeCstrs) => {
1392
- const registry = new Map;
1393
- win.customElements = {
1394
- define(tagName, Cstr, opts) {
1395
- registry.set(tagName, Cstr);
1396
- nodeCstrs[tagName.toUpperCase()] = Cstr;
1397
- const ceData = [ Cstr.name, Cstr.observedAttributes ];
1398
- callMethod(win, [ "customElements", "define" ], [ tagName, ceData, opts ]);
2071
+ : win[cstrName] || class extends SuperCstr {},
2072
+ cstrName
2073
+ ));
2074
+ nodeName && (nodeCstrs[nodeName] = Cstr);
2075
+ members.map(([memberName, memberType, staticValue]) => {
2076
+ memberName in Cstr.prototype ||
2077
+ memberName in SuperCstr.prototype ||
2078
+ ("string" == typeof memberType
2079
+ ? definePrototypeProperty(Cstr, memberName, {
2080
+ get() {
2081
+ if (!hasInstanceStateValue(this, memberName)) {
2082
+ const instanceId = this[InstanceIdKey];
2083
+ const applyPath = [
2084
+ ...this[ApplyPathKey],
2085
+ memberName,
2086
+ ];
2087
+ const PropCstr = win[memberType];
2088
+ PropCstr &&
2089
+ setInstanceStateValue(
2090
+ this,
2091
+ memberName,
2092
+ new PropCstr($winId$, instanceId, applyPath)
2093
+ );
2094
+ }
2095
+ return getInstanceStateValue(this, memberName);
1399
2096
  },
1400
- get: tagName => registry.get(tagName) || callMethod(win, [ "customElements", "get" ], [ tagName ]),
1401
- whenDefined: tagName => registry.has(tagName) ? Promise.resolve() : callMethod(win, [ "customElements", "whenDefined" ], [ tagName ]),
1402
- upgrade: elm => callMethod(win, [ "customElements", "upgrade" ], [ elm ])
1403
- };
1404
- })(win, nodeCstrs);
1405
- webWorkerCtx.$interfaces$.map((([cstrName, superCstrName, members, interfaceType, nodeName]) => {
1406
- const SuperCstr = TrapConstructors[cstrName] ? WorkerTrapProxy : "EventTarget" === superCstrName ? WorkerEventTargetProxy : "Object" === superCstrName ? WorkerBase : win[superCstrName];
1407
- const Cstr = win[cstrName] = defineConstructorName(12 === interfaceType ? class extends WorkerBase {
1408
- constructor(...args) {
1409
- super();
1410
- constructGlobal(this, cstrName, args);
2097
+ set(value) {
2098
+ setInstanceStateValue(this, memberName, value);
2099
+ },
2100
+ })
2101
+ : 5 === memberType
2102
+ ? definePrototypeValue(
2103
+ Cstr,
2104
+ memberName,
2105
+ function (...args) {
2106
+ return callMethod(this, [memberName], args);
1411
2107
  }
1412
- } : win[cstrName] || class extends SuperCstr {}, cstrName);
1413
- nodeName && (nodeCstrs[nodeName] = Cstr);
1414
- members.map((([memberName, memberType, staticValue]) => {
1415
- memberName in Cstr.prototype || memberName in SuperCstr.prototype || ("string" == typeof memberType ? definePrototypeProperty(Cstr, memberName, {
2108
+ )
2109
+ : memberType > 0 &&
2110
+ (void 0 !== staticValue
2111
+ ? definePrototypeValue(Cstr, memberName, staticValue)
2112
+ : definePrototypeProperty(Cstr, memberName, {
1416
2113
  get() {
1417
- if (!hasInstanceStateValue(this, memberName)) {
1418
- const instanceId = this[InstanceIdKey];
1419
- const applyPath = [ ...this[ApplyPathKey], memberName ];
1420
- const PropCstr = win[memberType];
1421
- PropCstr && setInstanceStateValue(this, memberName, new PropCstr($winId$, instanceId, applyPath));
1422
- }
1423
- return getInstanceStateValue(this, memberName);
2114
+ return getter(this, [memberName]);
1424
2115
  },
1425
2116
  set(value) {
1426
- setInstanceStateValue(this, memberName, value);
1427
- }
1428
- }) : 5 === memberType ? definePrototypeValue(Cstr, memberName, (function(...args) {
1429
- return callMethod(this, [ memberName ], args);
1430
- })) : memberType > 0 && (void 0 !== staticValue ? definePrototypeValue(Cstr, memberName, staticValue) : definePrototypeProperty(Cstr, memberName, {
1431
- get() {
1432
- return getter(this, [ memberName ]);
2117
+ return setter(this, [memberName], value);
1433
2118
  },
1434
- set(value) {
1435
- return setter(this, [ memberName ], value);
1436
- }
1437
- })));
1438
- }));
1439
- }));
1440
- commaSplit("atob,btoa,crypto,indexedDB,setTimeout,setInterval,clearTimeout,clearInterval").map((globalName => {
1441
- delete WorkerWindow.prototype[globalName];
1442
- if (!(globalName in win)) {
1443
- value = self[globalName];
1444
- null != value && (win[globalName] = "function" != typeof value || value.toString().startsWith("class") ? value : value.bind(self));
1445
- }
1446
- }));
1447
- Object.getOwnPropertyNames(self).map((globalName => {
1448
- globalName in win || (win[globalName] = self[globalName]);
1449
- }));
1450
- windowMediaConstructors.map((cstrName => defineProperty(win, cstrName, {
1451
- get() {
1452
- initWindowMedia();
1453
- return win[cstrName];
1454
- }
1455
- })));
1456
- "trustedTypes" in self && (win.trustedTypes = self.trustedTypes);
1457
- patchElement(win.Element, win.HTMLElement);
1458
- patchDocument(win.Document, env, isDocumentImplementation);
1459
- (WorkerDocumentFragment => {
1460
- definePrototypeNodeType(WorkerDocumentFragment, 11);
1461
- cachedTreeProps(WorkerDocumentFragment, elementStructurePropNames);
1462
- })(win.DocumentFragment);
1463
- patchHTMLAnchorElement(win.HTMLAnchorElement, env);
1464
- (WorkerHTMLFormElement => {
1465
- definePrototypePropertyDescriptor(WorkerHTMLFormElement, {});
1466
- cachedProps(WorkerHTMLFormElement, "elements");
1467
- })(win.HTMLFormElement);
1468
- patchHTMLIFrameElement(win.HTMLIFrameElement);
1469
- patchHTMLScriptElement(win.HTMLScriptElement, env);
1470
- patchSvgElement(win.SVGGraphicsElement);
1471
- patchDocumentElementChild(win.HTMLHeadElement, env);
1472
- patchDocumentElementChild(win.HTMLBodyElement, env);
1473
- ((WorkerHTMLHtmlElement, env) => {
1474
- const DocumentElementDescriptorMap = {
1475
- parentElement: {
1476
- value: null
1477
- },
1478
- parentNode: {
1479
- get: () => env.$document$
1480
- }
1481
- };
1482
- definePrototypePropertyDescriptor(WorkerHTMLHtmlElement, DocumentElementDescriptorMap);
1483
- })(win.HTMLHtmlElement, env);
1484
- createCSSStyleSheetConstructor(win, "CSSStyleSheet");
1485
- definePrototypeNodeType(win.Comment, 8);
1486
- definePrototypeNodeType(win.DocumentType, 10);
1487
- Object.assign(env, {
1488
- $winId$: $winId$,
1489
- $parentWinId$: $parentWinId$,
1490
- $window$: new Proxy(win, {
1491
- get: (win, propName) => {
1492
- var _a;
1493
- if ("string" != typeof propName || isNaN(propName)) {
1494
- return (null === (_a = webWorkerCtx.$config$.mainWindowAccessors) || void 0 === _a ? void 0 : _a.includes(propName)) ? getter(this, [ propName ]) : win[propName];
1495
- }
1496
- {
1497
- let frame = getChildEnvs()[propName];
1498
- return frame ? frame.$window$ : void 0;
1499
- }
1500
- },
1501
- has: () => true
1502
- }),
1503
- $document$: $createNode$("#document", $winId$ + ".d"),
1504
- $documentElement$: $createNode$("HTML", $winId$ + ".e"),
1505
- $head$: $createNode$("HEAD", $winId$ + ".h"),
1506
- $body$: $createNode$("BODY", $winId$ + ".b"),
1507
- $location$: $location$,
1508
- $visibilityState$: $visibilityState$,
1509
- $isSameOrigin$: $isSameOrigin$,
1510
- $isTopWindow$: $isTopWindow$,
1511
- $createNode$: $createNode$
1512
- });
1513
- win.requestAnimationFrame = cb => setTimeout((() => cb(performance.now())), 9);
1514
- win.cancelAnimationFrame = id => clearTimeout(id);
1515
- win.requestIdleCallback = (cb, start) => {
1516
- start = Date.now();
1517
- return setTimeout((() => cb({
1518
- didTimeout: false,
1519
- timeRemaining: () => Math.max(0, 50 - (Date.now() - start))
1520
- })), 1);
1521
- };
1522
- win.cancelIdleCallback = id => clearTimeout(id);
1523
- addStorageApi(win, "localStorage", webWorkerlocalStorage, $isSameOrigin$, env);
1524
- addStorageApi(win, "sessionStorage", webWorkerSessionStorage, $isSameOrigin$, env);
1525
- $isSameOrigin$ || (win.indexeddb = void 0);
1526
- if (isIframeWindow) {
1527
- historyState = {};
1528
- win.history = {
1529
- pushState(stateObj) {
1530
- historyState = stateObj;
1531
- },
1532
- replaceState(stateObj) {
1533
- historyState = stateObj;
1534
- },
1535
- get state() {
1536
- return historyState;
1537
- },
1538
- length: 0
1539
- };
1540
- win.indexeddb = void 0;
1541
- } else {
1542
- const originalPushState = win.history.pushState.bind(win.history);
1543
- const originalReplaceState = win.history.replaceState.bind(win.history);
1544
- win.history.pushState = (stateObj, _, newUrl) => {
1545
- false !== env.$propagateHistoryChange$ && originalPushState(stateObj, _, newUrl);
1546
- };
1547
- win.history.replaceState = (stateObj, _, newUrl) => {
1548
- false !== env.$propagateHistoryChange$ && originalReplaceState(stateObj, _, newUrl);
1549
- };
2119
+ })));
2120
+ });
2121
+ }
2122
+ );
2123
+ commaSplit(
2124
+ "atob,btoa,crypto,indexedDB,setTimeout,setInterval,clearTimeout,clearInterval"
2125
+ ).map((globalName) => {
2126
+ delete WorkerWindow.prototype[globalName];
2127
+ if (!(globalName in win)) {
2128
+ value = self[globalName];
2129
+ null != value &&
2130
+ (win[globalName] =
2131
+ "function" != typeof value ||
2132
+ value.toString().startsWith("class")
2133
+ ? value
2134
+ : value.bind(self));
2135
+ }
2136
+ });
2137
+ Object.getOwnPropertyNames(self).map((globalName) => {
2138
+ globalName in win || (win[globalName] = self[globalName]);
2139
+ });
2140
+ windowMediaConstructors.map((cstrName) =>
2141
+ defineProperty(win, cstrName, {
2142
+ get() {
2143
+ initWindowMedia();
2144
+ return win[cstrName];
2145
+ },
2146
+ })
2147
+ );
2148
+ "trustedTypes" in self && (win.trustedTypes = self.trustedTypes);
2149
+ patchElement(win.Element, win.HTMLElement);
2150
+ patchDocument(win.Document, env, isDocumentImplementation);
2151
+ ((WorkerDocumentFragment) => {
2152
+ definePrototypeNodeType(WorkerDocumentFragment, 11);
2153
+ cachedTreeProps(WorkerDocumentFragment, elementStructurePropNames);
2154
+ })(win.DocumentFragment);
2155
+ patchHTMLAnchorElement(win.HTMLAnchorElement, env);
2156
+ ((WorkerHTMLFormElement) => {
2157
+ definePrototypePropertyDescriptor(WorkerHTMLFormElement, {});
2158
+ cachedProps(WorkerHTMLFormElement, "elements");
2159
+ })(win.HTMLFormElement);
2160
+ patchHTMLIFrameElement(win.HTMLIFrameElement);
2161
+ patchHTMLScriptElement(win.HTMLScriptElement, env);
2162
+ patchSvgElement(win.SVGGraphicsElement);
2163
+ patchDocumentElementChild(win.HTMLHeadElement, env);
2164
+ patchDocumentElementChild(win.HTMLBodyElement, env);
2165
+ ((WorkerHTMLHtmlElement, env) => {
2166
+ const DocumentElementDescriptorMap = {
2167
+ parentElement: {
2168
+ value: null,
2169
+ },
2170
+ parentNode: {
2171
+ get: () => env.$document$,
2172
+ },
2173
+ };
2174
+ definePrototypePropertyDescriptor(
2175
+ WorkerHTMLHtmlElement,
2176
+ DocumentElementDescriptorMap
2177
+ );
2178
+ })(win.HTMLHtmlElement, env);
2179
+ createCSSStyleSheetConstructor(win, "CSSStyleSheet");
2180
+ definePrototypeNodeType(win.Comment, 8);
2181
+ definePrototypeNodeType(win.DocumentType, 10);
2182
+ Object.assign(env, {
2183
+ $winId$: $winId$,
2184
+ $parentWinId$: $parentWinId$,
2185
+ $window$: new Proxy(win, {
2186
+ get: (win, propName) => {
2187
+ var _a;
2188
+ if ("string" != typeof propName || isNaN(propName)) {
2189
+ return (
2190
+ null === (_a = webWorkerCtx.$config$.mainWindowAccessors) ||
2191
+ void 0 === _a
2192
+ ? void 0
2193
+ : _a.includes(propName)
2194
+ )
2195
+ ? getter(this, [propName])
2196
+ : win[propName];
1550
2197
  }
1551
- win.Worker = void 0;
1552
- }
1553
- addEventListener(...args) {
1554
- "load" === args[0] ? env.$runWindowLoadEvent$ && setTimeout((() => args[1]({
1555
- type: "load"
1556
- }))) : callMethod(this, [ "addEventListener" ], args, 2);
1557
- }
1558
- get body() {
1559
- return env.$body$;
1560
- }
1561
- get document() {
1562
- return env.$document$;
1563
- }
1564
- get documentElement() {
1565
- return env.$documentElement$;
1566
- }
1567
- fetch(input, init) {
1568
- input = "string" == typeof input || input instanceof URL ? String(input) : input.url;
1569
- return fetch(resolveUrl(env, input, "fetch"), init);
1570
- }
1571
- get frames() {
1572
- return env.$window$;
1573
- }
1574
- get frameElement() {
1575
- return $isTopWindow$ ? null : getOrCreateNodeInstance($parentWinId$, $winId$, "IFRAME");
1576
- }
1577
- get globalThis() {
1578
- return env.$window$;
1579
- }
1580
- get head() {
1581
- return env.$head$;
1582
- }
1583
- get length() {
1584
- return getChildEnvs().length;
1585
- }
1586
- get location() {
1587
- return $location$;
1588
- }
1589
- set location(loc) {
1590
- $location$.href = loc + "";
1591
- }
1592
- get Image() {
1593
- return createImageConstructor(env);
1594
- }
1595
- get navigator() {
1596
- return (env => {
1597
- let key;
1598
- let nav = {
1599
- sendBeacon: (url, body) => {
1600
- if (webWorkerCtx.$config$.logSendBeaconRequests) {
1601
- try {
1602
- logWorker(`sendBeacon: ${resolveUrl(env, url, null)}${body ? ", data: " + JSON.stringify(body) : ""}`);
1603
- } catch (e) {
1604
- console.error(e);
1605
- }
1606
- }
1607
- try {
1608
- fetch(resolveUrl(env, url, null), {
1609
- method: "POST",
1610
- body: body,
1611
- mode: "no-cors",
1612
- keepalive: true
1613
- });
1614
- return true;
1615
- } catch (e) {
1616
- console.error(e);
1617
- return false;
1618
- }
1619
- }
1620
- };
1621
- for (key in navigator) {
1622
- nav[key] = navigator[key];
1623
- }
1624
- return nav;
1625
- })(env);
1626
- }
1627
- get origin() {
1628
- return $location$.origin;
1629
- }
1630
- set origin(_) {}
1631
- get parent() {
1632
- for (let envWinId in environments) {
1633
- if (environments[envWinId].$winId$ === $parentWinId$) {
1634
- return environments[envWinId].$window$;
1635
- }
2198
+ {
2199
+ let frame = getChildEnvs()[propName];
2200
+ return frame ? frame.$window$ : void 0;
1636
2201
  }
1637
- return env.$window$;
1638
- }
1639
- postMessage(...args) {
1640
- if (environments[args[0]]) {
1641
- len(postMessages) > 50 && postMessages.splice(0, 5);
1642
- postMessages.push({
1643
- $winId$: args[0],
1644
- $data$: JSON.stringify(args[1])
1645
- });
1646
- args = args.slice(1);
2202
+ },
2203
+ has: () => true,
2204
+ }),
2205
+ $document$: $createNode$("#document", $winId$ + ".d"),
2206
+ $documentElement$: $createNode$("HTML", $winId$ + ".e"),
2207
+ $head$: $createNode$("HEAD", $winId$ + ".h"),
2208
+ $body$: $createNode$("BODY", $winId$ + ".b"),
2209
+ $location$: $location$,
2210
+ $visibilityState$: $visibilityState$,
2211
+ $isSameOrigin$: $isSameOrigin$,
2212
+ $isTopWindow$: $isTopWindow$,
2213
+ $createNode$: $createNode$,
2214
+ });
2215
+ win.requestAnimationFrame = (cb) =>
2216
+ setTimeout(() => cb(performance.now()), 9);
2217
+ win.cancelAnimationFrame = (id) => clearTimeout(id);
2218
+ win.requestIdleCallback = (cb, start) => {
2219
+ start = Date.now();
2220
+ return setTimeout(
2221
+ () =>
2222
+ cb({
2223
+ didTimeout: false,
2224
+ timeRemaining: () => Math.max(0, 50 - (Date.now() - start)),
2225
+ }),
2226
+ 1
2227
+ );
2228
+ };
2229
+ win.cancelIdleCallback = (id) => clearTimeout(id);
2230
+ addStorageApi(
2231
+ win,
2232
+ "localStorage",
2233
+ webWorkerlocalStorage,
2234
+ $isSameOrigin$,
2235
+ env
2236
+ );
2237
+ addStorageApi(
2238
+ win,
2239
+ "sessionStorage",
2240
+ webWorkerSessionStorage,
2241
+ $isSameOrigin$,
2242
+ env
2243
+ );
2244
+ $isSameOrigin$ || (win.indexeddb = void 0);
2245
+ if (isIframeWindow) {
2246
+ historyState = {};
2247
+ win.history = {
2248
+ pushState(stateObj) {
2249
+ historyState = stateObj;
2250
+ },
2251
+ replaceState(stateObj) {
2252
+ historyState = stateObj;
2253
+ },
2254
+ get state() {
2255
+ return historyState;
2256
+ },
2257
+ length: 0,
2258
+ };
2259
+ win.indexeddb = void 0;
2260
+ } else {
2261
+ const originalPushState = win.history.pushState.bind(win.history);
2262
+ const originalReplaceState = win.history.replaceState.bind(
2263
+ win.history
2264
+ );
2265
+ win.history.pushState = (stateObj, _, newUrl) => {
2266
+ false !== env.$propagateHistoryChange$ &&
2267
+ originalPushState(stateObj, _, newUrl);
2268
+ };
2269
+ win.history.replaceState = (stateObj, _, newUrl) => {
2270
+ false !== env.$propagateHistoryChange$ &&
2271
+ originalReplaceState(stateObj, _, newUrl);
2272
+ };
2273
+ }
2274
+ win.Worker = void 0;
2275
+ }
2276
+ addEventListener(...args) {
2277
+ "load" === args[0]
2278
+ ? env.$runWindowLoadEvent$ &&
2279
+ setTimeout(() =>
2280
+ args[1]({
2281
+ type: "load",
2282
+ })
2283
+ )
2284
+ : callMethod(this, ["addEventListener"], args, 2);
2285
+ }
2286
+ get body() {
2287
+ return env.$body$;
2288
+ }
2289
+ get document() {
2290
+ return env.$document$;
2291
+ }
2292
+ get documentElement() {
2293
+ return env.$documentElement$;
2294
+ }
2295
+ fetch(input, init) {
2296
+ input =
2297
+ "string" == typeof input || input instanceof URL
2298
+ ? String(input)
2299
+ : input.url;
2300
+ return fetch(resolveUrl(env, input, "fetch"), init);
2301
+ }
2302
+ get frames() {
2303
+ return env.$window$;
2304
+ }
2305
+ get frameElement() {
2306
+ return $isTopWindow$
2307
+ ? null
2308
+ : getOrCreateNodeInstance($parentWinId$, $winId$, "INPUT");
2309
+ }
2310
+ get globalThis() {
2311
+ return env.$window$;
2312
+ }
2313
+ get head() {
2314
+ return env.$head$;
2315
+ }
2316
+ get length() {
2317
+ return getChildEnvs().length;
2318
+ }
2319
+ get location() {
2320
+ return $location$;
2321
+ }
2322
+ set location(loc) {
2323
+ $location$.href = loc + "";
2324
+ }
2325
+ get Image() {
2326
+ return createImageConstructor(env);
2327
+ }
2328
+ get navigator() {
2329
+ return ((env) => {
2330
+ let key;
2331
+ let nav = {
2332
+ sendBeacon: (url, body) => {
2333
+ if (webWorkerCtx.$config$.logSendBeaconRequests) {
2334
+ try {
2335
+ logWorker(
2336
+ `sendBeacon: ${resolveUrl(env, url, null)}${
2337
+ body ? ", data: " + JSON.stringify(body) : ""
2338
+ }`
2339
+ );
2340
+ } catch (e) {
2341
+ console.error(e);
2342
+ }
1647
2343
  }
1648
- callMethod(this, [ "postMessage" ], args, 3);
1649
- }
1650
- get self() {
1651
- return env.$window$;
1652
- }
1653
- get top() {
1654
- for (let envWinId in environments) {
1655
- if (environments[envWinId].$isTopWindow$) {
1656
- return environments[envWinId].$window$;
1657
- }
2344
+ try {
2345
+ fetch(resolveUrl(env, url, null), {
2346
+ method: "POST",
2347
+ body: body,
2348
+ mode: "no-cors",
2349
+ keepalive: true,
2350
+ });
2351
+ return true;
2352
+ } catch (e) {
2353
+ console.error(e);
2354
+ return false;
1658
2355
  }
1659
- return env.$window$;
1660
- }
1661
- get window() {
1662
- return env.$window$;
1663
- }
1664
- get XMLHttpRequest() {
1665
- const Xhr = XMLHttpRequest;
1666
- const str = String(Xhr);
1667
- const ExtendedXhr = defineConstructorName(class extends Xhr {
1668
- open(...args) {
1669
- args[1] = resolveUrl(env, args[1], "xhr");
1670
- super.open(...args);
1671
- }
1672
- set withCredentials(_) {}
1673
- toString() {
1674
- return str;
1675
- }
1676
- }, getConstructorName(Xhr));
1677
- ExtendedXhr.prototype.constructor.toString = () => str;
1678
- return ExtendedXhr;
1679
- }
1680
- }, "Window");
1681
- const WorkerTrapProxy = class extends WorkerBase {
1682
- constructor(winId, instanceId, applyPath, nodeName) {
1683
- super(winId, instanceId, applyPath, nodeName);
1684
- return new Proxy(this, {
1685
- get: (instance, propName) => getter(instance, [ propName ]),
1686
- set(instance, propName, propValue) {
1687
- setter(instance, [ propName ], propValue);
1688
- return true;
1689
- }
1690
- });
2356
+ },
2357
+ };
2358
+ for (key in navigator) {
2359
+ nav[key] = navigator[key];
1691
2360
  }
1692
- };
1693
- const WorkerEventTargetProxy = class extends WorkerBase {};
1694
- eventTargetMethods.map((methodName => WorkerEventTargetProxy.prototype[methodName] = function(...args) {
1695
- return callMethod(this, [ methodName ], args, 2);
1696
- }));
1697
- cachedProps(WorkerWindow, "devicePixelRatio");
1698
- cachedDimensionProps(WorkerWindow);
1699
- cachedDimensionMethods(WorkerWindow, [ "getComputedStyle" ]);
1700
- new WorkerWindow;
1701
- return env;
1702
- };
1703
- const TrapConstructors = {
1704
- DOMStringMap: 1,
1705
- NamedNodeMap: 1
1706
- };
1707
- const createEnvironment = ({$winId$: $winId$, $parentWinId$: $parentWinId$, $url$: $url$, $visibilityState$: $visibilityState$}, isIframeWindow, isDocumentImplementation) => {
1708
- if (!environments[$winId$]) {
1709
- environments[$winId$] = createWindow($winId$, $parentWinId$, $url$, $visibilityState$, isIframeWindow, isDocumentImplementation);
1710
- {
1711
- const winType = $winId$ === $parentWinId$ ? "top" : "iframe";
1712
- logWorker(`Created ${winType} window ${normalizedWinId($winId$)} environment`, $winId$);
2361
+ return nav;
2362
+ })(env);
2363
+ }
2364
+ get origin() {
2365
+ return $location$.origin;
2366
+ }
2367
+ set origin(_) {}
2368
+ get parent() {
2369
+ for (let envWinId in environments) {
2370
+ if (environments[envWinId].$winId$ === $parentWinId$) {
2371
+ return environments[envWinId].$window$;
2372
+ }
2373
+ }
2374
+ return env.$window$;
2375
+ }
2376
+ postMessage(...args) {
2377
+ if (environments[args[0]]) {
2378
+ len(postMessages) > 50 && postMessages.splice(0, 5);
2379
+ postMessages.push({
2380
+ $winId$: args[0],
2381
+ $data$: JSON.stringify(args[1]),
2382
+ });
2383
+ args = args.slice(1);
2384
+ }
2385
+ callMethod(this, ["postMessage"], args, 3);
2386
+ }
2387
+ get self() {
2388
+ return env.$window$;
2389
+ }
2390
+ get top() {
2391
+ for (let envWinId in environments) {
2392
+ if (environments[envWinId].$isTopWindow$) {
2393
+ return environments[envWinId].$window$;
1713
2394
  }
2395
+ }
2396
+ return env.$window$;
2397
+ }
2398
+ get window() {
2399
+ return env.$window$;
2400
+ }
2401
+ get XMLHttpRequest() {
2402
+ const Xhr = XMLHttpRequest;
2403
+ const str = String(Xhr);
2404
+ const ExtendedXhr = defineConstructorName(
2405
+ class extends Xhr {
2406
+ open(...args) {
2407
+ args[1] = resolveUrl(env, args[1], "xhr");
2408
+ super.open(...args);
2409
+ }
2410
+ set withCredentials(_) {}
2411
+ toString() {
2412
+ return str;
2413
+ }
2414
+ },
2415
+ getConstructorName(Xhr)
2416
+ );
2417
+ ExtendedXhr.prototype.constructor.toString = () => str;
2418
+ return ExtendedXhr;
1714
2419
  }
1715
- webWorkerCtx.$postMessage$([ 7, $winId$ ]);
1716
- return environments[$winId$];
2420
+ },
2421
+ "Window"
2422
+ );
2423
+ const WorkerTrapProxy = class extends WorkerBase {
2424
+ constructor(winId, instanceId, applyPath, nodeName) {
2425
+ super(winId, instanceId, applyPath, nodeName);
2426
+ return new Proxy(this, {
2427
+ get: (instance, propName) => getter(instance, [propName]),
2428
+ set(instance, propName, propValue) {
2429
+ setter(instance, [propName], propValue);
2430
+ return true;
2431
+ },
2432
+ });
2433
+ }
1717
2434
  };
1718
- const queuedEvents = [];
1719
- const receiveMessageFromSandboxToWorker = ev => {
1720
- const msg = ev.data;
1721
- const msgType = msg[0];
1722
- const msgValue = msg[1];
1723
- if (webWorkerCtx.$isInitialized$) {
1724
- if (7 === msgType) {
1725
- (async initScript => {
1726
- let winId = initScript.$winId$;
1727
- let instanceId = initScript.$instanceId$;
1728
- let instance = getOrCreateNodeInstance(winId, instanceId, "SCRIPT");
1729
- let scriptContent = initScript.$content$;
1730
- let scriptSrc = initScript.$url$;
1731
- let scriptOrgSrc = initScript.$orgUrl$;
1732
- let errorMsg = "";
1733
- let env = environments[winId];
1734
- let rsp;
1735
- let javascriptContentTypes = [ "text/jscript", "text/javascript", "text/x-javascript", "application/javascript", "application/x-javascript", "text/ecmascript", "text/x-ecmascript", "application/ecmascript" ];
1736
- if (scriptSrc) {
1737
- try {
1738
- scriptSrc = resolveToUrl(env, scriptSrc, "script") + "";
1739
- setInstanceStateValue(instance, 4, scriptSrc);
1740
- webWorkerCtx.$config$.logScriptExecution && logWorker(`Execute script src: ${scriptOrgSrc}`, winId);
1741
- rsp = await fetch(scriptSrc);
1742
- if (rsp.ok) {
1743
- let responseContentType = rsp.headers.get("content-type");
1744
- let shouldExecute = javascriptContentTypes.some((ct => {
1745
- var _a, _b, _c;
1746
- return null === (_c = null === (_a = null == responseContentType ? void 0 : responseContentType.toLowerCase) || void 0 === _a ? void 0 : (_b = _a.call(responseContentType)).includes) || void 0 === _c ? void 0 : _c.call(_b, ct);
1747
- }));
1748
- if (shouldExecute) {
1749
- scriptContent = await rsp.text();
1750
- env.$currentScriptId$ = instanceId;
1751
- run(env, scriptContent, scriptOrgSrc || scriptSrc);
1752
- }
1753
- runStateLoadHandlers(instance, "load");
1754
- } else {
1755
- errorMsg = rsp.statusText;
1756
- runStateLoadHandlers(instance, "error");
1757
- }
1758
- } catch (urlError) {
1759
- console.error(urlError);
1760
- errorMsg = String(urlError.stack || urlError);
1761
- runStateLoadHandlers(instance, "error");
1762
- }
1763
- } else {
1764
- scriptContent && (errorMsg = runScriptContent(env, instanceId, scriptContent, winId, errorMsg));
1765
- }
1766
- env.$currentScriptId$ = "";
1767
- webWorkerCtx.$postMessage$([ 6, winId, instanceId, errorMsg ]);
1768
- })(msgValue);
1769
- } else if (9 === msgType) {
1770
- (({$winId$: $winId$, $instanceId$: $instanceId$, $refId$: $refId$, $thisArg$: $thisArg$, $args$: $args$}) => {
1771
- if (webWorkerRefsByRefId[$refId$]) {
1772
- try {
1773
- webWorkerRefsByRefId[$refId$].apply(deserializeFromMain($winId$, $instanceId$, [], $thisArg$), deserializeFromMain($winId$, $instanceId$, [], $args$));
1774
- } catch (e) {
1775
- console.error(e);
1776
- }
1777
- }
1778
- })(msgValue);
1779
- } else if (10 === msgType) {
1780
- (({$winId$: $winId$, $forward$: $forward$, $args$: $args$}) => {
1781
- try {
1782
- let target = environments[$winId$].$window$;
1783
- let i = 0;
1784
- let l = len($forward$);
1785
- for (;i < l; i++) {
1786
- i + 1 < l ? target = target[$forward$[i]] : target[$forward$[i]].apply(target, deserializeFromMain(null, $winId$, [], $args$));
1787
- }
1788
- } catch (e) {
1789
- console.error(e);
1790
- }
1791
- })(msgValue);
1792
- } else if (5 === msgType) {
1793
- createEnvironment(msgValue);
1794
- } else if (8 === msgType) {
1795
- if (1 !== environments[msgValue].$isInitialized$) {
1796
- const winId = msgValue;
1797
- const env = environments[winId];
1798
- const winType = env.$winId$ === env.$parentWinId$ ? "top" : "iframe";
1799
- logWorker(`Initialized ${winType} window ${normalizedWinId(winId)} environment 🎉`, winId);
2435
+ const WorkerEventTargetProxy = class extends WorkerBase {};
2436
+ eventTargetMethods.map(
2437
+ (methodName) =>
2438
+ (WorkerEventTargetProxy.prototype[methodName] = function (...args) {
2439
+ return callMethod(this, [methodName], args, 2);
2440
+ })
2441
+ );
2442
+ cachedProps(WorkerWindow, "devicePixelRatio");
2443
+ cachedDimensionProps(WorkerWindow);
2444
+ cachedDimensionMethods(WorkerWindow, ["getComputedStyle"]);
2445
+ new WorkerWindow();
2446
+ return env;
2447
+ };
2448
+ const TrapConstructors = {
2449
+ DOMStringMap: 1,
2450
+ NamedNodeMap: 1,
2451
+ };
2452
+ const createEnvironment = (
2453
+ {
2454
+ $winId$: $winId$,
2455
+ $parentWinId$: $parentWinId$,
2456
+ $url$: $url$,
2457
+ $visibilityState$: $visibilityState$,
2458
+ },
2459
+ isIframeWindow,
2460
+ isDocumentImplementation
2461
+ ) => {
2462
+ if (!environments[$winId$]) {
2463
+ environments[$winId$] = createWindow(
2464
+ $winId$,
2465
+ $parentWinId$,
2466
+ $url$,
2467
+ $visibilityState$,
2468
+ isIframeWindow,
2469
+ isDocumentImplementation
2470
+ );
2471
+ {
2472
+ const winType = $winId$ === $parentWinId$ ? "top" : "input";
2473
+ logWorker(
2474
+ `Created ${winType} window ${normalizedWinId($winId$)} environment`,
2475
+ $winId$
2476
+ );
2477
+ }
2478
+ }
2479
+ webWorkerCtx.$postMessage$([7, $winId$]);
2480
+ return environments[$winId$];
2481
+ };
2482
+ const queuedEvents = [];
2483
+ const receiveMessageFromSandboxToWorker = (ev) => {
2484
+ const msg = ev.data;
2485
+ const msgType = msg[0];
2486
+ const msgValue = msg[1];
2487
+ if (webWorkerCtx.$isInitialized$) {
2488
+ if (7 === msgType) {
2489
+ (async (initScript) => {
2490
+ let winId = initScript.$winId$;
2491
+ let instanceId = initScript.$instanceId$;
2492
+ let instance = getOrCreateNodeInstance(winId, instanceId, "SCRIPT");
2493
+ let scriptContent = initScript.$content$;
2494
+ let scriptSrc = initScript.$url$;
2495
+ let scriptOrgSrc = initScript.$orgUrl$;
2496
+ let errorMsg = "";
2497
+ let env = environments[winId];
2498
+ let rsp;
2499
+ let javascriptContentTypes = [
2500
+ "text/jscript",
2501
+ "text/javascript",
2502
+ "text/x-javascript",
2503
+ "application/javascript",
2504
+ "application/x-javascript",
2505
+ "text/ecmascript",
2506
+ "text/x-ecmascript",
2507
+ "application/ecmascript",
2508
+ ];
2509
+ if (scriptSrc) {
2510
+ try {
2511
+ scriptSrc = resolveToUrl(env, scriptSrc, "script") + "";
2512
+ setInstanceStateValue(instance, 4, scriptSrc);
2513
+ webWorkerCtx.$config$.logScriptExecution &&
2514
+ logWorker(`Execute script src: ${scriptOrgSrc}`, winId);
2515
+ rsp = await fetch(scriptSrc);
2516
+ if (rsp.ok) {
2517
+ let responseContentType = rsp.headers.get("content-type");
2518
+ let shouldExecute = javascriptContentTypes.some((ct) => {
2519
+ var _a, _b, _c;
2520
+ return null ===
2521
+ (_c =
2522
+ null ===
2523
+ (_a =
2524
+ null == responseContentType
2525
+ ? void 0
2526
+ : responseContentType.toLowerCase) || void 0 === _a
2527
+ ? void 0
2528
+ : (_b = _a.call(responseContentType)).includes) ||
2529
+ void 0 === _c
2530
+ ? void 0
2531
+ : _c.call(_b, ct);
2532
+ });
2533
+ if (shouldExecute) {
2534
+ scriptContent = await rsp.text();
2535
+ env.$currentScriptId$ = instanceId;
2536
+ run(env, scriptContent, scriptOrgSrc || scriptSrc);
1800
2537
  }
1801
- environments[msgValue].$isInitialized$ = 1;
1802
- environments[msgValue].$isLoading$ = 0;
1803
- } else if (14 === msgType) {
1804
- environments[msgValue].$visibilityState$ = msg[2];
1805
- } else if (13 === msgType) {
1806
- const $winId$ = msgValue.$winId$;
1807
- const env = environments[$winId$];
1808
- env.$location$.href = msgValue.url;
1809
- !function($winId$, env, data) {
1810
- const history = env.$window$.history;
1811
- switch (data.type) {
1812
- case 0:
1813
- env.$propagateHistoryChange$ = false;
1814
- try {
1815
- history.pushState(data.state, "", data.newUrl);
1816
- } catch (e) {}
1817
- env.$propagateHistoryChange$ = true;
1818
- break;
1819
-
1820
- case 1:
1821
- env.$propagateHistoryChange$ = false;
1822
- try {
1823
- history.replaceState(data.state, "", data.newUrl);
1824
- } catch (e) {}
1825
- env.$propagateHistoryChange$ = true;
1826
- }
1827
- }(msgValue.$winId$, env, msgValue);
1828
- } else {
1829
- 15 === msgType && ((_type, winId, instanceId, callbackName, args) => {
1830
- const elm = getOrCreateNodeInstance(winId, instanceId);
1831
- elm && "function" == typeof elm[callbackName] && elm[callbackName].apply(elm, args);
1832
- })(...msg);
1833
- }
1834
- } else if (1 === msgType) {
1835
- (initWebWorkerData => {
1836
- const config = webWorkerCtx.$config$ = JSON.parse(initWebWorkerData.$config$);
1837
- const locOrigin = initWebWorkerData.$origin$;
1838
- webWorkerCtx.$importScripts$ = importScripts.bind(self);
1839
- webWorkerCtx.$interfaces$ = initWebWorkerData.$interfaces$;
1840
- webWorkerCtx.$libPath$ = initWebWorkerData.$libPath$;
1841
- webWorkerCtx.$origin$ = locOrigin;
1842
- webWorkerCtx.$postMessage$ = postMessage.bind(self);
1843
- webWorkerCtx.$sharedDataBuffer$ = initWebWorkerData.$sharedDataBuffer$;
1844
- webWorkerlocalStorage.set(locOrigin, initWebWorkerData.$localStorage$);
1845
- webWorkerSessionStorage.set(locOrigin, initWebWorkerData.$sessionStorage$);
1846
- self.importScripts = void 0;
1847
- delete self.postMessage;
1848
- delete self.WorkerGlobalScope;
1849
- commaSplit("resolveUrl,get,set,apply").map((configName => {
1850
- config[configName] && (config[configName] = new Function("return " + config[configName])());
1851
- }));
1852
- })(msgValue);
1853
- webWorkerCtx.$postMessage$([ 2 ]);
1854
- } else if (3 === msgType) {
1855
- webWorkerCtx.$interfaces$ = [ ...webWorkerCtx.$interfaces$, ...msgValue ];
1856
- webWorkerCtx.$isInitialized$ = 1;
1857
- logWorker("Initialized web worker");
1858
- webWorkerCtx.$postMessage$([ 4 ]);
1859
- queuedEvents.length && logWorker(`Queued ready messages: ${queuedEvents.length}`);
1860
- [ ...queuedEvents ].map(receiveMessageFromSandboxToWorker);
1861
- queuedEvents.length = 0;
1862
- } else {
1863
- queuedEvents.push(ev);
2538
+ runStateLoadHandlers(instance, "load");
2539
+ } else {
2540
+ errorMsg = rsp.statusText;
2541
+ runStateLoadHandlers(instance, "error");
2542
+ }
2543
+ } catch (urlError) {
2544
+ console.error(urlError);
2545
+ errorMsg = String(urlError.stack || urlError);
2546
+ runStateLoadHandlers(instance, "error");
2547
+ }
2548
+ } else {
2549
+ scriptContent &&
2550
+ (errorMsg = runScriptContent(
2551
+ env,
2552
+ instanceId,
2553
+ scriptContent,
2554
+ winId,
2555
+ errorMsg
2556
+ ));
2557
+ }
2558
+ env.$currentScriptId$ = "";
2559
+ webWorkerCtx.$postMessage$([6, winId, instanceId, errorMsg]);
2560
+ })(msgValue);
2561
+ } else if (9 === msgType) {
2562
+ (({
2563
+ $winId$: $winId$,
2564
+ $instanceId$: $instanceId$,
2565
+ $refId$: $refId$,
2566
+ $thisArg$: $thisArg$,
2567
+ $args$: $args$,
2568
+ }) => {
2569
+ if (webWorkerRefsByRefId[$refId$]) {
2570
+ try {
2571
+ webWorkerRefsByRefId[$refId$].apply(
2572
+ deserializeFromMain($winId$, $instanceId$, [], $thisArg$),
2573
+ deserializeFromMain($winId$, $instanceId$, [], $args$)
2574
+ );
2575
+ } catch (e) {
2576
+ console.error(e);
2577
+ }
2578
+ }
2579
+ })(msgValue);
2580
+ } else if (10 === msgType) {
2581
+ (({ $winId$: $winId$, $forward$: $forward$, $args$: $args$ }) => {
2582
+ try {
2583
+ let target = environments[$winId$].$window$;
2584
+ let i = 0;
2585
+ let l = len($forward$);
2586
+ for (; i < l; i++) {
2587
+ i + 1 < l
2588
+ ? (target = target[$forward$[i]])
2589
+ : target[$forward$[i]].apply(
2590
+ target,
2591
+ deserializeFromMain(null, $winId$, [], $args$)
2592
+ );
2593
+ }
2594
+ } catch (e) {
2595
+ console.error(e);
2596
+ }
2597
+ })(msgValue);
2598
+ } else if (5 === msgType) {
2599
+ createEnvironment(msgValue);
2600
+ } else if (8 === msgType) {
2601
+ if (1 !== environments[msgValue].$isInitialized$) {
2602
+ const winId = msgValue;
2603
+ const env = environments[winId];
2604
+ const winType = env.$winId$ === env.$parentWinId$ ? "top" : "iframe";
2605
+ logWorker(
2606
+ `Initialized ${winType} window ${normalizedWinId(
2607
+ winId
2608
+ )} environment 🎉`,
2609
+ winId
2610
+ );
1864
2611
  }
1865
- };
1866
- self.onmessage = receiveMessageFromSandboxToWorker;
1867
- postMessage([ 0 ]);
2612
+ environments[msgValue].$isInitialized$ = 1;
2613
+ environments[msgValue].$isLoading$ = 0;
2614
+ } else if (14 === msgType) {
2615
+ environments[msgValue].$visibilityState$ = msg[2];
2616
+ } else if (13 === msgType) {
2617
+ const $winId$ = msgValue.$winId$;
2618
+ const env = environments[$winId$];
2619
+ env.$location$.href = msgValue.url;
2620
+ !(function ($winId$, env, data) {
2621
+ const history = env.$window$.history;
2622
+ switch (data.type) {
2623
+ case 0:
2624
+ env.$propagateHistoryChange$ = false;
2625
+ try {
2626
+ history.pushState(data.state, "", data.newUrl);
2627
+ } catch (e) {}
2628
+ env.$propagateHistoryChange$ = true;
2629
+ break;
2630
+
2631
+ case 1:
2632
+ env.$propagateHistoryChange$ = false;
2633
+ try {
2634
+ history.replaceState(data.state, "", data.newUrl);
2635
+ } catch (e) {}
2636
+ env.$propagateHistoryChange$ = true;
2637
+ }
2638
+ })(msgValue.$winId$, env, msgValue);
2639
+ } else {
2640
+ 15 === msgType &&
2641
+ ((_type, winId, instanceId, callbackName, args) => {
2642
+ const elm = getOrCreateNodeInstance(winId, instanceId);
2643
+ elm &&
2644
+ "function" == typeof elm[callbackName] &&
2645
+ elm[callbackName].apply(elm, args);
2646
+ })(...msg);
2647
+ }
2648
+ } else if (1 === msgType) {
2649
+ ((initWebWorkerData) => {
2650
+ const config = (webWorkerCtx.$config$ = JSON.parse(
2651
+ initWebWorkerData.$config$
2652
+ ));
2653
+ const locOrigin = initWebWorkerData.$origin$;
2654
+ webWorkerCtx.$importScripts$ = importScripts.bind(self);
2655
+ webWorkerCtx.$interfaces$ = initWebWorkerData.$interfaces$;
2656
+ webWorkerCtx.$libPath$ = initWebWorkerData.$libPath$;
2657
+ webWorkerCtx.$origin$ = locOrigin;
2658
+ webWorkerCtx.$postMessage$ = postMessage.bind(self);
2659
+ webWorkerCtx.$sharedDataBuffer$ = initWebWorkerData.$sharedDataBuffer$;
2660
+ webWorkerlocalStorage.set(locOrigin, initWebWorkerData.$localStorage$);
2661
+ webWorkerSessionStorage.set(
2662
+ locOrigin,
2663
+ initWebWorkerData.$sessionStorage$
2664
+ );
2665
+ self.importScripts = void 0;
2666
+ delete self.postMessage;
2667
+ delete self.WorkerGlobalScope;
2668
+ commaSplit("resolveUrl,get,set,apply").map((configName) => {
2669
+ config[configName] &&
2670
+ (config[configName] = new Function(
2671
+ "return " + config[configName]
2672
+ )());
2673
+ });
2674
+ })(msgValue);
2675
+ webWorkerCtx.$postMessage$([2]);
2676
+ } else if (3 === msgType) {
2677
+ webWorkerCtx.$interfaces$ = [...webWorkerCtx.$interfaces$, ...msgValue];
2678
+ webWorkerCtx.$isInitialized$ = 1;
2679
+ logWorker("Initialized web worker");
2680
+ webWorkerCtx.$postMessage$([4]);
2681
+ queuedEvents.length &&
2682
+ logWorker(`Queued ready messages: ${queuedEvents.length}`);
2683
+ [...queuedEvents].map(receiveMessageFromSandboxToWorker);
2684
+ queuedEvents.length = 0;
2685
+ } else {
2686
+ queuedEvents.push(ev);
2687
+ }
2688
+ };
2689
+ self.onmessage = receiveMessageFromSandboxToWorker;
2690
+ postMessage([0]);
1868
2691
  })(self);