titaniumnet-mirror/ultraviolet
1
0
Fork 0
mirror of https://github.com/titaniumnetwork-dev/Ultraviolet.git synced 2025-05-14 04:20:00 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

prettier

Browse source
This commit is contained in:
David Reed 2022-11-18 20:00:58 -05:00
parent d230e0e551
commit 8f999e7236
No known key found for this signature in database
GPG key ID: 2211691D8A1EE72F
42 changed files with 10481 additions and 8966 deletions
Download patch file Download diff file Expand all files Collapse all files

90
.github/ISSUE_TEMPLATE/bug_report.md vendored
View file

@ -1,42 +1,48 @@
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
Issue tracker is **ONLY** used for reporting bugs. New features should be discussed on our Discord server.
<!--- Provide a general summary of the issue in the Title above -->
## Expected Behavior
<!--- Tell us what should happen -->
## Current Behavior
<!--- Tell us what happens instead of the expected behavior -->
## Possible Solution
<!--- Not obligatory, but suggest a fix/reason for the bug, -->
## Steps to Reproduce
<!--- Provide a link to a live example, or an unambiguous set of steps to -->
<!--- reproduce this bug. Include code to reproduce, if relevant -->
1.
2.
3.
4.
## Context (Environment)
<!--- How has this issue affected you? What are you trying to accomplish? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->
<!--- Provide a general summary of the issue in the Title above -->
## Detailed Description
<!--- Provide a detailed description of the change or addition you are proposing -->
## Possible Implementation
<!--- Not obligatory, but suggest an idea for implementing addition or change -->
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: ''
assignees: ''
---
Issue tracker is **ONLY** used for reporting bugs. New features should be discussed on our Discord server.
<!--- Provide a general summary of the issue in the Title above -->
## Expected Behavior
<!--- Tell us what should happen -->
## Current Behavior
<!--- Tell us what happens instead of the expected behavior -->
## Possible Solution
<!--- Not obligatory, but suggest a fix/reason for the bug, -->
## Steps to Reproduce
<!--- Provide a link to a live example, or an unambiguous set of steps to -->
<!--- reproduce this bug. Include code to reproduce, if relevant -->
1.
2.
3.
4.
## Context (Environment)
<!--- How has this issue affected you? What are you trying to accomplish? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->
<!--- Provide a general summary of the issue in the Title above -->
## Detailed Description
<!--- Provide a detailed description of the change or addition you are proposing -->
## Possible Implementation
<!--- Not obligatory, but suggest an idea for implementing addition or change -->

16
.github/ISSUE_TEMPLATE/config.yml vendored
View file

@ -1,8 +1,8 @@
blank_issues_enabled: false
contact_links:
- name: Community Support
url: https://discord.gg/unblock
about: Please ask and answer questions here.
- name: Heroku, Repl.it, Blocked site issues
url: https://www.youtube.com/watch?v=BLUkgRAy_Vo
about: Do not create issues for these.
blank_issues_enabled: false
contact_links:
- name: Community Support
url: https://discord.gg/unblock
about: Please ask and answer questions here.
- name: Heroku, Repl.it, Blocked site issues
url: https://www.youtube.com/watch?v=BLUkgRAy_Vo
about: Do not create issues for these.

4
.prettierrc Normal file
View file

@ -0,0 +1,4 @@
{
"tabWidth": 4,
"singleQuote": true
}

9280
package-lock.json generated
View file

File diff suppressed because it is too large Load diff

69
package.json
View file

@ -1,36 +1,37 @@
{
"name": "@titaniumnetwork-dev/ultraviolet",
"version": "1.0.3",
"description": "Proxy",
"main": "lib/index.cjs",
"scripts": {
"build": "cross-env NODE_ENV=production webpack-cli",
"build:dev": "cross-env NODE_ENV=development webpack-cli",
"build:watch": "cross-env NODE_ENV=development webpack-cli --watch"
},
"author": "",
"license": "MIT",
"type": "module",
"dependencies": {
"bowser": "^2.11.0",
"css-tree": "^2.0.4",
"esotope-hammerhead": "^0.6.1",
"idb": "^7.0.0",
"meriyah": "^4.2.0",
"mime-db": "^1.51.0",
"parse5": "^6.0.1",
"set-cookie-parser": "^2.4.8"
},
"devDependencies": {
"copy-webpack-plugin": "^11.0.0",
"cross-env": "^7.0.3",
"eslint": "^8.8.0",
"terser-webpack-plugin": "^5.3.6",
"webpack": "^5.74.0",
"webpack-cli": "^4.10.0"
},
"files": [
"dist",
"lib"
]
"name": "@titaniumnetwork-dev/ultraviolet",
"version": "1.0.3",
"description": "Proxy",
"main": "lib/index.cjs",
"scripts": {
"build": "cross-env NODE_ENV=production webpack-cli",
"build:dev": "cross-env NODE_ENV=development webpack-cli",
"build:watch": "cross-env NODE_ENV=development webpack-cli --watch"
},
"author": "",
"license": "MIT",
"type": "module",
"dependencies": {
"bowser": "^2.11.0",
"css-tree": "^2.0.4",
"esotope-hammerhead": "^0.6.1",
"idb": "^7.0.0",
"meriyah": "^4.2.0",
"mime-db": "^1.51.0",
"parse5": "^6.0.1",
"set-cookie-parser": "^2.4.8"
},
"devDependencies": {
"copy-webpack-plugin": "^11.0.0",
"cross-env": "^7.0.3",
"eslint": "^8.8.0",
"prettier": "^2.7.1",
"terser-webpack-plugin": "^5.3.6",
"webpack": "^5.74.0",
"webpack-cli": "^4.10.0"
},
"files": [
"dist",
"lib"
]
}

193
src/client/dom/attr.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class AttrApi extends EventEmitter {
constructor(ctx) {
@ -8,8 +8,14 @@ class AttrApi extends EventEmitter {
this.window = ctx.window;
this.Attr = this.window.Attr || {};
this.attrProto = this.Attr.prototype || {};
this.value = ctx.nativeMethods.getOwnPropertyDescriptor(this.attrProto, 'value');
this.name = ctx.nativeMethods.getOwnPropertyDescriptor(this.attrProto, 'name');
this.value = ctx.nativeMethods.getOwnPropertyDescriptor(
this.attrProto,
'value'
);
this.name = ctx.nativeMethods.getOwnPropertyDescriptor(
this.attrProto,
'name'
);
this.getNamedItem = this.attrProto.getNamedItem || null;
this.setNamedItem = this.attrProto.setNamedItem || null;
this.removeNamedItem = this.attrProto.removeNamedItem || null;
@ -17,69 +23,100 @@ class AttrApi extends EventEmitter {
this.setNamedItemNS = this.attrProto.setNamedItemNS || null;
this.removeNamedItemNS = this.attrProto.removeNamedItemNS || null;
this.item = this.attrProto.item || null;
};
}
overrideNameValue() {
this.ctx.overrideDescriptor(this.attrProto, 'name', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('name', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
});
this.ctx.overrideDescriptor(this.attrProto, 'value', {
get: (target, that) => {
const event = new HookEvent({ name: this.name.get.call(that), value: target.call(that) }, target, that);
const event = new HookEvent(
{
name: this.name.get.call(that),
value: target.call(that),
},
target,
that
);
this.emit('getValue', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ val ]) => {
const event = new HookEvent({ name: this.name.get.call(that), value: val }, target, that);
set: (target, that, [val]) => {
const event = new HookEvent(
{ name: this.name.get.call(that), value: val },
target,
that
);
this.emit('setValue', event);
if (event.intercepted) return event.returnValue;
event.target.call(event.that, event.data.value);
}
},
});
};
}
overrideItemMethods() {
this.ctx.override(this.attrProto, 'getNamedItem', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
this.ctx.override(
this.attrProto,
'getNamedItem',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [name] = args;
const event = new HookEvent({ name }, target, that);
this.emit('getNamedItem', event);
const event = new HookEvent({ name }, target, that);
this.emit('getNamedItem', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
this.ctx.override(this.attrProto, 'setNamedItem', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ name, value ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
this.ctx.override(
this.attrProto,
'setNamedItem',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [name, value] = args;
const event = new HookEvent({ name, value }, target, that);
this.emit('setNamedItem', event);
const event = new HookEvent({ name, value }, target, that);
this.emit('setNamedItem', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name, event.data.value);
});
this.ctx.override(this.attrProto, 'removeNamedItem', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.name,
event.data.value
);
}
);
this.ctx.override(
this.attrProto,
'removeNamedItem',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [name] = args;
const event = new HookEvent({ name }, target, that);
this.emit('removeNamedItem', event);
const event = new HookEvent({ name }, target, that);
this.emit('removeNamedItem', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
this.ctx.override(this.attrProto, 'item', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ index ] = args;
let [index] = args;
const event = new HookEvent({ index }, target, that);
this.emit('item', event);
@ -87,37 +124,65 @@ class AttrApi extends EventEmitter {
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
this.ctx.override(this.attrProto, 'getNamedItemNS', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ namespace, localName ] = args;
this.ctx.override(
this.attrProto,
'getNamedItemNS',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [namespace, localName] = args;
const event = new HookEvent({ namespace, localName }, target, that);
this.emit('getNamedItemNS', event);
const event = new HookEvent(
{ namespace, localName },
target,
that
);
this.emit('getNamedItemNS', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.namespace, event.data.localName);
});
this.ctx.override(this.attrProto, 'setNamedItemNS', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ attr ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.namespace,
event.data.localName
);
}
);
this.ctx.override(
this.attrProto,
'setNamedItemNS',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [attr] = args;
const event = new HookEvent({ attr }, target, that);
this.emit('setNamedItemNS', event);
const event = new HookEvent({ attr }, target, that);
this.emit('setNamedItemNS', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
this.ctx.override(this.attrProto, 'removeNamedItemNS', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ namespace, localName ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
this.ctx.override(
this.attrProto,
'removeNamedItemNS',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [namespace, localName] = args;
const event = new HookEvent({ namespace, localName }, target, that);
this.emit('removeNamedItemNS', event);
const event = new HookEvent(
{ namespace, localName },
target,
that
);
this.emit('removeNamedItemNS', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.namespace, event.data.localName);
});
};
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.namespace,
event.data.localName
);
}
);
}
}
export default AttrApi;
export default AttrApi;

193
src/client/dom/document.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class DocumentHook extends EventEmitter {
constructor(ctx) {
@ -11,52 +11,86 @@ class DocumentHook extends EventEmitter {
this.DOMParser = this.window.DOMParser || {};
this.docProto = this.Document.prototype || {};
this.domProto = this.DOMParser.prototype || {};
this.title = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'title');
this.cookie = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'cookie');
this.referrer = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'referrer');
this.domain = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'domain');
this.documentURI = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'documentURI');
this.title = ctx.nativeMethods.getOwnPropertyDescriptor(
this.docProto,
'title'
);
this.cookie = ctx.nativeMethods.getOwnPropertyDescriptor(
this.docProto,
'cookie'
);
this.referrer = ctx.nativeMethods.getOwnPropertyDescriptor(
this.docProto,
'referrer'
);
this.domain = ctx.nativeMethods.getOwnPropertyDescriptor(
this.docProto,
'domain'
);
this.documentURI = ctx.nativeMethods.getOwnPropertyDescriptor(
this.docProto,
'documentURI'
);
this.write = this.docProto.write;
this.writeln = this.docProto.writeln;
this.querySelector = this.docProto.querySelector;
this.querySelectorAll = this.docProto.querySelectorAll;
this.parseFromString = this.domProto.parseFromString;
this.URL = ctx.nativeMethods.getOwnPropertyDescriptor(this.docProto, 'URL');
};
this.URL = ctx.nativeMethods.getOwnPropertyDescriptor(
this.docProto,
'URL'
);
}
overrideParseFromString() {
this.ctx.override(this.domProto, 'parseFromString', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ string, type ] = args;
this.ctx.override(
this.domProto,
'parseFromString',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [string, type] = args;
const event = new HookEvent({ string, type }, target, that);
this.emit('parseFromString', event);
const event = new HookEvent({ string, type }, target, that);
this.emit('parseFromString', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.string, event.data.type);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.string,
event.data.type
);
}
);
}
overrideQuerySelector() {
this.ctx.override(this.docProto, 'querySelector', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ selectors ] = args;
this.ctx.override(
this.docProto,
'querySelector',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [selectors] = args;
const event = new HookEvent({ selectors }, target, that);
this.emit('querySelector', event);
const event = new HookEvent({ selectors }, target, that);
this.emit('querySelector', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.selectors);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.selectors);
}
);
}
overrideDomain() {
this.ctx.overrideDescriptor(this.docProto, 'domain', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getDomain', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ val ]) => {
set: (target, that, [val]) => {
const event = new HookEvent({ value: val }, target, that);
this.emit('setDomain', event);
@ -64,34 +98,53 @@ class DocumentHook extends EventEmitter {
return event.target.call(event.that, event.data.value);
},
});
};
}
overrideReferrer() {
this.ctx.overrideDescriptor(this.docProto, 'referrer', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('referrer', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
});
};
}
overrideCreateTreeWalker() {
this.ctx.override(this.docProto, 'createTreeWalker', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ root, show = 0xFFFFFFFF, filter, expandEntityReferences ] = args;
this.ctx.override(
this.docProto,
'createTreeWalker',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [root, show = 0xffffffff, filter, expandEntityReferences] =
args;
const event = new HookEvent({ root, show, filter, expandEntityReferences }, target, that);
this.emit('createTreeWalker', event);
const event = new HookEvent(
{ root, show, filter, expandEntityReferences },
target,
that
);
this.emit('createTreeWalker', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.root, event.data.show, event.data.filter, event.data.expandEntityReferences);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.root,
event.data.show,
event.data.filter,
event.data.expandEntityReferences
);
}
);
}
overrideWrite() {
this.ctx.override(this.docProto, 'write', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ ...html ] = args;
let [...html] = args;
const event = new HookEvent({ html }, target, that);
this.emit('write', event);
@ -101,7 +154,7 @@ class DocumentHook extends EventEmitter {
});
this.ctx.override(this.docProto, 'writeln', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ ...html ] = args;
let [...html] = args;
const event = new HookEvent({ html }, target, that);
this.emit('writeln', event);
@ -109,76 +162,96 @@ class DocumentHook extends EventEmitter {
if (event.intercepted) return event.returnValue;
return event.target.apply(event.that, event.data.html);
});
};
}
overrideDocumentURI() {
this.ctx.overrideDescriptor(this.docProto, 'documentURI', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('documentURI', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
});
};
}
overrideURL() {
this.ctx.overrideDescriptor(this.docProto, 'URL', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('url', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
});
};
}
overrideReferrer() {
this.ctx.overrideDescriptor(this.docProto, 'referrer', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('referrer', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
});
};
}
overrideCookie() {
this.ctx.overrideDescriptor(this.docProto, 'cookie', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getCookie', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ value ]) => {
const event = new HookEvent({ value, }, target, that);
set: (target, that, [value]) => {
const event = new HookEvent({ value }, target, that);
this.emit('setCookie', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.value);
},
});
};
}
overrideTitle() {
this.ctx.overrideDescriptor(this.docProto, 'title', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getTitle', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ value ]) => {
const event = new HookEvent({ value, }, target, that);
set: (target, that, [value]) => {
const event = new HookEvent({ value }, target, that);
this.emit('setTitle', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.value);
},
});
};
};
}
}
export default DocumentHook;
export default DocumentHook;

231
src/client/dom/element.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class ElementApi extends EventEmitter {
constructor(ctx) {
@ -9,8 +9,14 @@ class ElementApi extends EventEmitter {
this.Audio = this.window.Audio;
this.Element = this.window.Element;
this.elemProto = this.Element ? this.Element.prototype : {};
this.innerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(this.elemProto, 'innerHTML');
this.outerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(this.elemProto, 'outerHTML');
this.innerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(
this.elemProto,
'innerHTML'
);
this.outerHTML = ctx.nativeMethods.getOwnPropertyDescriptor(
this.elemProto,
'outerHTML'
);
this.setAttribute = this.elemProto.setAttribute;
this.getAttribute = this.elemProto.getAttribute;
this.removeAttribute = this.elemProto.removeAttribute;
@ -19,83 +25,116 @@ class ElementApi extends EventEmitter {
this.querySelectorAll = this.elemProto.querySelectorAll;
this.insertAdjacentHTML = this.elemProto.insertAdjacentHTML;
this.insertAdjacentText = this.elemProto.insertAdjacentText;
};
}
overrideQuerySelector() {
this.ctx.override(this.elemProto, 'querySelector', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ selectors ] = args;
this.ctx.override(
this.elemProto,
'querySelector',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [selectors] = args;
const event = new HookEvent({ selectors }, target, that);
this.emit('querySelector', event);
const event = new HookEvent({ selectors }, target, that);
this.emit('querySelector', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.selectors);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.selectors);
}
);
}
overrideAttribute() {
this.ctx.override(this.elemProto, 'getAttribute', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
this.ctx.override(
this.elemProto,
'getAttribute',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [name] = args;
const event = new HookEvent({ name }, target, that);
this.emit('getAttribute', event);
const event = new HookEvent({ name }, target, that);
this.emit('getAttribute', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
this.ctx.override(this.elemProto, 'setAttribute', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ name, value ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
this.ctx.override(
this.elemProto,
'setAttribute',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [name, value] = args;
const event = new HookEvent({ name, value }, target, that);
this.emit('setAttribute', event);
const event = new HookEvent({ name, value }, target, that);
this.emit('setAttribute', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name, event.data.value);
});
this.ctx.override(this.elemProto, 'hasAttribute', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.name,
event.data.value
);
}
);
this.ctx.override(
this.elemProto,
'hasAttribute',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [name] = args;
const event = new HookEvent({ name }, target, that);
this.emit('hasAttribute', event);
const event = new HookEvent({ name }, target, that);
this.emit('hasAttribute', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
this.ctx.override(this.elemProto, 'removeAttribute', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
this.ctx.override(
this.elemProto,
'removeAttribute',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [name] = args;
const event = new HookEvent({ name }, target, that);
this.emit('removeAttribute', event);
const event = new HookEvent({ name }, target, that);
this.emit('removeAttribute', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
}
overrideAudio() {
this.ctx.override(this.window, 'Audio', (target, that, args) => {
if (!args.length) return new target(...args);
let [ url ] = args;
this.ctx.override(
this.window,
'Audio',
(target, that, args) => {
if (!args.length) return new target(...args);
let [url] = args;
const event = new HookEvent({ url }, target, that);
this.emit('audio', event);
const event = new HookEvent({ url }, target, that);
this.emit('audio', event);
if (event.intercepted) return event.returnValue;
return new event.target(event.data.url);
}, true);
};
if (event.intercepted) return event.returnValue;
return new event.target(event.data.url);
},
true
);
}
overrideHtml() {
this.hookProperty(this.Element, 'innerHTML', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getInnerHTML', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ val ]) => {
set: (target, that, [val]) => {
const event = new HookEvent({ value: val }, target, that);
this.emit('setInnerHTML', event);
@ -105,13 +144,17 @@ class ElementApi extends EventEmitter {
});
this.hookProperty(this.Element, 'outerHTML', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getOuterHTML', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ val ]) => {
set: (target, that, [val]) => {
const event = new HookEvent({ value: val }, target, that);
this.emit('setOuterHTML', event);
@ -119,47 +162,63 @@ class ElementApi extends EventEmitter {
target.call(that, event.data.value);
},
});
};
}
overrideInsertAdjacentHTML() {
this.ctx.override(this.elemProto, 'insertAdjacentHTML', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ position, html ] = args;
this.ctx.override(
this.elemProto,
'insertAdjacentHTML',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [position, html] = args;
const event = new HookEvent({ position, html }, target, that);
this.emit('insertAdjacentHTML', event);
const event = new HookEvent({ position, html }, target, that);
this.emit('insertAdjacentHTML', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.position, event.data.html);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.position,
event.data.html
);
}
);
}
overrideInsertAdjacentText() {
this.ctx.override(this.elemProto, 'insertAdjacentText', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ position, text ] = args;
this.ctx.override(
this.elemProto,
'insertAdjacentText',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [position, text] = args;
const event = new HookEvent({ position, text }, target, that);
this.emit('insertAdjacentText', event);
const event = new HookEvent({ position, text }, target, that);
this.emit('insertAdjacentText', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.position, event.data.text);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.position,
event.data.text
);
}
);
}
hookProperty(element, prop, handler) {
if (!element || !prop in element) return false;
if (this.ctx.nativeMethods.isArray(element)) {
for (const elem of element) {
this.hookProperty(elem, prop, handler);
};
}
return true;
};
}
const proto = element.prototype;
this.ctx.overrideDescriptor(proto, prop, handler);
return true;
};
};
export default ElementApi;
return true;
}
}
export default ElementApi;

149
src/client/dom/node.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class NodeApi extends EventEmitter {
constructor(ctx) {
@ -16,24 +16,49 @@ class NodeApi extends EventEmitter {
this.appendChild = this.nodeProto.appendChild;
this.removeChild = this.nodeProto.removeChild;
this.textContent = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'textContent');
this.parentNode = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'parentNode');
this.parentElement = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'parentElement');
this.childNodes = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'childNodes');
this.baseURI = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'baseURI');
this.previousSibling = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'previousSibling');
this.ownerDocument = ctx.nativeMethods.getOwnPropertyDescriptor(this.nodeProto, 'ownerDocument');
};
this.textContent = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'textContent'
);
this.parentNode = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'parentNode'
);
this.parentElement = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'parentElement'
);
this.childNodes = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'childNodes'
);
this.baseURI = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'baseURI'
);
this.previousSibling = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'previousSibling'
);
this.ownerDocument = ctx.nativeMethods.getOwnPropertyDescriptor(
this.nodeProto,
'ownerDocument'
);
}
overrideTextContent() {
this.ctx.overrideDescriptor(this.nodeProto, 'textContent', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getTextContent', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ val ]) => {
set: (target, that, [val]) => {
const event = new HookEvent({ value: val }, target, that);
this.emit('setTextContent', event);
@ -41,41 +66,57 @@ class NodeApi extends EventEmitter {
target.call(that, event.data.value);
},
});
};
}
overrideAppend() {
this.ctx.override(this.nodeProto, 'append', (target, that, [ ...nodes ]) => {
const event = new HookEvent({ nodes }, target, that);
this.emit('append', event);
this.ctx.override(
this.nodeProto,
'append',
(target, that, [...nodes]) => {
const event = new HookEvent({ nodes }, target, that);
this.emit('append', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.nodes);
});
this.ctx.override(this.nodeProto, 'appendChild', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ node ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.nodes);
}
);
this.ctx.override(
this.nodeProto,
'appendChild',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [node] = args;
const event = new HookEvent({ node }, target, that);
this.emit('appendChild', event);
const event = new HookEvent({ node }, target, that);
this.emit('appendChild', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.node);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.node);
}
);
}
overrideBaseURI() {
this.ctx.overrideDescriptor(this.nodeProto, 'baseURI', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('baseURI', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
})
};
});
}
overrideParent() {
this.ctx.overrideDescriptor(this.nodeProto, 'parentNode', {
get: (target, that) => {
const event = new HookEvent({ node: target.call(that) }, target, that);
const event = new HookEvent(
{ node: target.call(that) },
target,
that
);
this.emit('parentNode', event);
if (event.intercepted) return event.returnValue;
@ -84,38 +125,50 @@ class NodeApi extends EventEmitter {
});
this.ctx.overrideDescriptor(this.nodeProto, 'parentElement', {
get: (target, that) => {
const event = new HookEvent({ element: target.call(that) }, target, that);
const event = new HookEvent(
{ element: target.call(that) },
target,
that
);
this.emit('parentElement', event);
if (event.intercepted) return event.returnValue;
return event.data.node;
},
});
};
}
overrideOwnerDocument() {
this.ctx.overrideDescriptor(this.nodeProto, 'ownerDocument', {
get: (target, that) => {
const event = new HookEvent({ document: target.call(that) }, target, that);
const event = new HookEvent(
{ document: target.call(that) },
target,
that
);
this.emit('ownerDocument', event);
if (event.intercepted) return event.returnValue;
return event.data.document;
},
});
};
}
overrideCompareDocumentPosit1ion() {
this.ctx.override(this.nodeProto, 'compareDocumentPosition', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ node ] = args;
const event = new HookEvent({ node }, target, that);
this.ctx.override(
this.nodeProto,
'compareDocumentPosition',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [node] = args;
const event = new HookEvent({ node }, target, that);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.node);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.node);
}
);
}
overrideChildMethods() {
this.ctx.override(this.nodeProto, 'removeChild')
};
};
this.ctx.override(this.nodeProto, 'removeChild');
}
}
export default NodeApi;
export default NodeApi;

94
src/client/dom/style.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class StyleApi extends EventEmitter {
constructor(ctx) {
@ -10,9 +10,29 @@ class StyleApi extends EventEmitter {
this.cssStyleProto = this.CSSStyleDeclaration.prototype || {};
this.getPropertyValue = this.cssStyleProto.getPropertyValue || null;
this.setProperty = this.cssStyleProto.setProperty || null;
this.cssText - ctx.nativeMethods.getOwnPropertyDescriptors(this.cssStyleProto, 'cssText');
this.urlProps = ['background', 'backgroundImage', 'borderImage', 'borderImageSource', 'listStyle', 'listStyleImage', 'cursor'];
this.dashedUrlProps = ['background', 'background-image', 'border-image', 'border-image-source', 'list-style', 'list-style-image', 'cursor'];
this.cssText -
ctx.nativeMethods.getOwnPropertyDescriptors(
this.cssStyleProto,
'cssText'
);
this.urlProps = [
'background',
'backgroundImage',
'borderImage',
'borderImageSource',
'listStyle',
'listStyleImage',
'cursor',
];
this.dashedUrlProps = [
'background',
'background-image',
'border-image',
'border-image-source',
'list-style',
'list-style-image',
'cursor',
];
this.propToDashed = {
background: 'background',
backgroundImage: 'background-image',
@ -20,42 +40,58 @@ class StyleApi extends EventEmitter {
borderImageSource: 'border-image-source',
listStyle: 'list-style',
listStyleImage: 'list-style-image',
cursor: 'cursor'
cursor: 'cursor',
};
};
}
overrideSetGetProperty() {
this.ctx.override(this.cssStyleProto, 'getPropertyValue', (target, that, args) => {
if (!args.length) return target.apply(that, args);
this.ctx.override(
this.cssStyleProto,
'getPropertyValue',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ property ] = args;
let [property] = args;
const event = new HookEvent({ property }, target, that);
this.emit('getPropertyValue', event);
const event = new HookEvent({ property }, target, that);
this.emit('getPropertyValue', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.property);
});
this.ctx.override(this.cssStyleProto, 'setProperty', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ property, value ] = args;
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.property);
}
);
this.ctx.override(
this.cssStyleProto,
'setProperty',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [property, value] = args;
const event = new HookEvent({ property, value }, target, that);
this.emit('setProperty', event);
const event = new HookEvent({ property, value }, target, that);
this.emit('setProperty', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.property, event.data.value);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.property,
event.data.value
);
}
);
}
overrideCssText() {
this.ctx.overrideDescriptor(this.cssStyleProto, 'cssText', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getCssText', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
set: (target, that, [ val ]) => {
set: (target, that, [val]) => {
const event = new HookEvent({ value: val }, target, that);
this.emit('setCssText', event);
@ -63,7 +99,7 @@ class StyleApi extends EventEmitter {
return event.target.call(event.that, event.data.value);
},
});
};
};
}
}
export default StyleApi;
export default StyleApi;

629
src/client/events.js
View file

@ -21,37 +21,41 @@
'use strict';
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var R = typeof Reflect === 'object' ? Reflect : null;
var ReflectApply =
R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
};
var ReflectOwnKeys
var ReflectOwnKeys;
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target).concat(
Object.getOwnPropertySymbols(target)
);
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
var NumberIsNaN =
Number.isNaN ||
function NumberIsNaN(value) {
return value !== value;
};
function EventEmitter() {
EventEmitter.init.call(this);
EventEmitter.init.call(this);
}
export default EventEmitter;
@ -68,430 +72,451 @@ EventEmitter.prototype._maxListeners = undefined;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
if (typeof listener !== 'function') {
throw new TypeError(
'The "listener" argument must be of type Function. Received type ' +
typeof listener
);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
enumerable: true,
get: function () {
return defaultMaxListeners;
},
set: function (arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError(
'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' +
arg +
'.'
);
}
defaultMaxListeners = arg;
},
});
EventEmitter.init = function() {
EventEmitter.init = function () {
if (
this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events
) {
this._events = Object.create(null);
this._eventsCount = 0;
}
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError(
'The value of "n" is out of range. It must be a non-negative number. Received ' +
n +
'.'
);
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = type === 'error';
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
var events = this._events;
if (events !== undefined) doError = doError && events.error === undefined;
else if (!doError) return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0) er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error(
'Unhandled error.' + (er ? ' (' + er.message + ')' : '')
);
err.context = er;
throw err; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
var handler = events[type];
if (handler === undefined)
return false;
if (handler === undefined) return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
}
return true;
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
var m;
var events;
var existing;
checkListener(listener);
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
existing.push(listener);
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit(
'newListener',
type,
listener.listener ? listener.listener : listener
);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] = prepend
? [listener, existing]
: [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
return target;
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error(
'Possible EventEmitter memory leak detected. ' +
existing.length +
' ' +
String(type) +
' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit'
);
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
EventEmitter.prototype.prependListener = function prependListener(
type,
listener
) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0) return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
var state = {
fired: false,
wrapFn: undefined,
target: target,
type: type,
listener: listener,
};
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener = function prependOnceListener(
type,
listener
) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
EventEmitter.prototype.removeListener = function removeListener(
type,
listener
) {
var list, events, position, i, originalListener;
checkListener(listener);
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
events = this._events;
if (events === undefined) return this;
list = events[type];
if (list === undefined)
return this;
list = events[type];
if (list === undefined) return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0) this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position < 0) return this;
if (position === 0)
list.shift();
if (position === 0) list.shift();
else {
spliceOne(list, position);
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (list.length === 1) events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
events = this._events;
if (events === undefined) return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0) this._events = Object.create(null);
else delete events[type];
}
return this;
}
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
}
listeners = events[type];
listeners = events[type];
if (typeof listeners === 'function') {
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
this.removeListener(type, listeners[i]);
}
}
}
return this;
};
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
var events = target._events;
if (events === undefined)
return [];
if (events === undefined) return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined) return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
return unwrap
? unwrapListeners(evlistener)
: arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
EventEmitter.listenerCount = function (emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
}
return 0;
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
var copy = new Array(n);
for (var i = 0; i < n; ++i) copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
for (; index + 1 < list.length; index++) list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
}
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, {
once: true,
});
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
emitter.on(name, listener);
throw new TypeError(
'The "emitter" argument must be of type EventEmitter. Received type ' +
typeof emitter
);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
}

82
src/client/history.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "./events.js";
import HookEvent from "./hook.js";
import EventEmitter from './events.js';
import HookEvent from './hook.js';
class History extends EventEmitter {
constructor(ctx) {
@ -14,47 +14,73 @@ class History extends EventEmitter {
this.go = this.historyProto.go;
this.back = this.historyProto.back;
this.forward = this.historyProto.forward;
};
}
override() {
this.overridePushState();
this.overrideReplaceState();
this.overrideGo();
this.overrideForward();
this.overrideBack();
};
}
overridePushState() {
this.ctx.override(this.historyProto, 'pushState', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ state, title, url = '' ] = args;
this.ctx.override(
this.historyProto,
'pushState',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [state, title, url = ''] = args;
const event = new HookEvent({ state, title, url }, target, that);
this.emit('pushState', event);
const event = new HookEvent(
{ state, title, url },
target,
that
);
this.emit('pushState', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.state, event.data.title, event.data.url);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.state,
event.data.title,
event.data.url
);
}
);
}
overrideReplaceState() {
this.ctx.override(this.historyProto, 'replaceState', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ state, title, url = '' ] = args;
this.ctx.override(
this.historyProto,
'replaceState',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [state, title, url = ''] = args;
const event = new HookEvent({ state, title, url }, target, that);
this.emit('replaceState', event);
const event = new HookEvent(
{ state, title, url },
target,
that
);
this.emit('replaceState', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.state, event.data.title, event.data.url);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.state,
event.data.title,
event.data.url
);
}
);
}
overrideGo() {
this.ctx.override(this.historyProto, 'go', (target, that, [ delta ]) => {
this.ctx.override(this.historyProto, 'go', (target, that, [delta]) => {
const event = new HookEvent({ delta }, target, that);
this.emit('go', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.delta);
});
};
}
overrideForward() {
this.ctx.override(this.historyProto, 'forward', (target, that) => {
const event = new HookEvent(null, target, that);
@ -63,7 +89,7 @@ class History extends EventEmitter {
if (event.intercepted) return event.returnValue;
return event.target.call(event.that);
});
};
}
overrideBack() {
this.ctx.override(this.historyProto, 'back', (target, that) => {
const event = new HookEvent(null, target, that);
@ -72,7 +98,7 @@ class History extends EventEmitter {
if (event.intercepted) return event.returnValue;
return event.target.call(event.that);
});
};
};
}
}
export default History;
export default History;

12
src/client/hook.js
View file

@ -7,17 +7,17 @@ class HookEvent {
this.data = data;
this.target = target;
this.that = that;
};
}
get intercepted() {
return this.#intercepted;
};
}
get returnValue() {
return this.#returnValue;
};
}
respondWith(input) {
this.#returnValue = input;
this.#intercepted = true;
};
};
}
}
export default HookEvent;
export default HookEvent;

106
src/client/index.js
View file

@ -1,22 +1,22 @@
import DocumentHook from "./dom/document.js";
import ElementApi from "./dom/element.js";
import NodeApi from "./dom/node.js";
import AttrApi from "./dom/attr.js";
import FunctionHook from "./native/function.js";
import ObjectHook from "./native/object.js";
import Fetch from "./requests/fetch.js";
import WebSocketApi from "./requests/websocket.js";
import Xhr from "./requests/xhr.js";
import EventSourceApi from "./requests/eventsource.js";
import History from "./history.js";
import LocationApi from "./location.js";
import MessageApi from "./message.js";
import NavigatorApi from "./navigator.js";
import Workers from "./worker.js";
import URLApi from "./url.js";
import EventEmitter from "./events.js";
import StorageApi from "./storage.js";
import StyleApi from "./dom/style.js";
import DocumentHook from './dom/document.js';
import ElementApi from './dom/element.js';
import NodeApi from './dom/node.js';
import AttrApi from './dom/attr.js';
import FunctionHook from './native/function.js';
import ObjectHook from './native/object.js';
import Fetch from './requests/fetch.js';
import WebSocketApi from './requests/websocket.js';
import Xhr from './requests/xhr.js';
import EventSourceApi from './requests/eventsource.js';
import History from './history.js';
import LocationApi from './location.js';
import MessageApi from './message.js';
import NavigatorApi from './navigator.js';
import Workers from './worker.js';
import URLApi from './url.js';
import EventEmitter from './events.js';
import StorageApi from './storage.js';
import StyleApi from './dom/style.js';
class UVClient extends EventEmitter {
constructor(window = self, worker = !window.window) {
@ -25,8 +25,10 @@ class UVClient extends EventEmitter {
this.nativeMethods = {
fnToString: this.window.Function.prototype.toString,
defineProperty: this.window.Object.defineProperty,
getOwnPropertyDescriptor: this.window.Object.getOwnPropertyDescriptor,
getOwnPropertyDescriptors: this.window.Object.getOwnPropertyDescriptors,
getOwnPropertyDescriptor:
this.window.Object.getOwnPropertyDescriptor,
getOwnPropertyDescriptors:
this.window.Object.getOwnPropertyDescriptors,
getOwnPropertyNames: this.window.Object.getOwnPropertyNames,
keys: this.window.Object.keys,
getOwnPropertySymbols: this.window.Object.getOwnPropertySymbols,
@ -41,7 +43,7 @@ class UVClient extends EventEmitter {
this.xhr = new Xhr(this);
this.history = new History(this);
this.element = new ElementApi(this);
this.node = new NodeApi(this)
this.node = new NodeApi(this);
this.document = new DocumentHook(this);
this.function = new FunctionHook(this);
this.object = new ObjectHook(this);
@ -55,56 +57,70 @@ class UVClient extends EventEmitter {
this.location = new LocationApi(this);
this.storage = new StorageApi(this);
this.style = new StyleApi(this);
};
}
initLocation(rewriteUrl, sourceUrl) {
this.location = new LocationApi(this, sourceUrl, rewriteUrl, this.worker);
};
this.location = new LocationApi(
this,
sourceUrl,
rewriteUrl,
this.worker
);
}
override(obj, prop, wrapper, construct) {
if (!prop in obj) return false;
const wrapped = this.wrap(obj, prop, wrapper, construct);
return obj[prop] = wrapped;
};
return (obj[prop] = wrapped);
}
overrideDescriptor(obj, prop, wrapObj = {}) {
const wrapped = this.wrapDescriptor(obj, prop, wrapObj);
if (!wrapped) return {};
this.nativeMethods.defineProperty(obj, prop, wrapped);
return wrapped;
};
}
wrap(obj, prop, wrap, construct) {
const fn = obj[prop];
if (!fn) return fn;
const wrapped = 'prototype' in fn ? function attach() {
return wrap(fn, this, [...arguments]);
} : {
attach() {
return wrap(fn, this, [...arguments]);
},
}.attach;
const wrapped =
'prototype' in fn
? function attach() {
return wrap(fn, this, [...arguments]);
}
: {
attach() {
return wrap(fn, this, [...arguments]);
},
}.attach;
if (!!construct) {
wrapped.prototype = fn.prototype;
wrapped.prototype.constructor = wrapped;
};
wrapped.prototype.constructor = wrapped;
}
this.emit('wrap', fn, wrapped, !!construct);
return wrapped;
};
}
wrapDescriptor(obj, prop, wrapObj = {}) {
const descriptor = this.nativeMethods.getOwnPropertyDescriptor(obj, prop);
const descriptor = this.nativeMethods.getOwnPropertyDescriptor(
obj,
prop
);
if (!descriptor) return false;
for (let key in wrapObj) {
if (key in descriptor) {
if (key === 'get' || key === 'set') {
descriptor[key] = this.wrap(descriptor, key, wrapObj[key]);
} else {
descriptor[key] = typeof wrapObj[key] == 'function' ? wrapObj[key](descriptor[key]) : wrapObj[key];
};
descriptor[key] =
typeof wrapObj[key] == 'function'
? wrapObj[key](descriptor[key])
: wrapObj[key];
}
}
};
}
return descriptor;
};
};
}
}
export default UVClient;
if (typeof self === 'object') self.UVClient = UVClient;
if (typeof self === 'object') self.UVClient = UVClient;

205
src/client/location.js
View file

@ -1,4 +1,4 @@
import EventEmitter from "./events.js";
import EventEmitter from './events.js';
class LocationApi extends EventEmitter {
constructor(ctx) {
@ -6,29 +6,45 @@ class LocationApi extends EventEmitter {
this.ctx = ctx;
this.window = ctx.window;
this.location = this.window.location;
this.WorkerLocation = this.ctx.worker ? this.window.WorkerLocation : null;
this.workerLocProto = this.WorkerLocation ? this.WorkerLocation.prototype : {};
this.keys = ['href', 'protocol', 'host', 'hostname', 'port', 'pathname', 'search', 'hash', 'origin'];
this.WorkerLocation = this.ctx.worker
? this.window.WorkerLocation
: null;
this.workerLocProto = this.WorkerLocation
? this.WorkerLocation.prototype
: {};
this.keys = [
'href',
'protocol',
'host',
'hostname',
'port',
'pathname',
'search',
'hash',
'origin',
];
this.HashChangeEvent = this.window.HashChangeEvent || null;
this.href = this.WorkerLocation ? ctx.nativeMethods.getOwnPropertyDescriptor(this.workerLocProto, 'href') :
ctx.nativeMethods.getOwnPropertyDescriptor(this.location, 'href');
};
this.href = this.WorkerLocation
? ctx.nativeMethods.getOwnPropertyDescriptor(
this.workerLocProto,
'href'
)
: ctx.nativeMethods.getOwnPropertyDescriptor(this.location, 'href');
}
overrideWorkerLocation(parse) {
if (!this.WorkerLocation) return false;
const uv = this;
for (const key of this.keys) {
this.ctx.overrideDescriptor(this.workerLocProto, key, {
get: (target, that) => {
return parse(
uv.href.get.call(this.location)
)[key]
return parse(uv.href.get.call(this.location))[key];
},
});
};
}
return true;
};
}
emulate(parse, wrap) {
const emulation = {};
const that = this;
@ -36,81 +52,124 @@ class LocationApi extends EventEmitter {
for (const key of that.keys) {
this.ctx.nativeMethods.defineProperty(emulation, key, {
get() {
return parse(
that.href.get.call(that.location)
)[key];
return parse(that.href.get.call(that.location))[key];
},
set: key !== 'origin' ? function (val) {
switch(key) {
case 'href':
that.location.href = wrap(val);
break;
case 'hash':
that.emit('hashchange', emulation.href, (val.trim().startsWith('#') ? new URL(val.trim(), emulation.href).href : new URL('#' + val.trim(), emulation.href).href), that);
break;
default:
const url = new URL(emulation.href);
url[key] = val;
that.location.href = wrap(url.href);
};
} : undefined,
set:
key !== 'origin'
? function (val) {
switch (key) {
case 'href':
that.location.href = wrap(val);
break;
case 'hash':
that.emit(
'hashchange',
emulation.href,
val.trim().startsWith('#')
? new URL(
val.trim(),
emulation.href
).href
: new URL(
'#' + val.trim(),
emulation.href
).href,
that
);
break;
default:
const url = new URL(emulation.href);
url[key] = val;
that.location.href = wrap(url.href);
}
}
: undefined,
configurable: false,
enumerable: true,
});
};
}
if ('reload' in this.location) {
this.ctx.nativeMethods.defineProperty(emulation, 'reload', {
value: this.ctx.wrap(this.location, 'reload', (target, that) => {
return target.call(that === emulation ? this.location : that);
}),
value: this.ctx.wrap(
this.location,
'reload',
(target, that) => {
return target.call(
that === emulation ? this.location : that
);
}
),
writable: false,
enumerable: true,
});
};
}
if ('replace' in this.location) {
this.ctx.nativeMethods.defineProperty(emulation, 'replace', {
value: this.ctx.wrap(this.location, 'assign', (target, that, args) => {
if (!args.length || that !== emulation) target.call(that);
that = this.location;
let [ input ] = args;
const url = new URL(input, emulation.href);
return target.call(that === emulation ? this.location : that, wrap(url.href));
}),
value: this.ctx.wrap(
this.location,
'assign',
(target, that, args) => {
if (!args.length || that !== emulation)
target.call(that);
that = this.location;
let [input] = args;
const url = new URL(input, emulation.href);
return target.call(
that === emulation ? this.location : that,
wrap(url.href)
);
}
),
writable: false,
enumerable: true,
});
};
}
if ('assign' in this.location) {
this.ctx.nativeMethods.defineProperty(emulation, 'assign', {
value: this.ctx.wrap(this.location, 'assign', (target, that, args) => {
if (!args.length || that !== emulation) target.call(that);
that = this.location;
let [ input ] = args;
const url = new URL(input, emulation.href);
return target.call(that === emulation ? this.location : that, wrap(url.href));
}),
value: this.ctx.wrap(
this.location,
'assign',
(target, that, args) => {
if (!args.length || that !== emulation)
target.call(that);
that = this.location;
let [input] = args;
const url = new URL(input, emulation.href);
return target.call(
that === emulation ? this.location : that,
wrap(url.href)
);
}
),
writable: false,
enumerable: true,
});
};
}
if ('ancestorOrigins' in this.location) {
this.ctx.nativeMethods.defineProperty(emulation, 'ancestorOrigins', {
get() {
const arr = [];
if (that.window.DOMStringList) that.ctx.nativeMethods.setPrototypeOf(arr, that.window.DOMStringList.prototype);
return arr;
},
set: undefined,
enumerable: true,
});
};
this.ctx.nativeMethods.defineProperty(
emulation,
'ancestorOrigins',
{
get() {
const arr = [];
if (that.window.DOMStringList)
that.ctx.nativeMethods.setPrototypeOf(
arr,
that.window.DOMStringList.prototype
);
return arr;
},
set: undefined,
enumerable: true,
}
);
}
this.ctx.nativeMethods.defineProperty(emulation, 'toString', {
value: this.ctx.wrap(this.location, 'toString', () => {
@ -124,12 +183,16 @@ class LocationApi extends EventEmitter {
value: () => emulation.href,
writable: false,
enumerable: false,
});
});
if (this.ctx.window.Location) this.ctx.nativeMethods.setPrototypeOf(emulation, this.ctx.window.Location.prototype);
if (this.ctx.window.Location)
this.ctx.nativeMethods.setPrototypeOf(
emulation,
this.ctx.window.Location.prototype
);
return emulation;
};
};
return emulation;
}
}
export default LocationApi;
export default LocationApi;

115
src/client/message.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "./events.js";
import HookEvent from "./hook.js";
import EventEmitter from './events.js';
import HookEvent from './hook.js';
class MessageApi extends EventEmitter {
constructor(ctx) {
@ -12,9 +12,15 @@ class MessageApi extends EventEmitter {
this.mpProto = this.MessagePort.prototype || {};
this.mpPostMessage = this.mpProto.postMessage;
this.messageProto = this.MessageEvent.prototype || {};
this.messageData = ctx.nativeMethods.getOwnPropertyDescriptor(this.messageProto, 'data');
this.messageOrigin = ctx.nativeMethods.getOwnPropertyDescriptor(this.messageProto, 'origin');
};
this.messageData = ctx.nativeMethods.getOwnPropertyDescriptor(
this.messageProto,
'data'
);
this.messageOrigin = ctx.nativeMethods.getOwnPropertyDescriptor(
this.messageProto,
'origin'
);
}
overridePostMessage() {
this.ctx.override(this.window, 'postMessage', (target, that, args) => {
if (!args.length) return target.apply(that, args);
@ -22,63 +28,102 @@ class MessageApi extends EventEmitter {
let message;
let origin;
let transfer;
if (!this.ctx.worker) {
[ message, origin, transfer = [] ] = args;
} else {
[ message, transfer = [] ] = args;
};
const event = new HookEvent({ message, origin, transfer, worker: this.ctx.worker }, target, that);
if (!this.ctx.worker) {
[message, origin, transfer = []] = args;
} else {
[message, transfer = []] = args;
}
const event = new HookEvent(
{ message, origin, transfer, worker: this.ctx.worker },
target,
that
);
this.emit('postMessage', event);
if (event.intercepted) return event.returnValue;
return this.ctx.worker ? event.target.call(event.that, event.data.message, event.data.transfer) : event.target.call(event.that, event.data.message, event.data.origin, event.data.transfer);
return this.ctx.worker
? event.target.call(
event.that,
event.data.message,
event.data.transfer
)
: event.target.call(
event.that,
event.data.message,
event.data.origin,
event.data.transfer
);
});
};
}
wrapPostMessage(obj, prop, noOrigin = false) {
return this.ctx.wrap(obj, prop, (target, that, args) => {
if (this.ctx.worker ? !args.length : 2 > args) return target.apply(that, args);
if (this.ctx.worker ? !args.length : 2 > args)
return target.apply(that, args);
let message;
let origin;
let transfer;
if (!noOrigin) {
[ message, origin, transfer = [] ] = args;
} else {
[ message, transfer = [] ] = args;
origin = null;
};
const event = new HookEvent({ message, origin, transfer, worker: this.ctx.worker }, target, obj);
if (!noOrigin) {
[message, origin, transfer = []] = args;
} else {
[message, transfer = []] = args;
origin = null;
}
const event = new HookEvent(
{ message, origin, transfer, worker: this.ctx.worker },
target,
obj
);
this.emit('postMessage', event);
if (event.intercepted) return event.returnValue;
return noOrigin ? event.target.call(event.that, event.data.message, event.data.transfer) : event.target.call(event.that, event.data.message, event.data.origin, event.data.transfer);
return noOrigin
? event.target.call(
event.that,
event.data.message,
event.data.transfer
)
: event.target.call(
event.that,
event.data.message,
event.data.origin,
event.data.transfer
);
});
};
}
overrideMessageOrigin() {
this.ctx.overrideDescriptor(this.messageProto, 'origin', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('origin', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
}
},
});
};
}
overrideMessageData() {
this.ctx.overrideDescriptor(this.messageProto, 'data', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('data', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
}
},
});
};
};
}
}
export default MessageApi;
export default MessageApi;

51
src/client/native/function.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class FunctionHook extends EventEmitter {
constructor(ctx) {
@ -13,25 +13,38 @@ class FunctionHook extends EventEmitter {
this.call = this.fnProto.call;
this.apply = this.fnProto.apply;
this.bind = this.fnProto.bind;
};
}
overrideFunction() {
this.ctx.override(this.window, 'Function', (target, that, args) => {
if (!args.length) return target.apply(that, args);
this.ctx.override(
this.window,
'Function',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let script = args[args.length - 1];
let fnArgs = [];
let script = args[args.length - 1];
let fnArgs = [];
for (let i = 0; i < args.length - 1; i++) {
fnArgs.push(args[i]);
};
for (let i = 0; i < args.length - 1; i++) {
fnArgs.push(args[i]);
}
const event = new HookEvent({ script, args: fnArgs }, target, that);
this.emit('function', event);
const event = new HookEvent(
{ script, args: fnArgs },
target,
that
);
this.emit('function', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, ...event.data.args, event.data.script);
}, true);
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
...event.data.args,
event.data.script
);
},
true
);
}
overrideToString() {
this.ctx.override(this.fnProto, 'toString', (target, that) => {
const event = new HookEvent({ fn: that }, target, that);
@ -40,7 +53,7 @@ class FunctionHook extends EventEmitter {
if (event.intercepted) return event.returnValue;
return event.target.call(event.data.fn);
});
};
};
}
}
export default FunctionHook;
export default FunctionHook;

66
src/client/native/object.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class ObjectHook extends EventEmitter {
constructor(ctx) {
@ -10,31 +10,47 @@ class ObjectHook extends EventEmitter {
this.getOwnPropertyDescriptors = this.Object.getOwnPropertyDescriptors;
this.getOwnPropertyDescriptor = this.Object.getOwnPropertyDescriptor;
this.getOwnPropertyNames = this.Object.getOwnPropertyNames;
};
}
overrideGetPropertyNames() {
this.ctx.override(this.Object, 'getOwnPropertyNames', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ object ] = args;
this.ctx.override(
this.Object,
'getOwnPropertyNames',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [object] = args;
const event = new HookEvent({ names: target.call(that, object) }, target, that);
this.emit('getOwnPropertyNames', event);
if (event.intercepted) return event.returnValue;
return event.data.names;
});
};
const event = new HookEvent(
{ names: target.call(that, object) },
target,
that
);
this.emit('getOwnPropertyNames', event);
if (event.intercepted) return event.returnValue;
return event.data.names;
}
);
}
overrideGetOwnPropertyDescriptors() {
this.ctx.override(this.Object, 'getOwnPropertyDescriptors', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ object ] = args;
this.ctx.override(
this.Object,
'getOwnPropertyDescriptors',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [object] = args;
const event = new HookEvent({ descriptors: target.call(that, object) }, target, that);
this.emit('getOwnPropertyDescriptors', event);
if (event.intercepted) return event.returnValue;
return event.data.descriptors;
});
};
};
const event = new HookEvent(
{ descriptors: target.call(that, object) },
target,
that
);
this.emit('getOwnPropertyDescriptors', event);
export default ObjectHook;
if (event.intercepted) return event.returnValue;
return event.data.descriptors;
}
);
}
}
export default ObjectHook;

20
src/client/navigator.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "./events.js";
import HookEvent from "./hook.js";
import EventEmitter from './events.js';
import HookEvent from './hook.js';
class NavigatorApi extends EventEmitter {
constructor(ctx) {
@ -10,19 +10,23 @@ class NavigatorApi extends EventEmitter {
this.Navigator = this.window.Navigator || {};
this.navProto = this.Navigator.prototype || {};
this.sendBeacon = this.navProto.sendBeacon;
};
}
overrideSendBeacon() {
this.ctx.override(this.navProto, 'sendBeacon', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ url, data = '' ] = args;
let [url, data = ''] = args;
const event = new HookEvent({ url, data }, target, that);
this.emit('sendBeacon', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.url, event.data.data);
return event.target.call(
event.that,
event.data.url,
event.data.data
);
});
};
};
}
}
export default NavigatorApi;
export default NavigatorApi;

52
src/client/requests/eventsource.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class EventSourceApi extends EventEmitter {
constructor(ctx) {
@ -8,38 +8,50 @@ class EventSourceApi extends EventEmitter {
this.window = ctx.window;
this.EventSource = this.window.EventSource || {};
this.esProto = this.EventSource.prototype || {};
this.url = ctx.nativeMethods.getOwnPropertyDescriptor(this.esProto, 'url');
this.url = ctx.nativeMethods.getOwnPropertyDescriptor(
this.esProto,
'url'
);
this.CONNECTING = 0;
this.OPEN = 1;
this.CLOSED = 2;
};
}
overrideConstruct() {
this.ctx.override(this.window, 'EventSource', (target, that, args) => {
if (!args.length) return new target(...args);
let [ url, config = {} ] = args;
this.ctx.override(
this.window,
'EventSource',
(target, that, args) => {
if (!args.length) return new target(...args);
let [url, config = {}] = args;
const event = new HookEvent({ url, config }, target, that);
this.emit('construct', event);
const event = new HookEvent({ url, config }, target, that);
this.emit('construct', event);
if (event.intercepted) return event.returnValue;
return new event.target(event.data.url, event.data.config);
}, true);
if (event.intercepted) return event.returnValue;
return new event.target(event.data.url, event.data.config);
},
true
);
if ('EventSource' in this.window) {
this.window.EventSource.CONNECTING = this.CONNECTING;
this.window.EventSource.OPEN = this.OPEN;
this.window.EventSource.CLOSED = this.CLOSED;
};
};
}
}
overrideUrl() {
this.ctx.overrideDescriptor(this.esProto, 'url', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
this.emit('url', event);
return event.data.value;
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('url', event);
return event.data.value;
},
});
};
};
}
}
export default EventSourceApi;
export default EventSourceApi;

134
src/client/requests/fetch.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class Fetch extends EventEmitter {
constructor(ctx) {
@ -13,49 +13,75 @@ class Fetch extends EventEmitter {
this.reqProto = this.Request ? this.Request.prototype : {};
this.resProto = this.Response ? this.Response.prototype : {};
this.headersProto = this.Headers ? this.Headers.prototype : {};
this.reqUrl = ctx.nativeMethods.getOwnPropertyDescriptor(this.reqProto, 'url');
this.resUrl = ctx.nativeMethods.getOwnPropertyDescriptor(this.resProto, 'url');
this.reqHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(this.reqProto, 'headers');
this.resHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(this.resProto, 'headers');
};
this.reqUrl = ctx.nativeMethods.getOwnPropertyDescriptor(
this.reqProto,
'url'
);
this.resUrl = ctx.nativeMethods.getOwnPropertyDescriptor(
this.resProto,
'url'
);
this.reqHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(
this.reqProto,
'headers'
);
this.resHeaders = ctx.nativeMethods.getOwnPropertyDescriptor(
this.resProto,
'headers'
);
}
override() {
this.overrideRequest();
this.overrideUrl();
this.overrideHeaders();
return true;
};
}
overrideRequest() {
if (!this.fetch) return false;
this.ctx.override(this.window, 'fetch', (target, that, args) => {
if (!args.length || args[0] instanceof this.Request) return target.apply(that, args);
if (!args.length || args[0] instanceof this.Request)
return target.apply(that, args);
let [ input, options = {} ] = args;
let [input, options = {}] = args;
const event = new HookEvent({ input, options }, target, that);
this.emit('request', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.input, event.data.options);
return event.target.call(
event.that,
event.data.input,
event.data.options
);
});
this.ctx.override(this.window, 'Request', (target, that, args) => {
if (!args.length) return new target(...args);
this.ctx.override(
this.window,
'Request',
(target, that, args) => {
if (!args.length) return new target(...args);
let [ input, options = {} ] = args;
const event = new HookEvent({ input, options }, target);
let [input, options = {}] = args;
const event = new HookEvent({ input, options }, target);
this.emit('request', event);
if (event.intercepted) return event.returnValue;
this.emit('request', event);
if (event.intercepted) return event.returnValue;
return new event.target(event.data.input, event.data.options);
}, true);
return new event.target(event.data.input, event.data.options);
},
true
);
return true;
};
}
overrideUrl() {
this.ctx.overrideDescriptor(this.reqProto, 'url', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('requestUrl', event);
if (event.intercepted) return event.returnValue;
@ -66,7 +92,11 @@ class Fetch extends EventEmitter {
this.ctx.overrideDescriptor(this.resProto, 'url', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('responseUrl', event);
if (event.intercepted) return event.returnValue;
@ -75,35 +105,47 @@ class Fetch extends EventEmitter {
},
});
return true;
};
}
overrideHeaders() {
if (!this.Headers) return false;
this.ctx.overrideDescriptor(this.reqProto, 'headers', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('requestHeaders', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
},
});
this.ctx.overrideDescriptor(this.resProto, 'headers', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('responseHeaders', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
},
});
this.ctx.override(this.headersProto, 'get', (target, that, [ name ]) => {
this.ctx.override(this.headersProto, 'get', (target, that, [name]) => {
if (!name) return target.call(that);
const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
const event = new HookEvent(
{ name, value: target.call(that, name) },
target,
that
);
this.emit('getHeader', event);
if (event.intercepted) return event.returnValue;
@ -114,20 +156,28 @@ class Fetch extends EventEmitter {
this.ctx.override(this.headersProto, 'set', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ name, value ] = args;
let [name, value] = args;
const event = new HookEvent({ name, value }, target, that);
this.emit('setHeader', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name, event.data.value);
return event.target.call(
event.that,
event.data.name,
event.data.value
);
});
this.ctx.override(this.headersProto, 'has', (target, that, args) => {
if (!args.length) return target.call(that);
let [ name ] = args;
let [name] = args;
const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
const event = new HookEvent(
{ name, value: target.call(that, name) },
target,
that
);
this.emit('hasHeader', event);
if (event.intercepted) return event.returnValue;
@ -138,19 +188,23 @@ class Fetch extends EventEmitter {
this.ctx.override(this.headersProto, 'append', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ name, value ] = args;
let [name, value] = args;
const event = new HookEvent({ name, value }, target, that);
this.emit('appendHeader', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name, event.data.value);
return event.target.call(
event.that,
event.data.name,
event.data.value
);
});
this.ctx.override(this.headersProto, 'delete', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
let [name] = args;
const event = new HookEvent({ name }, target, that);
this.emit('deleteHeader', event);
@ -160,7 +214,7 @@ class Fetch extends EventEmitter {
});
return true;
};
};
}
}
export default Fetch;
export default Fetch;

70
src/client/requests/websocket.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class WebSocketApi extends EventEmitter {
constructor(ctx) {
@ -8,51 +8,71 @@ class WebSocketApi extends EventEmitter {
this.window = ctx.window;
this.WebSocket = this.window.WebSocket || {};
this.wsProto = this.WebSocket.prototype || {};
this.url = ctx.nativeMethods.getOwnPropertyDescriptor(this.wsProto, 'url');
this.protocol = ctx.nativeMethods.getOwnPropertyDescriptor(this.wsProto, 'protocol');
this.url = ctx.nativeMethods.getOwnPropertyDescriptor(
this.wsProto,
'url'
);
this.protocol = ctx.nativeMethods.getOwnPropertyDescriptor(
this.wsProto,
'protocol'
);
this.send = this.wsProto.send;
this.close = this.wsProto.close;
this.CONNECTING = 0;
this.OPEN = 1;
this.CLOSING = 2;
this.CLOSED = 3;
};
}
overrideWebSocket() {
this.ctx.override(this.window, 'WebSocket', (target, that, args) => {
if (!args.length) return new target(...args);
let [ url, protocols = [] ] = args;
this.ctx.override(
this.window,
'WebSocket',
(target, that, args) => {
if (!args.length) return new target(...args);
let [url, protocols = []] = args;
if (!this.ctx.nativeMethods.isArray(protocols)) protocols = [ protocols ];
const event = new HookEvent({ url, protocols }, target, that);
this.emit('websocket', event);
if (!this.ctx.nativeMethods.isArray(protocols))
protocols = [protocols];
const event = new HookEvent({ url, protocols }, target, that);
this.emit('websocket', event);
if (event.intercepted) return event.returnValue;
return new event.target(event.data.url, event.data.protocols);
}, true);
if (event.intercepted) return event.returnValue;
return new event.target(event.data.url, event.data.protocols);
},
true
);
this.window.WebSocket.CONNECTING = this.CONNECTING;
this.window.WebSocket.OPEN = this.OPEN;
this.window.WebSocket.CLOSING = this.CLOSING;
this.window.WebSocket.CLOSED = this.CLOSED;
};
}
overrideUrl() {
this.ctx.overrideDescriptor(this.wsProto, 'url', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
this.emit('url', event);
return event.data.value;
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('url', event);
return event.data.value;
},
});
};
}
overrideProtocol() {
this.ctx.overrideDescriptor(this.wsProto, 'protocol', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
this.emit('protocol', event);
return event.data.value;
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('protocol', event);
return event.data.value;
},
});
};
};
}
}
export default WebSocketApi;
export default WebSocketApi;

150
src/client/requests/xhr.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "../events.js";
import HookEvent from "../hook.js";
import EventEmitter from '../events.js';
import HookEvent from '../hook.js';
class Xhr extends EventEmitter {
constructor(ctx) {
@ -7,17 +7,25 @@ class Xhr extends EventEmitter {
this.ctx = ctx;
this.window = ctx.window;
this.XMLHttpRequest = this.window.XMLHttpRequest;
this.xhrProto = this.window.XMLHttpRequest ? this.window.XMLHttpRequest.prototype : {};
this.xhrProto = this.window.XMLHttpRequest
? this.window.XMLHttpRequest.prototype
: {};
this.open = this.xhrProto.open;
this.abort = this.xhrProto.abort;
this.send = this.xhrProto.send;
this.overrideMimeType = this.xhrProto.overrideMimeType
this.overrideMimeType = this.xhrProto.overrideMimeType;
this.getAllResponseHeaders = this.xhrProto.getAllResponseHeaders;
this.getResponseHeader = this.xhrProto.getResponseHeader;
this.setRequestHeader = this.xhrProto.setRequestHeader;
this.responseURL = ctx.nativeMethods.getOwnPropertyDescriptor(this.xhrProto, 'responseURL');
this.responseText = ctx.nativeMethods.getOwnPropertyDescriptor(this.xhrProto, 'responseText');
};
this.responseURL = ctx.nativeMethods.getOwnPropertyDescriptor(
this.xhrProto,
'responseURL'
);
this.responseText = ctx.nativeMethods.getOwnPropertyDescriptor(
this.xhrProto,
'responseText'
);
}
override() {
this.overrideOpen();
this.overrideSend();
@ -25,85 +33,119 @@ class Xhr extends EventEmitter {
this.overrideGetResHeader();
this.overrideGetResHeaders();
this.overrideSetReqHeader();
};
}
overrideOpen() {
this.ctx.override(this.xhrProto, 'open', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ method, input, async = true, user = null, password = null ] = args;
const event = new HookEvent({ method, input, async, user, password }, target, that);
let [method, input, async = true, user = null, password = null] =
args;
const event = new HookEvent(
{ method, input, async, user, password },
target,
that
);
this.emit('open', event);
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.method,
event.data.input,
event.data.async,
event.data.user,
event.that,
event.data.method,
event.data.input,
event.data.async,
event.data.user,
event.data.password
);
});
};
}
overrideResponseUrl() {
this.ctx.overrideDescriptor(this.xhrProto, 'responseURL', {
get: (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('responseUrl', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
},
});
};
}
overrideSend() {
this.ctx.override(this.xhrProto, 'send', (target, that, [ body = null ]) => {
const event = new HookEvent({ body }, target, that);
this.ctx.override(
this.xhrProto,
'send',
(target, that, [body = null]) => {
const event = new HookEvent({ body }, target, that);
this.emit('send', event);
if (event.intercepted) return event.returnValue;
this.emit('send', event);
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.body,
);
});
};
return event.target.call(event.that, event.data.body);
}
);
}
overrideSetReqHeader() {
this.ctx.override(this.xhrProto, 'setRequestHeader', (target, that, args) => {
if (2 > args.length) return target.apply(that, args);
this.ctx.override(
this.xhrProto,
'setRequestHeader',
(target, that, args) => {
if (2 > args.length) return target.apply(that, args);
let [ name, value ] = args;
const event = new HookEvent({ name, value }, target, that);
let [name, value] = args;
const event = new HookEvent({ name, value }, target, that);
this.emit('setReqHeader', event);
if (event.intercepted) return event.returnValue;
this.emit('setReqHeader', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name, event.data.value);
});
};
return event.target.call(
event.that,
event.data.name,
event.data.value
);
}
);
}
overrideGetResHeaders() {
this.ctx.override(this.xhrProto, 'getAllResponseHeaders', (target, that) => {
const event = new HookEvent({ value: target.call(that) }, target, that);
this.ctx.override(
this.xhrProto,
'getAllResponseHeaders',
(target, that) => {
const event = new HookEvent(
{ value: target.call(that) },
target,
that
);
this.emit('getAllResponseHeaders', event);
if (event.intercepted) return event.returnValue;
this.emit('getAllResponseHeaders', event);
if (event.intercepted) return event.returnValue;
return event.data.value;
});
};
return event.data.value;
}
);
}
overrideGetResHeader() {
this.ctx.override(this.xhrProto, 'getResponseHeader', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ name ] = args;
this.ctx.override(
this.xhrProto,
'getResponseHeader',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [name] = args;
const event = new HookEvent({ name, value: target.call(that, name) }, target, that);
if (event.intercepted) return event.returnValue;
const event = new HookEvent(
{ name, value: target.call(that, name) },
target,
that
);
if (event.intercepted) return event.returnValue;
return event.data.value;
});
};
};
return event.data.value;
}
);
}
}
export default Xhr
export default Xhr;

109
src/client/storage.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "./events.js";
import HookEvent from "./hook.js";
import EventEmitter from './events.js';
import HookEvent from './hook.js';
class StorageApi extends EventEmitter {
constructor(ctx) {
@ -17,73 +17,110 @@ class StorageApi extends EventEmitter {
this.key = this.storeProto.key || null;
this.methods = ['key', 'getItem', 'setItem', 'removeItem', 'clear'];
this.wrappers = new ctx.nativeMethods.Map();
};
}
overrideMethods() {
this.ctx.override(this.storeProto, 'getItem', (target, that, args) => {
if (!args.length) return target.apply((this.wrappers.get(that) || that), args);
let [ name ] = args;
if (!args.length)
return target.apply(this.wrappers.get(that) || that, args);
let [name] = args;
const event = new HookEvent({ name }, target, (this.wrappers.get(that) || that));
const event = new HookEvent(
{ name },
target,
this.wrappers.get(that) || that
);
this.emit('getItem', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
this.ctx.override(this.storeProto, 'setItem', (target, that, args) => {
if (2 > args.length) return target.apply((this.wrappers.get(that) || that), args);
let [ name, value ] = args;
if (2 > args.length)
return target.apply(this.wrappers.get(that) || that, args);
let [name, value] = args;
const event = new HookEvent({ name, value }, target, (this.wrappers.get(that) || that));
const event = new HookEvent(
{ name, value },
target,
this.wrappers.get(that) || that
);
this.emit('setItem', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name, event.data.value);
return event.target.call(
event.that,
event.data.name,
event.data.value
);
});
this.ctx.override(this.storeProto, 'removeItem', (target, that, args) => {
if (!args.length) return target.apply((this.wrappers.get(that) || that), args);
let [ name ] = args;
this.ctx.override(
this.storeProto,
'removeItem',
(target, that, args) => {
if (!args.length)
return target.apply(this.wrappers.get(that) || that, args);
let [name] = args;
const event = new HookEvent({ name }, target, (this.wrappers.get(that) || that));
this.emit('removeItem', event);
const event = new HookEvent(
{ name },
target,
this.wrappers.get(that) || that
);
this.emit('removeItem', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
});
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.name);
}
);
this.ctx.override(this.storeProto, 'clear', (target, that) => {
const event = new HookEvent(null, target, (this.wrappers.get(that) || that));
const event = new HookEvent(
null,
target,
this.wrappers.get(that) || that
);
this.emit('clear', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that);
});
this.ctx.override(this.storeProto, 'key', (target, that, args) => {
if (!args.length) return target.apply((this.wrappers.get(that) || that), args);
let [ index ] = args;
if (!args.length)
return target.apply(this.wrappers.get(that) || that, args);
let [index] = args;
const event = new HookEvent({ index }, target, (this.wrappers.get(that) || that));
const event = new HookEvent(
{ index },
target,
this.wrappers.get(that) || that
);
this.emit('key', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.index);
});
};
}
overrideLength() {
this.ctx.overrideDescriptor(this.storeProto, 'length', {
get: (target, that) => {
const event = new HookEvent({ length: target.call((this.wrappers.get(that) || that)) }, target, (this.wrappers.get(that) || that));
const event = new HookEvent(
{ length: target.call(this.wrappers.get(that) || that) },
target,
this.wrappers.get(that) || that
);
this.emit('length', event);
if (event.intercepted) return event.returnValue;
return event.data.length;
},
});
};
}
emulate(storage, obj = {}) {
this.ctx.nativeMethods.setPrototypeOf(obj, this.storeProto);
const proxy = new this.ctx.window.Proxy(obj, {
get: (target, prop) => {
if (prop in this.storeProto || typeof prop === 'symbol') return storage[prop];
if (prop in this.storeProto || typeof prop === 'symbol')
return storage[prop];
const event = new HookEvent({ name: prop }, null, storage);
this.emit('get', event);
@ -92,14 +129,19 @@ class StorageApi extends EventEmitter {
return storage[event.data.name];
},
set: (target, prop, value) => {
if (prop in this.storeProto || typeof prop === 'symbol') return storage[prop] = value;
if (prop in this.storeProto || typeof prop === 'symbol')
return (storage[prop] = value);
const event = new HookEvent({ name: prop, value }, null, storage);
const event = new HookEvent(
{ name: prop, value },
null,
storage
);
this.emit('set', event);
if (event.intercepted) return event.returnValue;
return storage[event.data.name] = event.data.value;
return (storage[event.data.name] = event.data.value);
},
deleteProperty: (target, prop) => {
if (typeof prop === 'symbol') return delete storage[prop];
@ -112,13 +154,12 @@ class StorageApi extends EventEmitter {
return delete storage[event.data.name];
},
});
this.wrappers.set(proxy, storage);
this.ctx.nativeMethods.setPrototypeOf(proxy, this.storeProto);
return proxy;
};
};
}
}
export default StorageApi;

16
src/client/url.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "./events.js";
import HookEvent from "./hook.js";
import EventEmitter from './events.js';
import HookEvent from './hook.js';
class URLApi extends EventEmitter {
constructor(ctx) {
@ -9,11 +9,11 @@ class URLApi extends EventEmitter {
this.URL = this.window.URL || {};
this.createObjectURL = this.URL.createObjectURL;
this.revokeObjectURL = this.URL.revokeObjectURL;
};
}
overrideObjectURL() {
this.ctx.override(this.URL, 'createObjectURL', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ object ] = args;
let [object] = args;
const event = new HookEvent({ object }, target, that);
this.emit('createObjectURL', event);
@ -23,7 +23,7 @@ class URLApi extends EventEmitter {
});
this.ctx.override(this.URL, 'revokeObjectURL', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ url ] = args;
let [url] = args;
const event = new HookEvent({ url }, target, that);
this.emit('revokeObjectURL', event);
@ -31,7 +31,7 @@ class URLApi extends EventEmitter {
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.url);
});
};
};
}
}
export default URLApi;
export default URLApi;

111
src/client/worker.js
View file

@ -1,5 +1,5 @@
import EventEmitter from "./events.js";
import HookEvent from "./hook.js";
import EventEmitter from './events.js';
import HookEvent from './hook.js';
class Workers extends EventEmitter {
constructor(ctx) {
@ -13,54 +13,85 @@ class Workers extends EventEmitter {
this.postMessage = this.workerProto.postMessage;
this.terminate = this.workerProto.terminate;
this.addModule = this.workletProto.addModule;
};
}
overrideWorker() {
this.ctx.override(this.window, 'Worker', (target, that, args) => {
if (!args.length) return new target(...args);
let [ url, options = {} ] = args;
this.ctx.override(
this.window,
'Worker',
(target, that, args) => {
if (!args.length) return new target(...args);
let [url, options = {}] = args;
const event = new HookEvent({ url, options }, target, that);
this.emit('worker', event);
const event = new HookEvent({ url, options }, target, that);
this.emit('worker', event);
if (event.intercepted) return event.returnValue;
return new event.target(...[ event.data.url, event.data.options ]);
}, true);
};
if (event.intercepted) return event.returnValue;
return new event.target(
...[event.data.url, event.data.options]
);
},
true
);
}
overrideAddModule() {
this.ctx.override(this.workletProto, 'addModule', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ url, options = {} ] = args;
this.ctx.override(
this.workletProto,
'addModule',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [url, options = {}] = args;
const event = new HookEvent({ url, options }, target, that);
this.emit('addModule', event);
const event = new HookEvent({ url, options }, target, that);
this.emit('addModule', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.url, event.data.options);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.url,
event.data.options
);
}
);
}
overridePostMessage() {
this.ctx.override(this.workerProto, 'postMessage', (target, that, args) => {
if (!args.length) return target.apply(that, args);
let [ message, transfer = [] ] = args;
this.ctx.override(
this.workerProto,
'postMessage',
(target, that, args) => {
if (!args.length) return target.apply(that, args);
let [message, transfer = []] = args;
const event = new HookEvent({ message, transfer }, target, that);
this.emit('postMessage', event);
const event = new HookEvent(
{ message, transfer },
target,
that
);
this.emit('postMessage', event);
if (event.intercepted) return event.returnValue;
return event.target.call(event.that, event.data.message, event.data.transfer);
});
};
if (event.intercepted) return event.returnValue;
return event.target.call(
event.that,
event.data.message,
event.data.transfer
);
}
);
}
overrideImportScripts() {
this.ctx.override(this.window, 'importScripts', (target, that, scripts) => {
if (!scripts.length) return target.apply(that, scripts);
this.ctx.override(
this.window,
'importScripts',
(target, that, scripts) => {
if (!scripts.length) return target.apply(that, scripts);
const event = new HookEvent({ scripts }, target, that);
this.emit('importScripts', event);
const event = new HookEvent({ scripts }, target, that);
this.emit('importScripts', event);
if (event.intercepted) return event.returnValue;
return event.target.apply(event.that, event.data.scripts);
});
};
};
if (event.intercepted) return event.returnValue;
return event.target.apply(event.that, event.data.scripts);
}
);
}
}
export default Workers;
export default Workers;

165
src/rewrite/codecs.js
View file

@ -3,15 +3,30 @@
// Do not use any browser or node-specific API!
// -------------------------------------------------------------
export const xor = {
encode(str){
encode(str) {
if (!str) return str;
return encodeURIComponent(str.toString().split('').map((char, ind) => ind % 2 ? String.fromCharCode(char.charCodeAt() ^ 2) : char).join(''));
return encodeURIComponent(
str
.toString()
.split('')
.map((char, ind) =>
ind % 2 ? String.fromCharCode(char.charCodeAt() ^ 2) : char
)
.join('')
);
},
decode(str){
decode(str) {
if (!str) return str;
let [ input, ...search ] = str.split('?');
let [input, ...search] = str.split('?');
return decodeURIComponent(input).split('').map((char, ind) => ind % 2 ? String.fromCharCode(char.charCodeAt(0) ^ 2) : char).join('') + (search.length ? '?' + search.join('?') : '');
return (
decodeURIComponent(input)
.split('')
.map((char, ind) =>
ind % 2 ? String.fromCharCode(char.charCodeAt(0) ^ 2) : char
)
.join('') + (search.length ? '?' + search.join('?') : '')
);
},
};
@ -27,48 +42,132 @@ export const plain = {
};
export const base64 = {
encode(str){
encode(str) {
if (!str) return str;
str = str.toString();
const b64chs = Array.from('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=');
const b64chs = Array.from(
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
);
let u32;
let c0;
let c1;
let c2;
let c0;
let c1;
let c2;
let asc = '';
let pad = str.length % 3;
for (let i = 0; i < str.length;) {
if((c0 = str.charCodeAt(i++)) > 255 || (c1 = str.charCodeAt(i++)) > 255 || (c2 = str.charCodeAt(i++)) > 255)throw new TypeError('invalid character found');
for (let i = 0; i < str.length; ) {
if (
(c0 = str.charCodeAt(i++)) > 255 ||
(c1 = str.charCodeAt(i++)) > 255 ||
(c2 = str.charCodeAt(i++)) > 255
)
throw new TypeError('invalid character found');
u32 = (c0 << 16) | (c1 << 8) | c2;
asc += b64chs[u32 >> 18 & 63]
+ b64chs[u32 >> 12 & 63]
+ b64chs[u32 >> 6 & 63]
+ b64chs[u32 & 63];
asc +=
b64chs[(u32 >> 18) & 63] +
b64chs[(u32 >> 12) & 63] +
b64chs[(u32 >> 6) & 63] +
b64chs[u32 & 63];
}
return encodeURIComponent(pad ? asc.slice(0, pad - 3) + '==='.substr(pad) : asc);
return encodeURIComponent(
pad ? asc.slice(0, pad - 3) + '==='.substr(pad) : asc
);
},
decode(str){
decode(str) {
if (!str) return str;
str = decodeURIComponent(str.toString());
const b64tab = {"0":52,"1":53,"2":54,"3":55,"4":56,"5":57,"6":58,"7":59,"8":60,"9":61,"A":0,"B":1,"C":2,"D":3,"E":4,"F":5,"G":6,"H":7,"I":8,"J":9,"K":10,"L":11,"M":12,"N":13,"O":14,"P":15,"Q":16,"R":17,"S":18,"T":19,"U":20,"V":21,"W":22,"X":23,"Y":24,"Z":25,"a":26,"b":27,"c":28,"d":29,"e":30,"f":31,"g":32,"h":33,"i":34,"j":35,"k":36,"l":37,"m":38,"n":39,"o":40,"p":41,"q":42,"r":43,"s":44,"t":45,"u":46,"v":47,"w":48,"x":49,"y":50,"z":51,"+":62,"/":63,"=":64};
str = str.replace(/\s+/g, '');
const b64tab = {
0: 52,
1: 53,
2: 54,
3: 55,
4: 56,
5: 57,
6: 58,
7: 59,
8: 60,
9: 61,
A: 0,
B: 1,
C: 2,
D: 3,
E: 4,
F: 5,
G: 6,
H: 7,
I: 8,
J: 9,
K: 10,
L: 11,
M: 12,
N: 13,
O: 14,
P: 15,
Q: 16,
R: 17,
S: 18,
T: 19,
U: 20,
V: 21,
W: 22,
X: 23,
Y: 24,
Z: 25,
a: 26,
b: 27,
c: 28,
d: 29,
e: 30,
f: 31,
g: 32,
h: 33,
i: 34,
j: 35,
k: 36,
l: 37,
m: 38,
n: 39,
o: 40,
p: 41,
q: 42,
r: 43,
s: 44,
t: 45,
u: 46,
v: 47,
w: 48,
x: 49,
y: 50,
z: 51,
'+': 62,
'/': 63,
'=': 64,
};
str = str.replace(/\s+/g, '');
str += '=='.slice(2 - (str.length & 3));
let u24;
let bin = '';
let r1;
let r2;
for (let i = 0; i < str.length;) {
u24 = b64tab[str.charAt(i++)] << 18
| b64tab[str.charAt(i++)] << 12
| (r1 = b64tab[str.charAt(i++)]) << 6
| (r2 = b64tab[str.charAt(i++)]);
bin += r1 === 64 ? String.fromCharCode(u24 >> 16 & 255)
: r2 === 64 ? String.fromCharCode(u24 >> 16 & 255, u24 >> 8 & 255)
: String.fromCharCode(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
};
for (let i = 0; i < str.length; ) {
u24 =
(b64tab[str.charAt(i++)] << 18) |
(b64tab[str.charAt(i++)] << 12) |
((r1 = b64tab[str.charAt(i++)]) << 6) |
(r2 = b64tab[str.charAt(i++)]);
bin +=
r1 === 64
? String.fromCharCode((u24 >> 16) & 255)
: r2 === 64
? String.fromCharCode((u24 >> 16) & 255, (u24 >> 8) & 255)
: String.fromCharCode(
(u24 >> 16) & 255,
(u24 >> 8) & 255,
u24 & 255
);
}
return bin;
},
};
};

43
src/rewrite/cookie.js
View file

@ -8,17 +8,16 @@ function validateCookie(cookie, meta, js = false) {
if (cookie.httpOnly && !!js) return false;
if (cookie.domain.startsWith('.')) {
if (!meta.url.hostname.endsWith(cookie.domain.slice(1))) return false;
return true;
};
}
if (cookie.domain !== meta.url.hostname) return false;
if (cookie.secure && meta.url.protocol === 'http:') return false;
if (!meta.url.pathname.startsWith(cookie.path)) return false;
return true;
};
}
async function db(openDB) {
const db = await openDB('__op', 1, {
@ -31,8 +30,7 @@ async function db(openDB) {
});
db.transaction(['cookies'], 'readwrite').store.index('path');
return db;
};
}
function serialize(cookies = [], meta, js) {
let str = '';
@ -40,56 +38,55 @@ function serialize(cookies = [], meta, js) {
if (!validateCookie(cookie, meta, js)) continue;
if (str.length) str += '; ';
str += cookie.name;
str += '='
str += '=';
str += cookie.value;
};
}
return str;
};
}
async function getCookies(db) {
const now = new Date();
return (await db.getAll('cookies')).filter(cookie => {
return (await db.getAll('cookies')).filter((cookie) => {
let expired = false;
if (cookie.set) {
if (cookie.maxAge) {
expired = (cookie.set.getTime() + (cookie.maxAge * 1e3)) < now;
expired = cookie.set.getTime() + cookie.maxAge * 1e3 < now;
} else if (cookie.expires) {
expired = new Date(cookie.expires.toLocaleString()) < now;
};
};
}
}
if (expired) {
db.delete('cookies', cookie.id);
return false;
};
}
return true;
return true;
});
};
}
function setCookies(data, db, meta) {
if (!db) return false;
const cookies = setCookie(data, {
decodeValues: false,
})
});
for (const cookie of cookies) {
if (!cookie.domain) cookie.domain = '.' + meta.url.hostname;
if (!cookie.path) cookie.path = '/';
if (!cookie.domain.startsWith('.')) {
cookie.domain = '.' + cookie.domain;
};
}
db.put('cookies', {
...cookie,
...cookie,
id: `${cookie.domain}@${cookie.path}@${cookie.name}`,
set: new Date(Date.now()),
});
};
}
return true;
};
}
export { validateCookie, getCookies, setCookies, db , serialize };
export { validateCookie, getCookies, setCookies, db, serialize };

29
src/rewrite/css.js
View file

@ -1,6 +1,6 @@
import { parse, walk, generate } from "css-tree";
import EventEmitter from "./events.js";
import parsel from "./parsel.js";
import { parse, walk, generate } from 'css-tree';
import EventEmitter from './events.js';
import parsel from './parsel.js';
class CSS extends EventEmitter {
constructor(ctx) {
@ -11,26 +11,29 @@ class CSS extends EventEmitter {
this.parse = parse;
this.walk = walk;
this.generate = generate;
};
}
rewrite(str, options) {
return this.recast(str, options, 'rewrite');
};
}
source(str, options) {
return this.recast(str, options, 'source');
};
}
recast(str, options, type) {
if (!str) return str;
str = new String(str).toString();
try {
const ast = this.parse(str, { ...options, parseCustomProperty: true });
this.walk(ast, node => {
const ast = this.parse(str, {
...options,
parseCustomProperty: true,
});
this.walk(ast, (node) => {
this.emit(node.type, node, options, type);
});
return this.generate(ast);
} catch(e) {
} catch (e) {
return str;
};
};
};
}
}
}
export default CSS;
export default CSS;

629
src/rewrite/events.js
View file

@ -21,37 +21,41 @@
'use strict';
var R = typeof Reflect === 'object' ? Reflect : null
var ReflectApply = R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}
var R = typeof Reflect === 'object' ? Reflect : null;
var ReflectApply =
R && typeof R.apply === 'function'
? R.apply
: function ReflectApply(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
};
var ReflectOwnKeys
var ReflectOwnKeys;
if (R && typeof R.ownKeys === 'function') {
ReflectOwnKeys = R.ownKeys
ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target)
.concat(Object.getOwnPropertySymbols(target));
};
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target).concat(
Object.getOwnPropertySymbols(target)
);
};
} else {
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
ReflectOwnKeys = function ReflectOwnKeys(target) {
return Object.getOwnPropertyNames(target);
};
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
if (console && console.warn) console.warn(warning);
}
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
return value !== value;
}
var NumberIsNaN =
Number.isNaN ||
function NumberIsNaN(value) {
return value !== value;
};
function EventEmitter() {
EventEmitter.init.call(this);
EventEmitter.init.call(this);
}
export default EventEmitter;
@ -68,430 +72,451 @@ EventEmitter.prototype._maxListeners = undefined;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== 'function') {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
if (typeof listener !== 'function') {
throw new TypeError(
'The "listener" argument must be of type Function. Received type ' +
typeof listener
);
}
}
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
enumerable: true,
get: function() {
return defaultMaxListeners;
},
set: function(arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
}
defaultMaxListeners = arg;
}
enumerable: true,
get: function () {
return defaultMaxListeners;
},
set: function (arg) {
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError(
'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' +
arg +
'.'
);
}
defaultMaxListeners = arg;
},
});
EventEmitter.init = function() {
EventEmitter.init = function () {
if (
this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events
) {
this._events = Object.create(null);
this._eventsCount = 0;
}
if (this._events === undefined ||
this._events === Object.getPrototypeOf(this)._events) {
this._events = Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || undefined;
this._maxListeners = this._maxListeners || undefined;
};
// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
}
this._maxListeners = n;
return this;
if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
throw new RangeError(
'The value of "n" is out of range. It must be a non-negative number. Received ' +
n +
'.'
);
}
this._maxListeners = n;
return this;
};
function _getMaxListeners(that) {
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
if (that._maxListeners === undefined)
return EventEmitter.defaultMaxListeners;
return that._maxListeners;
}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
return _getMaxListeners(this);
return _getMaxListeners(this);
};
EventEmitter.prototype.emit = function emit(type) {
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = (type === 'error');
var args = [];
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
var doError = type === 'error';
var events = this._events;
if (events !== undefined)
doError = (doError && events.error === undefined);
else if (!doError)
return false;
var events = this._events;
if (events !== undefined) doError = doError && events.error === undefined;
else if (!doError) return false;
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
// If there is no 'error' event listener then throw.
if (doError) {
var er;
if (args.length > 0) er = args[0];
if (er instanceof Error) {
// Note: The comments on the `throw` lines are intentional, they show
// up in Node's output if this results in an unhandled exception.
throw er; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error(
'Unhandled error.' + (er ? ' (' + er.message + ')' : '')
);
err.context = er;
throw err; // Unhandled 'error' event
}
// At least give some kind of context to the user
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
err.context = er;
throw err; // Unhandled 'error' event
}
var handler = events[type];
var handler = events[type];
if (handler === undefined)
return false;
if (handler === undefined) return false;
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i)
ReflectApply(listeners[i], this, args);
}
if (typeof handler === 'function') {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners = arrayClone(handler, len);
for (var i = 0; i < len; ++i) ReflectApply(listeners[i], this, args);
}
return true;
return true;
};
function _addListener(target, type, listener, prepend) {
var m;
var events;
var existing;
var m;
var events;
var existing;
checkListener(listener);
checkListener(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit('newListener', type,
listener.listener ? listener.listener : listener);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] =
prepend ? [listener, existing] : [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
events = target._events;
if (events === undefined) {
events = target._events = Object.create(null);
target._eventsCount = 0;
} else {
existing.push(listener);
// To avoid recursion in the case that type === "newListener"! Before
// adding it to the listeners, first emit "newListener".
if (events.newListener !== undefined) {
target.emit(
'newListener',
type,
listener.listener ? listener.listener : listener
);
// Re-assign `events` because a newListener handler could have caused the
// this._events to be assigned to a new object
events = target._events;
}
existing = events[type];
}
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error('Possible EventEmitter memory leak detected. ' +
existing.length + ' ' + String(type) + ' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit');
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
if (existing === undefined) {
// Optimize the case of one listener. Don't need the extra array object.
existing = events[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === 'function') {
// Adding the second element, need to change to array.
existing = events[type] = prepend
? [listener, existing]
: [existing, listener];
// If we've already got an array, just append.
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
return target;
// Check for listener leak
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
// No error code for this since it is a Warning
// eslint-disable-next-line no-restricted-syntax
var w = new Error(
'Possible EventEmitter memory leak detected. ' +
existing.length +
' ' +
String(type) +
' listeners ' +
'added. Use emitter.setMaxListeners() to ' +
'increase limit'
);
w.name = 'MaxListenersExceededWarning';
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
EventEmitter.prototype.addListener = function addListener(type, listener) {
return _addListener(this, type, listener, false);
return _addListener(this, type, listener, false);
};
EventEmitter.prototype.on = EventEmitter.prototype.addListener;
EventEmitter.prototype.prependListener =
function prependListener(type, listener) {
return _addListener(this, type, listener, true);
};
EventEmitter.prototype.prependListener = function prependListener(
type,
listener
) {
return _addListener(this, type, listener, true);
};
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0) return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
function _onceWrap(target, type, listener) {
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
var state = {
fired: false,
wrapFn: undefined,
target: target,
type: type,
listener: listener,
};
var wrapped = onceWrapper.bind(state);
wrapped.listener = listener;
state.wrapFn = wrapped;
return wrapped;
}
EventEmitter.prototype.once = function once(type, listener) {
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
checkListener(listener);
this.on(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener =
function prependOnceListener(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
EventEmitter.prototype.prependOnceListener = function prependOnceListener(
type,
listener
) {
checkListener(listener);
this.prependListener(type, _onceWrap(this, type, listener));
return this;
};
// Emits a 'removeListener' event if and only if the listener was removed.
EventEmitter.prototype.removeListener =
function removeListener(type, listener) {
var list, events, position, i, originalListener;
EventEmitter.prototype.removeListener = function removeListener(
type,
listener
) {
var list, events, position, i, originalListener;
checkListener(listener);
checkListener(listener);
events = this._events;
if (events === undefined)
return this;
events = this._events;
if (events === undefined) return this;
list = events[type];
if (list === undefined)
return this;
list = events[type];
if (list === undefined) return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0) this._events = Object.create(null);
else {
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
delete events[type];
if (events.removeListener)
this.emit('removeListener', type, list.listener || listener);
}
} else if (typeof list !== 'function') {
} else if (typeof list !== 'function') {
position = -1;
for (i = list.length - 1; i >= 0; i--) {
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
if (list[i] === listener || list[i].listener === listener) {
originalListener = list[i].listener;
position = i;
break;
}
}
if (position < 0)
return this;
if (position < 0) return this;
if (position === 0)
list.shift();
if (position === 0) list.shift();
else {
spliceOne(list, position);
spliceOne(list, position);
}
if (list.length === 1)
events[type] = list[0];
if (list.length === 1) events[type] = list[0];
if (events.removeListener !== undefined)
this.emit('removeListener', type, originalListener || listener);
}
this.emit('removeListener', type, originalListener || listener);
}
return this;
};
return this;
};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners =
function removeAllListeners(type) {
var listeners, events, i;
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
var listeners, events, i;
events = this._events;
if (events === undefined)
return this;
events = this._events;
if (events === undefined) return this;
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
// not listening for removeListener, no need to emit
if (events.removeListener === undefined) {
if (arguments.length === 0) {
this._events = Object.create(null);
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0)
this._events = Object.create(null);
else
delete events[type];
this._eventsCount = 0;
} else if (events[type] !== undefined) {
if (--this._eventsCount === 0) this._events = Object.create(null);
else delete events[type];
}
return this;
}
}
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
// emit removeListener for all listeners on all events
if (arguments.length === 0) {
var keys = Object.keys(events);
var key;
for (i = 0; i < keys.length; ++i) {
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
key = keys[i];
if (key === 'removeListener') continue;
this.removeAllListeners(key);
}
this.removeAllListeners('removeListener');
this._events = Object.create(null);
this._eventsCount = 0;
return this;
}
}
listeners = events[type];
listeners = events[type];
if (typeof listeners === 'function') {
if (typeof listeners === 'function') {
this.removeListener(type, listeners);
} else if (listeners !== undefined) {
} else if (listeners !== undefined) {
// LIFO order
for (i = listeners.length - 1; i >= 0; i--) {
this.removeListener(type, listeners[i]);
this.removeListener(type, listeners[i]);
}
}
}
return this;
};
return this;
};
function _listeners(target, type, unwrap) {
var events = target._events;
var events = target._events;
if (events === undefined)
return [];
if (events === undefined) return [];
var evlistener = events[type];
if (evlistener === undefined)
return [];
var evlistener = events[type];
if (evlistener === undefined) return [];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
if (typeof evlistener === 'function')
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ?
unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
return unwrap
? unwrapListeners(evlistener)
: arrayClone(evlistener, evlistener.length);
}
EventEmitter.prototype.listeners = function listeners(type) {
return _listeners(this, type, true);
return _listeners(this, type, true);
};
EventEmitter.prototype.rawListeners = function rawListeners(type) {
return _listeners(this, type, false);
return _listeners(this, type, false);
};
EventEmitter.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
EventEmitter.listenerCount = function (emitter, type) {
if (typeof emitter.listenerCount === 'function') {
return emitter.listenerCount(type);
} else {
return listenerCount.call(emitter, type);
}
};
EventEmitter.prototype.listenerCount = listenerCount;
function listenerCount(type) {
var events = this._events;
var events = this._events;
if (events !== undefined) {
var evlistener = events[type];
if (events !== undefined) {
var evlistener = events[type];
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
if (typeof evlistener === 'function') {
return 1;
} else if (evlistener !== undefined) {
return evlistener.length;
}
}
}
return 0;
return 0;
}
EventEmitter.prototype.eventNames = function eventNames() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
};
function arrayClone(arr, n) {
var copy = new Array(n);
for (var i = 0; i < n; ++i)
copy[i] = arr[i];
return copy;
var copy = new Array(n);
for (var i = 0; i < n; ++i) copy[i] = arr[i];
return copy;
}
function spliceOne(list, index) {
for (; index + 1 < list.length; index++)
list[index] = list[index + 1];
list.pop();
for (; index + 1 < list.length; index++) list[index] = list[index + 1];
list.pop();
}
function unwrapListeners(arr) {
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
var ret = new Array(arr.length);
for (var i = 0; i < ret.length; ++i) {
ret[i] = arr[i].listener || arr[i];
}
return ret;
}
function once(emitter, name) {
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
return new Promise(function (resolve, reject) {
function errorListener(err) {
emitter.removeListener(name, resolver);
reject(err);
}
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
};
function resolver() {
if (typeof emitter.removeListener === 'function') {
emitter.removeListener('error', errorListener);
}
resolve([].slice.call(arguments));
}
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== 'error') {
addErrorHandlerIfEventEmitter(emitter, errorListener, {
once: true,
});
}
});
}
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
if (typeof emitter.on === 'function') {
eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
}
}
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
if (typeof emitter.on === 'function') {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
emitter.on(name, listener);
throw new TypeError(
'The "emitter" argument must be of type EventEmitter. Received type ' +
typeof emitter
);
}
} else if (typeof emitter.addEventListener === 'function') {
// EventTarget does not have `error` event semantics like Node
// EventEmitters, we do not listen for `error` events here.
emitter.addEventListener(name, function wrapListener(arg) {
// IE does not have builtin `{ once: true }` support so we
// have to do it manually.
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
});
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
}

251
src/rewrite/html.js
View file

@ -7,75 +7,101 @@ class HTML extends EventEmitter {
this.ctx = ctx;
this.rewriteUrl = ctx.rewriteUrl;
this.sourceUrl = ctx.sourceUrl;
};
}
rewrite(str, options = {}) {
if (!str) return str;
return this.recast(str, node => {
if (node.tagName) this.emit('element', node, 'rewrite');
if (node.attr) this.emit('attr', node, 'rewrite');
if (node.nodeName === '#text') this.emit('text', node, 'rewrite');
}, options)
};
return this.recast(
str,
(node) => {
if (node.tagName) this.emit('element', node, 'rewrite');
if (node.attr) this.emit('attr', node, 'rewrite');
if (node.nodeName === '#text')
this.emit('text', node, 'rewrite');
},
options
);
}
source(str, options = {}) {
if (!str) return str;
return this.recast(str, node => {
if (node.tagName) this.emit('element', node, 'source');
if (node.attr) this.emit('attr', node, 'source');
if (node.nodeName === '#text') this.emit('text', node, 'source');
}, options)
};
return this.recast(
str,
(node) => {
if (node.tagName) this.emit('element', node, 'source');
if (node.attr) this.emit('attr', node, 'source');
if (node.nodeName === '#text')
this.emit('text', node, 'source');
},
options
);
}
recast(str, fn, options = {}) {
try {
const ast = (options.document ? parse : parseFragment)(new String(str).toString());
const ast = (options.document ? parse : parseFragment)(
new String(str).toString()
);
this.iterate(ast, fn, options);
return serialize(ast);
} catch(e) {
} catch (e) {
return str;
};
};
}
}
iterate(ast, fn, fnOptions) {
if (!ast) return ast;
if (ast.tagName) {
const element = new P5Element(ast, false, fnOptions);
fn(element);
if (ast.attrs) {
for (const attr of ast.attrs) {
if (!attr.skip) fn(new AttributeEvent(element, attr, fnOptions));
};
};
};
if (!attr.skip)
fn(new AttributeEvent(element, attr, fnOptions));
}
}
}
if (ast.childNodes) {
for (const child of ast.childNodes) {
if (!child.skip) this.iterate(child, fn, fnOptions);
};
};
}
}
if (ast.nodeName === '#text') {
fn(new TextEvent(ast, new P5Element(ast.parentNode), false, fnOptions));
};
fn(
new TextEvent(
ast,
new P5Element(ast.parentNode),
false,
fnOptions
)
);
}
return ast;
};
}
wrapSrcset(str, meta = this.ctx.meta) {
return str.split(',').map(src => {
const parts = src.trimStart().split(' ');
if (parts[0]) parts[0] = this.ctx.rewriteUrl(parts[0], meta);
return parts.join(' ');
}).join(', ');
};
return str
.split(',')
.map((src) => {
const parts = src.trimStart().split(' ');
if (parts[0]) parts[0] = this.ctx.rewriteUrl(parts[0], meta);
return parts.join(' ');
})
.join(', ');
}
unwrapSrcset(str, meta = this.ctx.meta) {
return str.split(',').map(src => {
const parts = src.trimStart().split(' ');
if (parts[0]) parts[0] = this.ctx.sourceUrl(parts[0], meta);
return parts.join(' ');
}).join(', ');
};
return str
.split(',')
.map((src) => {
const parts = src.trimStart().split(' ');
if (parts[0]) parts[0] = this.ctx.sourceUrl(parts[0], meta);
return parts.join(' ');
})
.join(', ');
}
static parse = parse;
static parseFragment = parseFragment;
static serialize = serialize;
};
static serialize = serialize;
}
class P5Element extends EventEmitter {
constructor(node, stream = false, options = {}) {
@ -83,96 +109,104 @@ class P5Element extends EventEmitter {
this.stream = stream;
this.node = node;
this.options = options;
};
}
setAttribute(name, value) {
for (const attr of this.attrs) {
if (attr.name === name) {
attr.value = value;
return true;
};
};
this.attrs.push(
{
name,
value,
}
);
};
}
this.attrs.push({
name,
value,
});
}
getAttribute(name) {
const attr = this.attrs.find(attr => attr.name === name) || {};
const attr = this.attrs.find((attr) => attr.name === name) || {};
return attr.value;
};
}
hasAttribute(name) {
return !!this.attrs.find(attr => attr.name === name);
};
return !!this.attrs.find((attr) => attr.name === name);
}
removeAttribute(name) {
const i = this.attrs.findIndex(attr => attr.name === name);
const i = this.attrs.findIndex((attr) => attr.name === name);
if (typeof i !== 'undefined') this.attrs.splice(i, 1);
};
}
get tagName() {
return this.node.tagName;
};
}
set tagName(val) {
this.node.tagName = val;
};
}
get childNodes() {
return !this.stream ? this.node.childNodes : null;
};
}
get innerHTML() {
return !this.stream ? serialize(
{
nodeName: '#document-fragment',
childNodes: this.childNodes,
}
) : null;
};
return !this.stream
? serialize({
nodeName: '#document-fragment',
childNodes: this.childNodes,
})
: null;
}
set innerHTML(val) {
if (!this.stream) this.node.childNodes = parseFragment(val).childNodes;
};
}
get outerHTML() {
return !this.stream ? serialize(
{
nodeName: '#document-fragment',
childNodes: [ this ],
}
) : null;
};
return !this.stream
? serialize({
nodeName: '#document-fragment',
childNodes: [this],
})
: null;
}
set outerHTML(val) {
if (!this.stream) this.parentNode.childNodes.splice(this.parentNode.childNodes.findIndex(node => node === this.node), 1, ...parseFragment(val).childNodes);
};
if (!this.stream)
this.parentNode.childNodes.splice(
this.parentNode.childNodes.findIndex(
(node) => node === this.node
),
1,
...parseFragment(val).childNodes
);
}
get textContent() {
if (this.stream) return null;
let str = '';
iterate(this.node, node => {
iterate(this.node, (node) => {
if (node.nodeName === '#text') str += node.value;
});
return str;
};
}
set textContent(val) {
if (!this.stream) this.node.childNodes = [
{
nodeName: '#text',
value: val,
parentNode: this.node
}
];
};
if (!this.stream)
this.node.childNodes = [
{
nodeName: '#text',
value: val,
parentNode: this.node,
},
];
}
get nodeName() {
return this.node.nodeName;
}
}
get parentNode() {
return this.node.parentNode ? new P5Element(this.node.parentNode) : null;
};
return this.node.parentNode
? new P5Element(this.node.parentNode)
: null;
}
get attrs() {
return this.node.attrs;
}
get namespaceURI() {
return this.node.namespaceURI;
}
};
}
class AttributeEvent {
constructor(node, attr, options = {}) {
@ -180,9 +214,9 @@ class AttributeEvent {
this.attrs = node.attrs;
this.node = node;
this.options = options;
};
}
delete() {
const i = this.attrs.findIndex(attr => attr === this.attr);
const i = this.attrs.findIndex((attr) => attr === this.attr);
this.attrs.splice(i, 1);
@ -191,25 +225,25 @@ class AttributeEvent {
});
return true;
};
}
get name() {
return this.attr.name;
};
}
set name(val) {
this.attr.name = val;
};
}
get value() {
return this.attr.value;
};
}
set value(val) {
this.attr.value = val;
};
}
get deleted() {
return false;
};
};
}
}
class TextEvent {
constructor(node, element, stream = false, options = {}) {
@ -217,21 +251,20 @@ class TextEvent {
this.node = node;
this.element = element;
this.options = options;
};
}
get nodeName() {
return this.node.nodeName;
}
}
get parentNode() {
return this.element;
};
}
get value() {
return this.stream ? this.node.text : this.node.value;
};
}
set value(val) {
if (this.stream) this.node.text = val;
else this.node.value = val;
};
};
}
}
export default HTML;
export default HTML;

137
src/rewrite/index.js
View file

@ -4,30 +4,53 @@ import JS from './js.js';
import setCookie from 'set-cookie-parser';
import { xor, base64, plain } from './codecs.js';
import mimeTypes from './mime.js';
import { validateCookie, db, getCookies, setCookies, serialize } from './cookie.js';
import { attributes, isUrl, isForbidden, isHtml, isSrcset, isStyle, text, injectHead, createInjection } from './rewrite.html.js';
import {
validateCookie,
db,
getCookies,
setCookies,
serialize,
} from './cookie.js';
import {
attributes,
isUrl,
isForbidden,
isHtml,
isSrcset,
isStyle,
text,
injectHead,
createInjection,
} from './rewrite.html.js';
import { importStyle, url } from './rewrite.css.js';
//import { call, destructureDeclaration, dynamicImport, getProperty, importDeclaration, setProperty, sourceMethods, wrapEval, wrapIdentifier } from './rewrite.script.js';
import { dynamicImport, identifier, importDeclaration, property, unwrap, wrapEval } from './rewrite.script.js';
import { openDB } from 'idb';
import {
dynamicImport,
identifier,
importDeclaration,
property,
unwrap,
wrapEval,
} from './rewrite.script.js';
import { openDB } from 'idb';
import parsel from './parsel.js';
import UVClient from '../client/index.js';
import Bowser from 'bowser';
const valid_chars = "!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~";
const reserved_chars = "%";
const valid_chars =
"!#$%&'*+-.0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ^_`abcdefghijklmnopqrstuvwxyz|~";
const reserved_chars = '%';
class Ultraviolet {
constructor(options = {}) {
this.prefix = options.prefix || '/service/';
//this.urlRegex = /^(#|about:|data:|mailto:|javascript:)/;
this.urlRegex = /^(#|about:|data:|mailto:)/
this.urlRegex = /^(#|about:|data:|mailto:)/;
this.rewriteUrl = options.rewriteUrl || this.rewriteUrl;
this.sourceUrl = options.sourceUrl || this.sourceUrl;
this.encodeUrl = options.encodeUrl || this.encodeUrl;
this.decodeUrl = options.decodeUrl || this.decodeUrl;
this.vanilla = 'vanilla' in options ? options.vanilla : false;
this.vanilla = 'vanilla' in options ? options.vanilla : false;
this.meta = options.meta || {};
this.meta.base ||= undefined;
this.meta.origin ||= '';
@ -42,7 +65,10 @@ class Ultraviolet {
this.parsel = parsel;
this.openDB = this.constructor.openDB;
this.Bowser = this.constructor.Bowser;
this.client = typeof self !== 'undefined' ? new UVClient((options.window || self)) : null;
this.client =
typeof self !== 'undefined'
? new UVClient(options.window || self)
: null;
this.master = '__uv';
this.dataPrefix = '__uv$';
this.attributePrefix = '__uv';
@ -65,75 +91,86 @@ class Ultraviolet {
serialize,
setCookie,
};
};
}
rewriteUrl(str, meta = this.meta) {
str = new String(str).trim();
if (!str || this.urlRegex.test(str)) return str;
if (str.startsWith('javascript:')) {
return 'javascript:' + this.js.rewrite(str.slice('javascript:'.length));
};
return (
'javascript:' + this.js.rewrite(str.slice('javascript:'.length))
);
}
try {
return meta.origin + this.prefix + this.encodeUrl(new URL(str, meta.base).href);
} catch(e) {
return (
meta.origin +
this.prefix +
this.encodeUrl(new URL(str, meta.base).href)
);
} catch (e) {
return meta.origin + this.prefix + this.encodeUrl(str);
};
};
}
}
sourceUrl(str, meta = this.meta) {
if (!str || this.urlRegex.test(str)) return str;
try {
return new URL(
this.decodeUrl(str.slice(this.prefix.length + meta.origin.length)),
this.decodeUrl(
str.slice(this.prefix.length + meta.origin.length)
),
meta.base
).href;
} catch(e) {
return this.decodeUrl(str.slice(this.prefix.length + meta.origin.length));
};
};
} catch (e) {
return this.decodeUrl(
str.slice(this.prefix.length + meta.origin.length)
);
}
}
encodeUrl(str) {
return encodeURIComponent(str);
};
}
decodeUrl(str) {
return decodeURIComponent(str);
};
}
encodeProtocol(protocol) {
protocol = protocol.toString();
let result = '';
for(let i = 0; i < protocol.length; i++){
for (let i = 0; i < protocol.length; i++) {
const char = protocol[i];
if(valid_chars.includes(char) && !reserved_chars.includes(char)){
if (valid_chars.includes(char) && !reserved_chars.includes(char)) {
result += char;
}else{
} else {
const code = char.charCodeAt();
result += '%' + code.toString(16).padStart(2, 0);
}
}
return result;
};
}
decodeProtocol(protocol) {
if(typeof protocol != 'string')throw new TypeError('protocol must be a string');
if (typeof protocol != 'string')
throw new TypeError('protocol must be a string');
let result = '';
for(let i = 0; i < protocol.length; i++){
for (let i = 0; i < protocol.length; i++) {
const char = protocol[i];
if(char == '%'){
if (char == '%') {
const code = parseInt(protocol.slice(i + 1, i + 3), 16);
const decoded = String.fromCharCode(code);
result += decoded;
i += 2;
}else{
} else {
result += char;
}
}
return result;
}
implementUVMiddleware() {
@ -151,31 +188,31 @@ class Ultraviolet {
wrapEval(this);
identifier(this);
unwrap(this);
};
}
get rewriteHtml() {
return this.html.rewrite.bind(this.html);
};
}
get sourceHtml() {
return this.html.source.bind(this.html);
};
}
get rewriteCSS() {
return this.css.rewrite.bind(this.css);
};
}
get sourceCSS() {
return this.css.source.bind(this.css);
};
}
get rewriteJS() {
return this.js.rewrite.bind(this.js);
};
}
get sourceJS() {
return this.js.source.bind(this.js);
};
}
static codec = { xor, base64, plain };
static mime = mimeTypes;
static setCookie = setCookie;
static openDB = openDB;
static Bowser = Bowser;
};
}
export default Ultraviolet;
if (typeof self === 'object') self.Ultraviolet = Ultraviolet;
if (typeof self === 'object') self.Ultraviolet = Ultraviolet;

45
src/rewrite/js.js
View file

@ -27,13 +27,13 @@ class JS extends EventEmitter {
};
this.parse = parseScript /*parse*/;
this.generate = generate;
};
}
rewrite(str, data = {}) {
return this.recast(str, data, 'rewrite');
};
}
source(str, data = {}) {
return this.recast(str, data, 'source');
};
}
recast(str, data = {}, type = '') {
try {
const output = [];
@ -56,19 +56,26 @@ class JS extends EventEmitter {
this.emit(node.type, node, meta, type);
});
meta.changes.sort((a, b) => (a.start - b.start) || (a.end - b.end));
meta.changes.sort((a, b) => a.start - b.start || a.end - b.end);
for (const change of meta.changes) {
if ('start' in change && typeof change.start === 'number') output.push(str.slice(slice, change.start));
if (change.node) output.push(typeof change.node === 'string' ? change.node : generate(change.node, this.generationOptions));
if ('end' in change && typeof change.end === 'number') slice = change.end;
};
if ('start' in change && typeof change.start === 'number')
output.push(str.slice(slice, change.start));
if (change.node)
output.push(
typeof change.node === 'string'
? change.node
: generate(change.node, this.generationOptions)
);
if ('end' in change && typeof change.end === 'number')
slice = change.end;
}
output.push(str.slice(slice));
return output.join('');
} catch(e) {
} catch (e) {
return str;
};
};
}
}
iterate(ast, handler) {
if (typeof ast != 'object' || !handler) return;
walk(ast, null, handler);
@ -78,16 +85,16 @@ class JS extends EventEmitter {
for (const child in node) {
if (child === 'parent') continue;
if (Array.isArray(node[child])) {
node[child].forEach(entry => {
if (entry) walk(entry, node, handler)
node[child].forEach((entry) => {
if (entry) walk(entry, node, handler);
});
} else {
if (node[child]) walk(node[child], node, handler);
};
};
}
}
if (typeof node.iterateEnd === 'function') node.iterateEnd();
};
};
};
}
}
}
export default JS;
export default JS;

206
src/rewrite/mime.js
View file

@ -5,18 +5,18 @@
* MIT Licensed
*/
'use strict'
'use strict';
/**
* Module dependencies.
* @private
*/
var $exports = {}
import db from "mime-db";
var $exports = {};
var extname = function(path = '') {
import db from 'mime-db';
var extname = function (path = '') {
if (!path.includes('.')) return '';
const map = path.split('.');
@ -28,24 +28,24 @@ var extname = function(path = '') {
* @private
*/
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
var TEXT_TYPE_REGEXP = /^text\//i
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
var TEXT_TYPE_REGEXP = /^text\//i;
/**
* Module exports.
* @public
*/
$exports.charset = charset
$exports.charsets = { lookup: charset }
$exports.contentType = contentType
$exports.extension = extension
$exports.extensions = Object.create(null)
$exports.lookup = lookup
$exports.types = Object.create(null)
$exports.charset = charset;
$exports.charsets = { lookup: charset };
$exports.contentType = contentType;
$exports.extension = extension;
$exports.extensions = Object.create(null);
$exports.lookup = lookup;
$exports.types = Object.create(null);
// Populate the extensions/types maps
populateMaps($exports.extensions, $exports.types)
populateMaps($exports.extensions, $exports.types);
/**
* Get the default charset for a MIME type.
@ -54,25 +54,25 @@ populateMaps($exports.extensions, $exports.types)
* @return {boolean|string}
*/
function charset (type) {
if (!type || typeof type !== 'string') {
return false
}
function charset(type) {
if (!type || typeof type !== 'string') {
return false;
}
// TODO: use media-typer
var match = EXTRACT_TYPE_REGEXP.exec(type)
var mime = match && db[match[1].toLowerCase()]
// TODO: use media-typer
var match = EXTRACT_TYPE_REGEXP.exec(type);
var mime = match && db[match[1].toLowerCase()];
if (mime && mime.charset) {
return mime.charset
}
if (mime && mime.charset) {
return mime.charset;
}
// default text/* to utf-8
if (match && TEXT_TYPE_REGEXP.test(match[1])) {
return 'UTF-8'
}
// default text/* to utf-8
if (match && TEXT_TYPE_REGEXP.test(match[1])) {
return 'UTF-8';
}
return false
return false;
}
/**
@ -82,27 +82,25 @@ function charset (type) {
* @return {boolean|string}
*/
function contentType (str) {
// TODO: should this even be in this module?
if (!str || typeof str !== 'string') {
return false
}
function contentType(str) {
// TODO: should this even be in this module?
if (!str || typeof str !== 'string') {
return false;
}
var mime = str.indexOf('/') === -1
? $exports.lookup(str)
: str
var mime = str.indexOf('/') === -1 ? $exports.lookup(str) : str;
if (!mime) {
return false
}
if (!mime) {
return false;
}
// TODO: use content-type or other module
if (mime.indexOf('charset') === -1) {
var charset = $exports.charset(mime)
if (charset) mime += '; charset=' + charset.toLowerCase()
}
// TODO: use content-type or other module
if (mime.indexOf('charset') === -1) {
var charset = $exports.charset(mime);
if (charset) mime += '; charset=' + charset.toLowerCase();
}
return mime
return mime;
}
/**
@ -112,22 +110,22 @@ function contentType (str) {
* @return {boolean|string}
*/
function extension (type) {
if (!type || typeof type !== 'string') {
return false
}
function extension(type) {
if (!type || typeof type !== 'string') {
return false;
}
// TODO: use media-typer
var match = EXTRACT_TYPE_REGEXP.exec(type)
// TODO: use media-typer
var match = EXTRACT_TYPE_REGEXP.exec(type);
// get extensions
var exts = match && $exports.extensions[match[1].toLowerCase()]
// get extensions
var exts = match && $exports.extensions[match[1].toLowerCase()];
if (!exts || !exts.length) {
return false
}
if (!exts || !exts.length) {
return false;
}
return exts[0]
return exts[0];
}
/**
@ -137,21 +135,21 @@ function extension (type) {
* @return {boolean|string}
*/
function lookup (path) {
if (!path || typeof path !== 'string') {
return false
}
function lookup(path) {
if (!path || typeof path !== 'string') {
return false;
}
// get the extension ("ext" or ".ext" or full path)
var extension = extname('x.' + path)
.toLowerCase()
.substr(1)
// get the extension ("ext" or ".ext" or full path)
var extension = extname('x.' + path)
.toLowerCase()
.substr(1);
if (!extension) {
return false
}
if (!extension) {
return false;
}
return $exports.types[extension] || false
return $exports.types[extension] || false;
}
/**
@ -159,40 +157,44 @@ function lookup (path) {
* @private
*/
function populateMaps (extensions, types) {
// source preference (least -> most)
var preference = ['nginx', 'apache', undefined, 'iana']
function populateMaps(extensions, types) {
// source preference (least -> most)
var preference = ['nginx', 'apache', undefined, 'iana'];
Object.keys(db).forEach(function forEachMimeType (type) {
var mime = db[type]
var exts = mime.extensions
Object.keys(db).forEach(function forEachMimeType(type) {
var mime = db[type];
var exts = mime.extensions;
if (!exts || !exts.length) {
return
}
// mime -> extensions
extensions[type] = exts
// extension -> mime
for (var i = 0; i < exts.length; i++) {
var extension = exts[i]
if (types[extension]) {
var from = preference.indexOf(db[types[extension]].source)
var to = preference.indexOf(mime.source)
if (types[extension] !== 'application/octet-stream' &&
(from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
// skip the remapping
continue
if (!exts || !exts.length) {
return;
}
}
// set the extension -> mime
types[extension] = type
}
})
// mime -> extensions
extensions[type] = exts;
// extension -> mime
for (var i = 0; i < exts.length; i++) {
var extension = exts[i];
if (types[extension]) {
var from = preference.indexOf(db[types[extension]].source);
var to = preference.indexOf(mime.source);
if (
types[extension] !== 'application/octet-stream' &&
(from > to ||
(from === to &&
types[extension].substr(0, 12) === 'application/'))
) {
// skip the remapping
continue;
}
}
// set the extension -> mime
types[extension] = type;
}
});
}
export default $exports;
export default $exports;

815
src/rewrite/parsel.js
View file

@ -1,382 +1,435 @@
export default (function (exports) {
'use strict';
const TOKENS = {
attribute: /\[\s*(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(?<caseSensitive>[iIsS])?\s*)?\]/gu,
id: /#(?<name>(?:[-\w\u{0080}-\u{FFFF}]|\\.)+)/gu,
class: /\.(?<name>(?:[-\w\u{0080}-\u{FFFF}]|\\.)+)/gu,
comma: /\s*,\s*/g, // must be before combinator
combinator: /\s*[\s>+~]\s*/g, // this must be after attribute
"pseudo-element": /::(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu, // this must be before pseudo-class
"pseudo-class": /:(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu,
type: /(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)|\*/gu // this must be last
};
const TOKENS_WITH_PARENS = new Set(["pseudo-class", "pseudo-element"]);
const TOKENS_WITH_STRINGS = new Set([...TOKENS_WITH_PARENS, "attribute"]);
const TRIM_TOKENS = new Set(["combinator", "comma"]);
const RECURSIVE_PSEUDO_CLASSES = new Set(["not", "is", "where", "has", "matches", "-moz-any", "-webkit-any", "nth-child", "nth-last-child"]);
const RECURSIVE_PSEUDO_CLASSES_ARGS = {
"nth-child": /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/
};
RECURSIVE_PSEUDO_CLASSES["nth-last-child"] = RECURSIVE_PSEUDO_CLASSES_ARGS["nth-child"];
const TOKENS_FOR_RESTORE = Object.assign({}, TOKENS);
TOKENS_FOR_RESTORE["pseudo-element"] = RegExp(TOKENS["pseudo-element"].source.replace("(?<argument>¶+)", "(?<argument>.+?)"), "gu");
TOKENS_FOR_RESTORE["pseudo-class"] = RegExp(TOKENS["pseudo-class"].source.replace("(?<argument>¶+)", "(?<argument>.+)"), "gu");
function gobbleParens(text, i) {
let str = "", stack = [];
for (; i < text.length; i++) {
let char = text[i];
if (char === "(") {
stack.push(char);
}
else if (char === ")") {
if (stack.length > 0) {
stack.pop();
}
else {
throw new Error("Closing paren without opening paren at " + i);
}
}
str += char;
if (stack.length === 0) {
return str;
}
}
throw new Error("Opening paren without closing paren");
}
function tokenizeBy (text, grammar) {
if (!text) {
return [];
}
var strarr = [text];
for (var token in grammar) {
let pattern = grammar[token];
for (var i=0; i < strarr.length; i++) { // Don’t cache length as it changes during the loop
var str = strarr[i];
if (typeof str === "string") {
pattern.lastIndex = 0;
var match = pattern.exec(str);
if (match) {
let from = match.index - 1;
let args = [];
let content = match[0];
let before = str.slice(0, from + 1);
if (before) {
args.push(before);
}
args.push({
type: token,
content,
...match.groups
});
let after = str.slice(from + content.length + 1);
if (after) {
args.push(after);
}
strarr.splice(i, 1, ...args);
}
}
}
}
let offset = 0;
for (let i=0; i<strarr.length; i++) {
let token = strarr[i];
let length = token.length || token.content.length;
if (typeof token === "object") {
token.pos = [offset, offset + length];
if (TRIM_TOKENS.has(token.type)) {
token.content = token.content.trim() || " ";
}
}
offset += length;
}
return strarr;
}
function tokenize (selector) {
if (!selector) {
return null;
}
selector = selector.trim(); // prevent leading/trailing whitespace be interpreted as combinators
// Replace strings with whitespace strings (to preserve offsets)
let strings = [];
// FIXME Does not account for escaped backslashes before a quote
selector = selector.replace(/(['"])(\\\1|.)+?\1/g, (str, quote, content, start) => {
strings.push({str, start});
return quote + "§".repeat(content.length) + quote;
});
// Now that strings are out of the way, extract parens and replace them with parens with whitespace (to preserve offsets)
let parens = [], offset = 0, start;
while ((start = selector.indexOf("(", offset)) > -1) {
let str = gobbleParens(selector, start);
parens.push({str, start});
selector = selector.substring(0, start) + "(" + "¶".repeat(str.length - 2) + ")" + selector.substring(start + str.length);
offset = start + str.length;
}
// Now we have no nested structures and we can parse with regexes
let tokens = tokenizeBy(selector, TOKENS);
// Now restore parens and strings in reverse order
function restoreNested(strings, regex, types) {
for (let str of strings) {
for (let token of tokens) {
if (types.has(token.type) && token.pos[0] < str.start && str.start < token.pos[1]) {
let content = token.content;
token.content = token.content.replace(regex, str.str);
if (token.content !== content) { // actually changed?
// Re-evaluate groups
TOKENS_FOR_RESTORE[token.type].lastIndex = 0;
let match = TOKENS_FOR_RESTORE[token.type].exec(token.content);
let groups = match.groups;
Object.assign(token, groups);
}
}
}
}
}
restoreNested(parens, /\(¶+\)/, TOKENS_WITH_PARENS);
restoreNested(strings, /(['"])§+?\1/, TOKENS_WITH_STRINGS);
return tokens;
}
// Convert a flat list of tokens into a tree of complex & compound selectors
function nestTokens(tokens, {list = true} = {}) {
if (list && tokens.find(t => t.type === "comma")) {
let selectors = [], temp = [];
for (let i=0; i<tokens.length; i++) {
if (tokens[i].type === "comma") {
if (temp.length === 0) {
throw new Error("Incorrect comma at " + i);
}
selectors.push(nestTokens(temp, {list: false}));
temp.length = 0;
}
else {
temp.push(tokens[i]);
}
}
if (temp.length === 0) {
throw new Error("Trailing comma");
}
else {
selectors.push(nestTokens(temp, {list: false}));
}
return { type: "list", list: selectors };
}
for (let i=tokens.length - 1; i>=0; i--) {
let token = tokens[i];
if (token.type === "combinator") {
let left = tokens.slice(0, i);
let right = tokens.slice(i + 1);
return {
type: "complex",
combinator: token.content,
left: nestTokens(left),
right: nestTokens(right)
};
}
}
if (tokens.length === 0) {
return null;
}
// If we're here, there are no combinators, so it's just a list
return tokens.length === 1? tokens[0] : {
type: "compound",
list: [...tokens] // clone to avoid pointers messing up the AST
};
}
// Traverse an AST (or part thereof), in depth-first order
function walk(node, callback, o, parent) {
if (!node) {
return;
}
if (node.type === "complex") {
walk(node.left, callback, o, node);
walk(node.right, callback, o, node);
}
else if (node.type === "compound") {
for (let n of node.list) {
walk(n, callback, o, node);
}
}
else if (node.subtree && o && o.subtree) {
walk(node.subtree, callback, o, node);
}
callback(node, parent);
}
/**
* Parse a CSS selector
* @param selector {String} The selector to parse
* @param options.recursive {Boolean} Whether to parse the arguments of pseudo-classes like :is(), :has() etc. Defaults to true.
* @param options.list {Boolean} Whether this can be a selector list (A, B, C etc). Defaults to true.
*/
function parse(selector, {recursive = true, list = true} = {}) {
let tokens = tokenize(selector);
if (!tokens) {
return null;
}
let ast = nestTokens(tokens, {list});
if (recursive) {
walk(ast, node => {
if (node.type === "pseudo-class" && node.argument) {
if (RECURSIVE_PSEUDO_CLASSES.has(node.name)) {
let argument = node.argument;
const childArg = RECURSIVE_PSEUDO_CLASSES_ARGS[node.name];
if (childArg) {
const match = childArg.exec(argument);
if (!match) {
return;
}
Object.assign(node, match.groups);
argument = match.groups.subtree;
}
if (argument) {
node.subtree = parse(argument, {recursive: true, list: true});
}
}
}
});
}
return ast;
}
function specificityToNumber(specificity, base) {
base = base || Math.max(...specificity) + 1;
return specificity[0] * base ** 2 + specificity[1] * base + specificity[2];
}
function maxIndexOf(arr) {
let max = arr[0], ret = 0;
for (let i=0; i<arr.length; i++) {
if (arr[i] > max) {
ret = i;
max = arr[i];
}
}
return arr.length === 0? -1 : ret;
}
/**
* Calculate specificity of a selector.
* If the selector is a list, the max specificity is returned.
*/
function specificity(selector, {format = "array"} = {}) {
let ast = typeof selector === "object"? selector : parse(selector, {recursive: true});
if (!ast) {
return null;
}
if (ast.type === "list") {
// Return max specificity
let base = 10;
let specificities = ast.list.map(s => {
let sp = specificity(s);
base = Math.max(base, ...sp);
return sp;
});
let numbers = specificities.map(s => specificityToNumber(s, base));
let i = maxIndexOf(numbers);
return specificities[i];
}
let ret = [0, 0, 0];
walk(ast, node => {
if (node.type === "id") {
ret[0]++;
}
else if (node.type === "class" || node.type === "attribute") {
ret[1]++;
}
else if ((node.type === "type" && node.content !== "*") || node.type === "pseudo-element") {
ret[2]++;
}
else if (node.type === "pseudo-class" && node.name !== "where") {
if (RECURSIVE_PSEUDO_CLASSES.has(node.name) && node.subtree) {
// Max of argument list
let sub = specificity(node.subtree);
sub.forEach((s, i) => ret[i] += s);
}
else {
ret[1]++;
}
}
});
return ret;
}
exports.RECURSIVE_PSEUDO_CLASSES = RECURSIVE_PSEUDO_CLASSES;
exports.RECURSIVE_PSEUDO_CLASSES_ARGS = RECURSIVE_PSEUDO_CLASSES_ARGS;
exports.TOKENS = TOKENS;
exports.TRIM_TOKENS = TRIM_TOKENS;
exports.gobbleParens = gobbleParens;
exports.nestTokens = nestTokens;
exports.parse = parse;
exports.specificity = specificity;
exports.specificityToNumber = specificityToNumber;
exports.tokenize = tokenize;
exports.tokenizeBy = tokenizeBy;
exports.walk = walk;
Object.defineProperty(exports, '__esModule', { value: true });
return exports;
}({}));
'use strict';
const TOKENS = {
attribute:
/\[\s*(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)\s*(?:(?<operator>\W?=)\s*(?<value>.+?)\s*(?<caseSensitive>[iIsS])?\s*)?\]/gu,
id: /#(?<name>(?:[-\w\u{0080}-\u{FFFF}]|\\.)+)/gu,
class: /\.(?<name>(?:[-\w\u{0080}-\u{FFFF}]|\\.)+)/gu,
comma: /\s*,\s*/g, // must be before combinator
combinator: /\s*[\s>+~]\s*/g, // this must be after attribute
'pseudo-element':
/::(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu, // this must be before pseudo-class
'pseudo-class':
/:(?<name>[-\w\u{0080}-\u{FFFF}]+)(?:\((?<argument>¶+)\))?/gu,
type: /(?:(?<namespace>\*|[-\w]*)\|)?(?<name>[-\w\u{0080}-\u{FFFF}]+)|\*/gu, // this must be last
};
const TOKENS_WITH_PARENS = new Set(['pseudo-class', 'pseudo-element']);
const TOKENS_WITH_STRINGS = new Set([...TOKENS_WITH_PARENS, 'attribute']);
const TRIM_TOKENS = new Set(['combinator', 'comma']);
const RECURSIVE_PSEUDO_CLASSES = new Set([
'not',
'is',
'where',
'has',
'matches',
'-moz-any',
'-webkit-any',
'nth-child',
'nth-last-child',
]);
const RECURSIVE_PSEUDO_CLASSES_ARGS = {
'nth-child': /(?<index>[\dn+-]+)\s+of\s+(?<subtree>.+)/,
};
RECURSIVE_PSEUDO_CLASSES['nth-last-child'] =
RECURSIVE_PSEUDO_CLASSES_ARGS['nth-child'];
const TOKENS_FOR_RESTORE = Object.assign({}, TOKENS);
TOKENS_FOR_RESTORE['pseudo-element'] = RegExp(
TOKENS['pseudo-element'].source.replace(
'(?<argument>¶+)',
'(?<argument>.+?)'
),
'gu'
);
TOKENS_FOR_RESTORE['pseudo-class'] = RegExp(
TOKENS['pseudo-class'].source.replace(
'(?<argument>¶+)',
'(?<argument>.+)'
),
'gu'
);
function gobbleParens(text, i) {
let str = '',
stack = [];
for (; i < text.length; i++) {
let char = text[i];
if (char === '(') {
stack.push(char);
} else if (char === ')') {
if (stack.length > 0) {
stack.pop();
} else {
throw new Error(
'Closing paren without opening paren at ' + i
);
}
}
str += char;
if (stack.length === 0) {
return str;
}
}
throw new Error('Opening paren without closing paren');
}
function tokenizeBy(text, grammar) {
if (!text) {
return [];
}
var strarr = [text];
for (var token in grammar) {
let pattern = grammar[token];
for (var i = 0; i < strarr.length; i++) {
// Don’t cache length as it changes during the loop
var str = strarr[i];
if (typeof str === 'string') {
pattern.lastIndex = 0;
var match = pattern.exec(str);
if (match) {
let from = match.index - 1;
let args = [];
let content = match[0];
let before = str.slice(0, from + 1);
if (before) {
args.push(before);
}
args.push({
type: token,
content,
...match.groups,
});
let after = str.slice(from + content.length + 1);
if (after) {
args.push(after);
}
strarr.splice(i, 1, ...args);
}
}
}
}
let offset = 0;
for (let i = 0; i < strarr.length; i++) {
let token = strarr[i];
let length = token.length || token.content.length;
if (typeof token === 'object') {
token.pos = [offset, offset + length];
if (TRIM_TOKENS.has(token.type)) {
token.content = token.content.trim() || ' ';
}
}
offset += length;
}
return strarr;
}
function tokenize(selector) {
if (!selector) {
return null;
}
selector = selector.trim(); // prevent leading/trailing whitespace be interpreted as combinators
// Replace strings with whitespace strings (to preserve offsets)
let strings = [];
// FIXME Does not account for escaped backslashes before a quote
selector = selector.replace(
/(['"])(\\\1|.)+?\1/g,
(str, quote, content, start) => {
strings.push({ str, start });
return quote + '§'.repeat(content.length) + quote;
}
);
// Now that strings are out of the way, extract parens and replace them with parens with whitespace (to preserve offsets)
let parens = [],
offset = 0,
start;
while ((start = selector.indexOf('(', offset)) > -1) {
let str = gobbleParens(selector, start);
parens.push({ str, start });
selector =
selector.substring(0, start) +
'(' +
'¶'.repeat(str.length - 2) +
')' +
selector.substring(start + str.length);
offset = start + str.length;
}
// Now we have no nested structures and we can parse with regexes
let tokens = tokenizeBy(selector, TOKENS);
// Now restore parens and strings in reverse order
function restoreNested(strings, regex, types) {
for (let str of strings) {
for (let token of tokens) {
if (
types.has(token.type) &&
token.pos[0] < str.start &&
str.start < token.pos[1]
) {
let content = token.content;
token.content = token.content.replace(regex, str.str);
if (token.content !== content) {
// actually changed?
// Re-evaluate groups
TOKENS_FOR_RESTORE[token.type].lastIndex = 0;
let match = TOKENS_FOR_RESTORE[token.type].exec(
token.content
);
let groups = match.groups;
Object.assign(token, groups);
}
}
}
}
}
restoreNested(parens, /\(¶+\)/, TOKENS_WITH_PARENS);
restoreNested(strings, /(['"])§+?\1/, TOKENS_WITH_STRINGS);
return tokens;
}
// Convert a flat list of tokens into a tree of complex & compound selectors
function nestTokens(tokens, { list = true } = {}) {
if (list && tokens.find((t) => t.type === 'comma')) {
let selectors = [],
temp = [];
for (let i = 0; i < tokens.length; i++) {
if (tokens[i].type === 'comma') {
if (temp.length === 0) {
throw new Error('Incorrect comma at ' + i);
}
selectors.push(nestTokens(temp, { list: false }));
temp.length = 0;
} else {
temp.push(tokens[i]);
}
}
if (temp.length === 0) {
throw new Error('Trailing comma');
} else {
selectors.push(nestTokens(temp, { list: false }));
}
return { type: 'list', list: selectors };
}
for (let i = tokens.length - 1; i >= 0; i--) {
let token = tokens[i];
if (token.type === 'combinator') {
let left = tokens.slice(0, i);
let right = tokens.slice(i + 1);
return {
type: 'complex',
combinator: token.content,
left: nestTokens(left),
right: nestTokens(right),
};
}
}
if (tokens.length === 0) {
return null;
}
// If we're here, there are no combinators, so it's just a list
return tokens.length === 1
? tokens[0]
: {
type: 'compound',
list: [...tokens], // clone to avoid pointers messing up the AST
};
}
// Traverse an AST (or part thereof), in depth-first order
function walk(node, callback, o, parent) {
if (!node) {
return;
}
if (node.type === 'complex') {
walk(node.left, callback, o, node);
walk(node.right, callback, o, node);
} else if (node.type === 'compound') {
for (let n of node.list) {
walk(n, callback, o, node);
}
} else if (node.subtree && o && o.subtree) {
walk(node.subtree, callback, o, node);
}
callback(node, parent);
}
/**
* Parse a CSS selector
* @param selector {String} The selector to parse
* @param options.recursive {Boolean} Whether to parse the arguments of pseudo-classes like :is(), :has() etc. Defaults to true.
* @param options.list {Boolean} Whether this can be a selector list (A, B, C etc). Defaults to true.
*/
function parse(selector, { recursive = true, list = true } = {}) {
let tokens = tokenize(selector);
if (!tokens) {
return null;
}
let ast = nestTokens(tokens, { list });
if (recursive) {
walk(ast, (node) => {
if (node.type === 'pseudo-class' && node.argument) {
if (RECURSIVE_PSEUDO_CLASSES.has(node.name)) {
let argument = node.argument;
const childArg =
RECURSIVE_PSEUDO_CLASSES_ARGS[node.name];
if (childArg) {
const match = childArg.exec(argument);
if (!match) {
return;
}
Object.assign(node, match.groups);
argument = match.groups.subtree;
}
if (argument) {
node.subtree = parse(argument, {
recursive: true,
list: true,
});
}
}
}
});
}
return ast;
}
function specificityToNumber(specificity, base) {
base = base || Math.max(...specificity) + 1;
return (
specificity[0] * base ** 2 + specificity[1] * base + specificity[2]
);
}
function maxIndexOf(arr) {
let max = arr[0],
ret = 0;
for (let i = 0; i < arr.length; i++) {
if (arr[i] > max) {
ret = i;
max = arr[i];
}
}
return arr.length === 0 ? -1 : ret;
}
/**
* Calculate specificity of a selector.
* If the selector is a list, the max specificity is returned.
*/
function specificity(selector, { format = 'array' } = {}) {
let ast =
typeof selector === 'object'
? selector
: parse(selector, { recursive: true });
if (!ast) {
return null;
}
if (ast.type === 'list') {
// Return max specificity
let base = 10;
let specificities = ast.list.map((s) => {
let sp = specificity(s);
base = Math.max(base, ...sp);
return sp;
});
let numbers = specificities.map((s) =>
specificityToNumber(s, base)
);
let i = maxIndexOf(numbers);
return specificities[i];
}
let ret = [0, 0, 0];
walk(ast, (node) => {
if (node.type === 'id') {
ret[0]++;
} else if (node.type === 'class' || node.type === 'attribute') {
ret[1]++;
} else if (
(node.type === 'type' && node.content !== '*') ||
node.type === 'pseudo-element'
) {
ret[2]++;
} else if (node.type === 'pseudo-class' && node.name !== 'where') {
if (RECURSIVE_PSEUDO_CLASSES.has(node.name) && node.subtree) {
// Max of argument list
let sub = specificity(node.subtree);
sub.forEach((s, i) => (ret[i] += s));
} else {
ret[1]++;
}
}
});
return ret;
}
exports.RECURSIVE_PSEUDO_CLASSES = RECURSIVE_PSEUDO_CLASSES;
exports.RECURSIVE_PSEUDO_CLASSES_ARGS = RECURSIVE_PSEUDO_CLASSES_ARGS;
exports.TOKENS = TOKENS;
exports.TRIM_TOKENS = TRIM_TOKENS;
exports.gobbleParens = gobbleParens;
exports.nestTokens = nestTokens;
exports.parse = parse;
exports.specificity = specificity;
exports.specificityToNumber = specificityToNumber;
exports.tokenize = tokenize;
exports.tokenizeBy = tokenizeBy;
exports.walk = walk;
Object.defineProperty(exports, '__esModule', { value: true });
return exports;
})({});

17
src/rewrite/rewrite.css.js
View file

@ -1,9 +1,12 @@
function url(ctx) {
const { css } = ctx;
css.on('Url', (node, data, type) => {
node.value = type === 'rewrite' ? ctx.rewriteUrl(node.value) : ctx.sourceUrl(node.value);
node.value =
type === 'rewrite'
? ctx.rewriteUrl(node.value)
: ctx.sourceUrl(node.value);
});
};
}
function importStyle(ctx) {
const { css } = ctx;
@ -12,9 +15,11 @@ function importStyle(ctx) {
const { data: url } = node.prelude.children.head;
// Already handling Url's
if (url.type === 'Url') return false;
url.value = type === 'rewrite' ? ctx.rewriteUrl(url.value) : ctx.sourceUrl(url.value);
url.value =
type === 'rewrite'
? ctx.rewriteUrl(url.value)
: ctx.sourceUrl(url.value);
});
};
}
export { url, importStyle };
export { url, importStyle };

284
src/rewrite/rewrite.html.js
View file

@ -3,50 +3,54 @@ function attributes(ctx, meta = ctx.meta) {
const origPrefix = attributePrefix + '-attr-';
html.on('attr', (attr, type) => {
if (attr.node.tagName === 'base' && attr.name === 'href' && attr.options.document) {
if (
attr.node.tagName === 'base' &&
attr.name === 'href' &&
attr.options.document
) {
meta.base = new URL(attr.value, meta.url);
};
}
if (type === 'rewrite' && isUrl(attr.name, attr.tagName)) {
attr.node.setAttribute(origPrefix + attr.name, attr.value);
attr.value = ctx.rewriteUrl(attr.value, meta);
};
}
if (type === 'rewrite' && isSrcset(attr.name)) {
attr.node.setAttribute(origPrefix + attr.name, attr.value);
attr.value = html.wrapSrcset(attr.value, meta);
};
}
if (type === 'rewrite' && isHtml(attr.name)) {
attr.node.setAttribute(origPrefix + attr.name, attr.value);
attr.value = html.rewrite(attr.value, {
attr.value = html.rewrite(attr.value, {
...meta,
document: true,
injectHead: attr.options.injectHead || [],
});
};
}
if (type === 'rewrite' && isStyle(attr.name)) {
attr.node.setAttribute(origPrefix + attr.name, attr.value);
attr.value = ctx.rewriteCSS(attr.value, { context: 'declarationList', });
};
attr.value = ctx.rewriteCSS(attr.value, {
context: 'declarationList',
});
}
if (type === 'rewrite' && isForbidden(attr.name)) {
attr.name = origPrefix + attr.name;
};
}
if (type === 'rewrite' && isEvent(attr.name)) {
attr.node.setAttribute(origPrefix + attr.name, attr.value);
attr.value = js.rewrite(attr.value, meta);
};
}
if (type === 'source' && attr.name.startsWith(origPrefix)) {
if (attr.node.hasAttribute(attr.name.slice(origPrefix.length))) attr.node.removeAttribute(attr.name.slice(origPrefix.length));
if (attr.node.hasAttribute(attr.name.slice(origPrefix.length)))
attr.node.removeAttribute(attr.name.slice(origPrefix.length));
attr.name = attr.name.slice(origPrefix.length);
};
}
/*
if (isHtml(attr.name)) {
@ -61,102 +65,120 @@ function attributes(ctx, meta = ctx.meta) {
};
*/
});
};
});
}
function text(ctx, meta = ctx.meta) {
const { html, js, css, attributePrefix } = ctx;
html.on('text', (text, type) => {
if (text.element.tagName === 'script') {
text.value = type === 'rewrite' ? js.rewrite(text.value) : js.source(text.value);
};
text.value =
type === 'rewrite'
? js.rewrite(text.value)
: js.source(text.value);
}
if (text.element.tagName === 'style') {
text.value = type === 'rewrite' ? css.rewrite(text.value) : css.source(text.value);
};
text.value =
type === 'rewrite'
? css.rewrite(text.value)
: css.source(text.value);
}
});
return true;
};
}
function isUrl(name, tag) {
return tag === 'object' && name === 'data' || ['src', 'href', 'ping', 'movie', 'action', 'poster', 'profile', 'background'].indexOf(name) > -1;
};
return (
(tag === 'object' && name === 'data') ||
[
'src',
'href',
'ping',
'movie',
'action',
'poster',
'profile',
'background',
].indexOf(name) > -1
);
}
function isEvent(name) {
return [
'onafterprint',
'onbeforeprint',
'onbeforeunload',
'onerror',
'onhashchange',
'onload',
'onmessage',
'onoffline',
'ononline',
'onpagehide',
'onpopstate',
'onstorage',
'onunload',
'onblur',
'onchange',
'oncontextmenu',
'onfocus',
'oninput',
'oninvalid',
'onreset',
'onsearch',
'onselect',
'onsubmit',
'onkeydown',
'onkeypress',
'onkeyup',
'onclick',
'ondblclick',
'onmousedown',
'onmousemove',
'onmouseout',
'onmouseover',
'onmouseup',
'onmousewheel',
'onwheel',
'ondrag',
'ondragend',
'ondragenter',
'ondragleave',
'ondragover',
'ondragstart',
'ondrop',
'onscroll',
'oncopy',
'oncut',
'onpaste',
'onabort',
'oncanplay',
'oncanplaythrough',
'oncuechange',
'ondurationchange',
'onemptied',
'onended',
'onerror',
'onloadeddata',
'onloadedmetadata',
'onloadstart',
'onpause',
'onplay',
'onplaying',
'onprogress',
'onratechange',
'onseeked',
'onseeking',
'onstalled',
'onsuspend',
'ontimeupdate',
'onvolumechange',
'onwaiting',
].indexOf(name) > -1;
};
return (
[
'onafterprint',
'onbeforeprint',
'onbeforeunload',
'onerror',
'onhashchange',
'onload',
'onmessage',
'onoffline',
'ononline',
'onpagehide',
'onpopstate',
'onstorage',
'onunload',
'onblur',
'onchange',
'oncontextmenu',
'onfocus',
'oninput',
'oninvalid',
'onreset',
'onsearch',
'onselect',
'onsubmit',
'onkeydown',
'onkeypress',
'onkeyup',
'onclick',
'ondblclick',
'onmousedown',
'onmousemove',
'onmouseout',
'onmouseover',
'onmouseup',
'onmousewheel',
'onwheel',
'ondrag',
'ondragend',
'ondragenter',
'ondragleave',
'ondragover',
'ondragstart',
'ondrop',
'onscroll',
'oncopy',
'oncut',
'onpaste',
'onabort',
'oncanplay',
'oncanplaythrough',
'oncuechange',
'ondurationchange',
'onemptied',
'onended',
'onerror',
'onloadeddata',
'onloadedmetadata',
'onloadstart',
'onpause',
'onplay',
'onplaying',
'onprogress',
'onratechange',
'onseeked',
'onseeking',
'onstalled',
'onsuspend',
'ontimeupdate',
'onvolumechange',
'onwaiting',
].indexOf(name) > -1
);
}
function injectHead(ctx) {
const { html, js, css, attributePrefix } = ctx;
@ -165,14 +187,18 @@ function injectHead(ctx) {
if (type !== 'rewrite') return false;
if (element.tagName !== 'head') return false;
if (!('injectHead' in element.options)) return false;
element.childNodes.unshift(
...element.options.injectHead
);
});
};
function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', config = '/uv.config.js', cookies = '', referrer = '') {
element.childNodes.unshift(...element.options.injectHead);
});
}
function createInjection(
handler = '/uv.handler.js',
bundle = '/uv.bundle.js',
config = '/uv.config.js',
cookies = '',
referrer = ''
) {
return [
{
tagName: 'script',
@ -180,7 +206,9 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
childNodes: [
{
nodeName: '#text',
value: `window.__uv$cookies = atob("${btoa(cookies)}");\nwindow.__uv$referrer = atob("${btoa(referrer)}");`
value: `window.__uv$cookies = atob("${btoa(
cookies
)}");\nwindow.__uv$referrer = atob("${btoa(referrer)}");`,
},
],
attrs: [
@ -188,7 +216,7 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
name: '__uv-script',
value: '1',
skip: true,
}
},
],
skip: true,
},
@ -202,7 +230,7 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
name: '__uv-script',
value: '1',
skip: true,
}
},
],
},
{
@ -215,7 +243,7 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
name: '__uv-script',
value: '1',
skip: true,
}
},
],
},
{
@ -228,27 +256,41 @@ function createInjection(handler = '/uv.handler.js', bundle = '/uv.bundle.js', c
name: '__uv-script',
value: '1',
skip: true,
}
},
],
}
},
];
};
}
function isForbidden(name) {
return ['http-equiv', 'integrity', 'sandbox', 'nonce', 'crossorigin'].indexOf(name) > -1;
};
return (
['http-equiv', 'integrity', 'sandbox', 'nonce', 'crossorigin'].indexOf(
name
) > -1
);
}
function isHtml(name){
function isHtml(name) {
return name === 'srcdoc';
};
}
function isStyle(name) {
return name === 'style';
};
}
function isSrcset(name) {
return name === 'srcset' || name === 'imagesrcset';
}
export {
attributes,
createInjection,
text,
isUrl,
isEvent,
isForbidden,
isHtml,
isStyle,
isSrcset,
injectHead,
};
export { attributes, createInjection, text, isUrl, isEvent, isForbidden, isHtml, isStyle, isSrcset, injectHead };

263
src/rewrite/rewrite.script.js
View file

@ -10,92 +10,167 @@ function property(ctx) {
node: '__uv.$wrap((',
start: node.property.start,
end: node.property.start,
})
node.iterateEnd = function() {
});
node.iterateEnd = function () {
data.changes.push({
node: '))',
start: node.property.end,
end: node.property.end,
});
};
};
if (!node.computed && node.property.name === 'location' && type === 'rewrite' || node.property.name === '__uv$location' && type === 'source') {
}
if (
(!node.computed &&
node.property.name === 'location' &&
type === 'rewrite') ||
(node.property.name === '__uv$location' && type === 'source')
) {
data.changes.push({
start: node.property.start,
end: node.property.end,
node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$location' : 'location'
node:
type === 'rewrite'
? '__uv$setSource(__uv).__uv$location'
: 'location',
});
};
}
if (!node.computed && node.property.name === 'top' && type === 'rewrite' || node.property.name === '__uv$top' && type === 'source') {
if (
(!node.computed &&
node.property.name === 'top' &&
type === 'rewrite') ||
(node.property.name === '__uv$top' && type === 'source')
) {
data.changes.push({
start: node.property.start,
end: node.property.end,
node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$top' : 'top'
node:
type === 'rewrite'
? '__uv$setSource(__uv).__uv$top'
: 'top',
});
};
}
if (!node.computed && node.property.name === 'parent' && type === 'rewrite' || node.property.name === '__uv$parent' && type === 'source') {
if (
(!node.computed &&
node.property.name === 'parent' &&
type === 'rewrite') ||
(node.property.name === '__uv$parent' && type === 'source')
) {
data.changes.push({
start: node.property.start,
end: node.property.end,
node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$parent' : 'parent'
node:
type === 'rewrite'
? '__uv$setSource(__uv).__uv$parent'
: 'parent',
});
};
}
if (!node.computed && node.property.name === 'postMessage' && type === 'rewrite') {
if (
!node.computed &&
node.property.name === 'postMessage' &&
type === 'rewrite'
) {
data.changes.push({
start: node.property.start,
end: node.property.end,
node:'__uv$setSource(__uv).postMessage',
node: '__uv$setSource(__uv).postMessage',
});
};
}
if (!node.computed && node.property.name === 'eval' && type === 'rewrite' || node.property.name === '__uv$eval' && type === 'source') {
if (
(!node.computed &&
node.property.name === 'eval' &&
type === 'rewrite') ||
(node.property.name === '__uv$eval' && type === 'source')
) {
data.changes.push({
start: node.property.start,
end: node.property.end,
node: type === 'rewrite' ? '__uv$setSource(__uv).__uv$eval' : 'eval'
node:
type === 'rewrite'
? '__uv$setSource(__uv).__uv$eval'
: 'eval',
});
};
}
if (!node.computed && node.property.name === '__uv$setSource' && type === 'source' && node.parent.type === Syntax.CallExpression) {
const { parent, property } = node;
if (
!node.computed &&
node.property.name === '__uv$setSource' &&
type === 'source' &&
node.parent.type === Syntax.CallExpression
) {
const { parent, property } = node;
data.changes.push({
start: property.start - 1,
end: parent.end,
});
node.iterateEnd = function() {
node.iterateEnd = function () {
data.changes.push({
start: property.start,
end: parent.end,
});
};
};
}
});
};
}
function identifier(ctx) {
const { js } = ctx;
js.on('Identifier', (node, data, type) => {
if (type !== 'rewrite') return false;
const { parent } = node;
if (!['location', 'eval', 'parent', 'top'].includes(node.name)) return false;
if (parent.type === Syntax.VariableDeclarator && parent.id === node) return false;
if ((parent.type === Syntax.AssignmentExpression || parent.type === Syntax.AssignmentPattern) && parent.left === node) return false;
if ((parent.type === Syntax.FunctionExpression || parent.type === Syntax.FunctionDeclaration) && parent.id === node) return false;
if (parent.type === Syntax.MemberExpression && parent.property === node && !parent.computed) return false;
if (node.name === 'eval' && parent.type === Syntax.CallExpression && parent.callee === node) return false;
if (parent.type === Syntax.Property && parent.key === node) return false;
if (parent.type === Syntax.Property && parent.value === node && parent.shorthand) return false;
if (parent.type === Syntax.UpdateExpression && (parent.operator === '++' || parent.operator === '--')) return false;
if ((parent.type === Syntax.FunctionExpression || parent.type === Syntax.FunctionDeclaration || parent.type === Syntax.ArrowFunctionExpression) && parent.params.indexOf(node) !== -1) return false;
if (!['location', 'eval', 'parent', 'top'].includes(node.name))
return false;
if (parent.type === Syntax.VariableDeclarator && parent.id === node)
return false;
if (
(parent.type === Syntax.AssignmentExpression ||
parent.type === Syntax.AssignmentPattern) &&
parent.left === node
)
return false;
if (
(parent.type === Syntax.FunctionExpression ||
parent.type === Syntax.FunctionDeclaration) &&
parent.id === node
)
return false;
if (
parent.type === Syntax.MemberExpression &&
parent.property === node &&
!parent.computed
)
return false;
if (
node.name === 'eval' &&
parent.type === Syntax.CallExpression &&
parent.callee === node
)
return false;
if (parent.type === Syntax.Property && parent.key === node)
return false;
if (
parent.type === Syntax.Property &&
parent.value === node &&
parent.shorthand
)
return false;
if (
parent.type === Syntax.UpdateExpression &&
(parent.operator === '++' || parent.operator === '--')
)
return false;
if (
(parent.type === Syntax.FunctionExpression ||
parent.type === Syntax.FunctionDeclaration ||
parent.type === Syntax.ArrowFunctionExpression) &&
parent.params.indexOf(node) !== -1
)
return false;
if (parent.type === Syntax.MethodDefinition) return false;
if (parent.type === Syntax.ClassDeclaration) return false;
if (parent.type === Syntax.RestElement) return false;
@ -105,10 +180,10 @@ function identifier(ctx) {
data.changes.push({
start: node.start,
end: node.end,
node: '__uv.$get(' + node.name + ')'
node: '__uv.$get(' + node.name + ')',
});
});
};
}
function wrapEval(ctx) {
const { js } = ctx;
@ -117,15 +192,15 @@ function wrapEval(ctx) {
if (!node.arguments.length) return false;
if (node.callee.type !== 'Identifier') return false;
if (node.callee.name !== 'eval') return false;
const [ script ] = node.arguments;
const [script] = node.arguments;
data.changes.push({
node: '__uv.js.rewrite(',
start: script.start,
end: script.start,
})
node.iterateEnd = function() {
});
node.iterateEnd = function () {
data.changes.push({
node: ')',
start: script.end,
@ -133,21 +208,31 @@ function wrapEval(ctx) {
});
};
});
};
}
function importDeclaration(ctx) {
const { js } = ctx;
js.on(Syntax.Literal, (node, data, type) => {
if (!((node.parent.type === Syntax.ImportDeclaration || node.parent.type === Syntax.ExportAllDeclaration || node.parent.type === Syntax.ExportNamedDeclaration)
&& node.parent.source === node)) return false;
if (
!(
(node.parent.type === Syntax.ImportDeclaration ||
node.parent.type === Syntax.ExportAllDeclaration ||
node.parent.type === Syntax.ExportNamedDeclaration) &&
node.parent.source === node
)
)
return false;
data.changes.push({
start: node.start + 1,
end: node.end - 1,
node: type === 'rewrite' ? ctx.rewriteUrl(node.value) : ctx.sourceUrl(node.value)
node:
type === 'rewrite'
? ctx.rewriteUrl(node.value)
: ctx.sourceUrl(node.value),
});
});
};
}
function dynamicImport(ctx) {
const { js } = ctx;
@ -157,8 +242,8 @@ function dynamicImport(ctx) {
node: '__uv.rewriteUrl(',
start: node.source.start,
end: node.source.start,
})
node.iterateEnd = function() {
});
node.iterateEnd = function () {
data.changes.push({
node: ')',
start: node.source.end,
@ -166,7 +251,7 @@ function dynamicImport(ctx) {
});
};
});
};
}
function unwrap(ctx) {
const { js } = ctx;
@ -174,70 +259,82 @@ function unwrap(ctx) {
if (type !== 'source') return false;
if (!isWrapped(node.callee)) return false;
switch(node.callee.property.name) {
switch (node.callee.property.name) {
case '$wrap':
if (!node.arguments || node.parent.type !== Syntax.MemberExpression || node.parent.property !== node) return false;
const [ property ] = node.arguments;
if (
!node.arguments ||
node.parent.type !== Syntax.MemberExpression ||
node.parent.property !== node
)
return false;
const [property] = node.arguments;
data.changes.push({
start: node.callee.start,
end: property.start,
});
node.iterateEnd = function() {
node.iterateEnd = function () {
data.changes.push({
start: node.end - 2,
end: node.end,
});
};
};
break;
case '$get':
case 'rewriteUrl':
const [ arg ] = node.arguments;
const [arg] = node.arguments;
data.changes.push({
start: node.callee.start,
end: arg.start,
});
node.iterateEnd = function() {
data.changes.push({
start: node.end - 1,
end: node.end,
});
};
break;
case 'rewrite':
const [ script ] = node.arguments;
data.changes.push({
start: node.callee.start,
end: script.start,
});
node.iterateEnd = function() {
node.iterateEnd = function () {
data.changes.push({
start: node.end - 1,
end: node.end,
});
};
};
break;
case 'rewrite':
const [script] = node.arguments;
data.changes.push({
start: node.callee.start,
end: script.start,
});
node.iterateEnd = function () {
data.changes.push({
start: node.end - 1,
end: node.end,
});
};
}
});
};
}
function isWrapped(node) {
if (node.type !== Syntax.MemberExpression) return false;
if (node.property.name === 'rewrite' && isWrapped(node.object)) return true;
if (node.object.type !== Syntax.Identifier || node.object.name !== '__uv') return false;
if (!['js', '$get', '$wrap', 'rewriteUrl'].includes(node.property.name)) return false;
if (node.object.type !== Syntax.Identifier || node.object.name !== '__uv')
return false;
if (!['js', '$get', '$wrap', 'rewriteUrl'].includes(node.property.name))
return false;
return true;
};
}
function computedProperty(parent) {
if (!parent.computed) return false;
const { property: node } = parent;
const { property: node } = parent;
if (node.type === 'Literal' && !['location', 'top', 'parent']) return false;
return true;
}
export {
property,
wrapEval,
dynamicImport,
importDeclaration,
identifier,
unwrap,
};
export { property, wrapEval, dynamicImport, importDeclaration, identifier, unwrap };

20
src/uv.config.js
View file

@ -1,10 +1,10 @@
self.__uv$config = {
prefix: '/service/',
bare: 'https://incog.dev/bare/',
encodeUrl: Ultraviolet.codec.xor.encode,
decodeUrl: Ultraviolet.codec.xor.decode,
handler: '/uv.handler.js',
bundle: '/uv.bundle.js',
config: '/uv.config.js',
sw: '/uv.sw.js',
};
self.__uv$config = {
prefix: '/service/',
bare: 'https://incog.dev/bare/',
encodeUrl: Ultraviolet.codec.xor.encode,
decodeUrl: Ultraviolet.codec.xor.decode,
handler: '/uv.handler.js',
bundle: '/uv.bundle.js',
config: '/uv.config.js',
sw: '/uv.sw.js',
};

2559
src/uv.handler.js
View file

File diff suppressed because it is too large Load diff

1663
src/uv.sw.js
View file

File diff suppressed because it is too large Load diff

74
webpack.config.js
View file

@ -9,40 +9,46 @@ const isDevelopment = process.env.NODE_ENV !== 'production';
* @type {webpack.Configuration}
*/
const config = {
mode: isDevelopment ? 'development' : 'production',
entry: {
bundle: fileURLToPath(new URL('./src/rewrite/index.js', import.meta.url)),
handler: fileURLToPath(new URL('./src/uv.handler.js', import.meta.url)),
sw: fileURLToPath(new URL('./src/uv.sw.js', import.meta.url)),
},
output: {
path: fileURLToPath(new URL('./dist/', import.meta.url)),
filename: 'uv.[name].js',
},
optimization: {
minimize: !isDevelopment,
minimizer: [
new TerserPlugin({
exclude: ['sw.js', 'uv.config.js'],
}),
],
},
plugins: [
new CopyPlugin({
patterns: [
{
from: fileURLToPath(new URL('./src/uv.config.js', import.meta.url)),
},
{
from: fileURLToPath(new URL('./src/sw.js', import.meta.url)),
},
],
}),
],
performance: {
// suppress "entrypoint size limit" warning
hints: false,
},
mode: isDevelopment ? 'development' : 'production',
entry: {
bundle: fileURLToPath(
new URL('./src/rewrite/index.js', import.meta.url)
),
handler: fileURLToPath(new URL('./src/uv.handler.js', import.meta.url)),
sw: fileURLToPath(new URL('./src/uv.sw.js', import.meta.url)),
},
output: {
path: fileURLToPath(new URL('./dist/', import.meta.url)),
filename: 'uv.[name].js',
},
optimization: {
minimize: !isDevelopment,
minimizer: [
new TerserPlugin({
exclude: ['sw.js', 'uv.config.js'],
}),
],
},
plugins: [
new CopyPlugin({
patterns: [
{
from: fileURLToPath(
new URL('./src/uv.config.js', import.meta.url)
),
},
{
from: fileURLToPath(
new URL('./src/sw.js', import.meta.url)
),
},
],
}),
],
performance: {
// suppress "entrypoint size limit" warning
hints: false,
},
};
export default config;