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