s2/minifyfromhtml
1
0
Fork 0
mirror of https://github.com/S2-/minifyfromhtml.git synced 2025-08-02 12:00:03 +02:00
Code Issues Releases Wiki Activity

update modules

Browse Source
This commit is contained in:
s2
2020-07-20 16:16:07 +02:00
parent 783511ce12
commit 2b23424b86
785 changed files with 91905 additions and 56057 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
node_modules/webidl-conversions/README.md generated vendored
View File

@@ -25,7 +25,23 @@ void doStuff(boolean x, unsigned long y);
This package's main module's default export is an object with a variety of methods, each corresponding to a different Web IDL type. Each method, when invoked on a JavaScript value, will give back the new JavaScript value that results after passing through the Web IDL conversion rules. (See below for more details on what that means.) Alternately, the method could throw an error, if the Web IDL algorithm is specified to do so: for example `conversions["float"](NaN)` [will throw a `TypeError`](http://heycam.github.io/webidl/#es-float).
Each method also accepts a second, optional, parameter for miscellaneous options. For conversion methods that throw errors, a string option `{ context }` may be provided to provide more information in the error message. (For example, `conversions["float"](NaN, { context: "Argument 1 of Interface's operation" })` will throw an error with message `"Argument 1 of Interface's operation is not a finite floating-point value."`) Specific conversions may also accept other options, the details of which can be found below.
Each method also accepts a second, optional, parameter for miscellaneous options. For conversion methods that throw errors, a string option `{ context }` may be provided to provide more information in the error message. (For example, `conversions["float"](NaN, { context: "Argument 1 of Interface's operation" })` will throw an error with message `"Argument 1 of Interface's operation is not a finite floating-point value."`)
If we are dealing with multiple JavaScript realms (such as those created using Node.js' [vm](https://nodejs.org/api/vm.html) module or the HTML `iframe` element), and exceptions from another realm need to be thrown, one can supply an object option `globals` containing the following properties:
```js
{
globals: {
Number,
String,
TypeError
}
}
```
Those specific functions will be used when throwing exceptions.
Specific conversions may also accept other options, the details of which can be found below.
## Conversions implemented
@@ -40,12 +56,11 @@ Conversions for all of the basic types from the Web IDL specification are implem
- [`DOMString`](https://heycam.github.io/webidl/#es-DOMString), which can additionally be provided the boolean option `{ treatNullAsEmptyString }` as a second parameter
- [`ByteString`](https://heycam.github.io/webidl/#es-ByteString), [`USVString`](https://heycam.github.io/webidl/#es-USVString)
- [`object`](https://heycam.github.io/webidl/#es-object)
- [`Error`](https://heycam.github.io/webidl/#es-Error)
- [Buffer source types](https://heycam.github.io/webidl/#es-buffer-source-types)
- [Buffer source types](https://heycam.github.io/webidl/#es-buffer-source-types), which can additionally be provided with the boolean option `{ allowShared }` as a second parameter
Additionally, for convenience, the following derived type definitions are implemented:
- [`ArrayBufferView`](https://heycam.github.io/webidl/#ArrayBufferView)
- [`ArrayBufferView`](https://heycam.github.io/webidl/#ArrayBufferView), which can additionally be provided with the boolean option `{ allowShared }` as a second parameter
- [`BufferSource`](https://heycam.github.io/webidl/#BufferSource)
- [`DOMTimeStamp`](https://heycam.github.io/webidl/#DOMTimeStamp)
- [`Function`](https://heycam.github.io/webidl/#Function)
@@ -55,9 +70,15 @@ Derived types, such as nullable types, promise types, sequences, records, etc. a
### A note on the `long long` types
The `long long` and `unsigned long long` Web IDL types can hold values that cannot be stored in JavaScript numbers, so the conversion is imperfect. For example, converting the JavaScript number `18446744073709552000` to a Web IDL `long long` is supposed to produce the Web IDL value `-18446744073709551232`. Since we are representing our Web IDL values in JavaScript, we can't represent `-18446744073709551232`, so we instead the best we could do is `-18446744073709552000` as the output.
The `long long` and `unsigned long long` Web IDL types can hold values that cannot be stored in JavaScript numbers. Conversions are still accurate as we make use of BigInt in the conversion process, but in the case of `unsigned long long` we simply cannot represent some possible output values in JavaScript. For example, converting the JavaScript number `-1` to a Web IDL `unsigned long long` is supposed to produce the Web IDL value `18446744073709551615`. Since we are representing our Web IDL values in JavaScript, we can't represent `18446744073709551615`, so we instead the best we could do is `18446744073709551616` as the output.
This library actually doesn't even get that far. Producing those results would require doing accurate modular arithmetic on 64-bit intermediate values, but JavaScript does not make this easy. We could pull in a big-integer library as a dependency, but in lieu of that, we for now have decided to just produce inaccurate results if you pass in numbers that are not strictly between `Number.MIN_SAFE_INTEGER` and `Number.MAX_SAFE_INTEGER`.
To mitigate this, we could return the raw BigInt value from the conversion function, but right now it is not implemented. If your use case requires such precision, [file an issue](https://github.com/jsdom/webidl-conversions/issues/new).
On the other hand, `long long` conversion is always accurate, since the input value can never be more precise than the output value.
### A note on `BufferSource` types
All of the `BufferSource` types will throw when the relevant `ArrayBuffer` has been detached. This technically is not part of the [specified conversion algorithm](https://heycam.github.io/webidl/#es-buffer-source-types), but instead part of the [getting a reference/getting a copy](https://heycam.github.io/webidl/#ref-for-dfn-get-buffer-source-reference%E2%91%A0) algorithms. We've consolidated them here for convenience and ease of implementation, but if there is a need to separate them in the future, please open an issue so we can investigate.
## Background
@@ -77,4 +98,4 @@ And getting to that payoff is the goal of _this_ project—but for JavaScript im
Seriously, why would you ever use this? You really shouldn't. Web IDL is … strange, and you shouldn't be emulating its semantics. If you're looking for a generic argument-processing library, you should find one with better rules than those from Web IDL. In general, your JavaScript should not be trying to become more like Web IDL; if anything, we should fix Web IDL to make it more like JavaScript.
The _only_ people who should use this are those trying to create faithful implementations (or polyfills) of web platform interfaces defined in Web IDL. Its main consumer is the [jsdom](https://github.com/tmpvar/jsdom) project.
The _only_ people who should use this are those trying to create faithful implementations (or polyfills) of web platform interfaces defined in Web IDL. Its main consumer is the [jsdom](https://github.com/jsdom/jsdom) project.

249
node_modules/webidl-conversions/lib/index.js generated vendored
View File

@@ -1,7 +1,20 @@
"use strict";
function _(message, opts) {
return `${opts && opts.context ? opts.context : "Value"} ${message}.`;
function makeException(ErrorType, message, opts = {}) {
if (opts.globals) {
ErrorType = opts.globals[ErrorType.name];
}
return new ErrorType(`${opts.context ? opts.context : "Value"} ${message}.`);
}
function toNumber(value, opts = {}) {
if (!opts.globals) {
return +value;
}
if (typeof value === "bigint") {
throw opts.globals.TypeError("Cannot convert a BigInt value to a number");
}
return opts.globals.Number(value);
}
function type(V) {
@@ -19,6 +32,8 @@ function type(V) {
return "String";
case "symbol":
return "Symbol";
case "bigint":
return "BigInt";
case "object":
// Falls through
case "function":
@@ -79,8 +94,8 @@ function createIntegerConversion(bitLength, typeOpts) {
let lowerBound;
let upperBound;
if (bitLength === 64) {
upperBound = Math.pow(2, 53) - 1;
lowerBound = !isSigned ? 0 : -Math.pow(2, 53) + 1;
upperBound = Number.MAX_SAFE_INTEGER;
lowerBound = !isSigned ? 0 : Number.MIN_SAFE_INTEGER;
} else if (!isSigned) {
lowerBound = 0;
upperBound = Math.pow(2, bitLength) - 1;
@@ -92,24 +107,20 @@ function createIntegerConversion(bitLength, typeOpts) {
const twoToTheBitLength = Math.pow(2, bitLength);
const twoToOneLessThanTheBitLength = Math.pow(2, bitLength - 1);
return (V, opts) => {
if (opts === undefined) {
opts = {};
}
let x = +V;
x = censorNegativeZero(x); // Spec discussion ongoing: https://github.com/heycam/webidl/issues/306
return (V, opts = {}) => {
let x = toNumber(V, opts);
x = censorNegativeZero(x);
if (opts.enforceRange) {
if (!Number.isFinite(x)) {
throw new TypeError(_("is not a finite number", opts));
throw makeException(TypeError, "is not a finite number", opts);
}
x = integerPart(x);
if (x < lowerBound || x > upperBound) {
throw new TypeError(_(
`is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`, opts));
throw makeException(TypeError,
`is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`, opts);
}
return x;
@@ -141,6 +152,50 @@ function createIntegerConversion(bitLength, typeOpts) {
};
}
function createLongLongConversion(bitLength, { unsigned }) {
const upperBound = Number.MAX_SAFE_INTEGER;
const lowerBound = unsigned ? 0 : Number.MIN_SAFE_INTEGER;
const asBigIntN = unsigned ? BigInt.asUintN : BigInt.asIntN;
return (V, opts = {}) => {
if (opts === undefined) {
opts = {};
}
let x = toNumber(V, opts);
x = censorNegativeZero(x);
if (opts.enforceRange) {
if (!Number.isFinite(x)) {
throw makeException(TypeError, "is not a finite number", opts);
}
x = integerPart(x);
if (x < lowerBound || x > upperBound) {
throw makeException(TypeError,
`is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`, opts);
}
return x;
}
if (!Number.isNaN(x) && opts.clamp) {
x = Math.min(Math.max(x, lowerBound), upperBound);
x = evenRound(x);
return x;
}
if (!Number.isFinite(x) || x === 0) {
return 0;
}
let xBigInt = BigInt(integerPart(x));
xBigInt = asBigIntN(bitLength, xBigInt);
return Number(xBigInt);
};
}
exports.any = V => {
return V;
};
@@ -162,30 +217,30 @@ exports["unsigned short"] = createIntegerConversion(16, { unsigned: true });
exports.long = createIntegerConversion(32, { unsigned: false });
exports["unsigned long"] = createIntegerConversion(32, { unsigned: true });
exports["long long"] = createIntegerConversion(64, { unsigned: false });
exports["unsigned long long"] = createIntegerConversion(64, { unsigned: true });
exports["long long"] = createLongLongConversion(64, { unsigned: false });
exports["unsigned long long"] = createLongLongConversion(64, { unsigned: true });
exports.double = (V, opts) => {
const x = +V;
const x = toNumber(V, opts);
if (!Number.isFinite(x)) {
throw new TypeError(_("is not a finite floating-point value", opts));
throw makeException(TypeError, "is not a finite floating-point value", opts);
}
return x;
};
exports["unrestricted double"] = V => {
const x = +V;
exports["unrestricted double"] = (V, opts) => {
const x = toNumber(V, opts);
return x;
};
exports.float = (V, opts) => {
const x = +V;
const x = toNumber(V, opts);
if (!Number.isFinite(x)) {
throw new TypeError(_("is not a finite floating-point value", opts));
throw makeException(TypeError, "is not a finite floating-point value", opts);
}
if (Object.is(x, -0)) {
@@ -195,14 +250,14 @@ exports.float = (V, opts) => {
const y = Math.fround(x);
if (!Number.isFinite(y)) {
throw new TypeError(_("is outside the range of a single-precision floating-point value", opts));
throw makeException(TypeError, "is outside the range of a single-precision floating-point value", opts);
}
return y;
};
exports["unrestricted float"] = V => {
const x = +V;
exports["unrestricted float"] = (V, opts) => {
const x = toNumber(V, opts);
if (isNaN(x)) {
return x;
@@ -215,20 +270,17 @@ exports["unrestricted float"] = V => {
return Math.fround(x);
};
exports.DOMString = function (V, opts) {
if (opts === undefined) {
opts = {};
}
exports.DOMString = function (V, opts = {}) {
if (opts.treatNullAsEmptyString && V === null) {
return "";
}
if (typeof V === "symbol") {
throw new TypeError(_("is a symbol, which cannot be converted to a string", opts));
throw makeException(TypeError, "is a symbol, which cannot be converted to a string", opts);
}
return String(V);
const StringCtor = opts.globals ? opts.globals.String : String;
return StringCtor(V);
};
exports.ByteString = (V, opts) => {
@@ -236,7 +288,7 @@ exports.ByteString = (V, opts) => {
let c;
for (let i = 0; (c = x.codePointAt(i)) !== undefined; ++i) {
if (c > 255) {
throw new TypeError(_("is not a valid ByteString", opts));
throw makeException(TypeError, "is not a valid ByteString", opts);
}
}
@@ -273,7 +325,7 @@ exports.USVString = (V, opts) => {
exports.object = (V, opts) => {
if (type(V) !== "Object") {
throw new TypeError(_("is not an object", opts));
throw makeException(TypeError, "is not an object", opts);
}
return V;
@@ -285,22 +337,103 @@ exports.object = (V, opts) => {
// handling for that is omitted.
function convertCallbackFunction(V, opts) {
if (typeof V !== "function") {
throw new TypeError(_("is not a function", opts));
throw makeException(TypeError, "is not a function", opts);
}
return V;
}
const abByteLengthGetter =
Object.getOwnPropertyDescriptor(ArrayBuffer.prototype, "byteLength").get;
const sabByteLengthGetter =
Object.getOwnPropertyDescriptor(SharedArrayBuffer.prototype, "byteLength").get;
function isNonSharedArrayBuffer(V) {
try {
// This will throw on SharedArrayBuffers, but not detached ArrayBuffers.
// (The spec says it should throw, but the spec conflicts with implementations: https://github.com/tc39/ecma262/issues/678)
abByteLengthGetter.call(V);
return true;
} catch {
return false;
}
}
function isSharedArrayBuffer(V) {
try {
sabByteLengthGetter.call(V);
return true;
} catch {
return false;
}
}
function isArrayBufferDetached(V) {
try {
// eslint-disable-next-line no-new
new Uint8Array(V);
return false;
} catch {
return true;
}
}
exports.ArrayBuffer = (V, opts = {}) => {
if (!isNonSharedArrayBuffer(V)) {
if (opts.allowShared && !isSharedArrayBuffer(V)) {
throw makeException(TypeError, "is not an ArrayBuffer or SharedArrayBuffer", opts);
}
throw makeException(TypeError, "is not an ArrayBuffer", opts);
}
if (isArrayBufferDetached(V)) {
throw makeException(TypeError, "is a detached ArrayBuffer", opts);
}
return V;
};
const dvByteLengthGetter =
Object.getOwnPropertyDescriptor(DataView.prototype, "byteLength").get;
exports.DataView = (V, opts = {}) => {
try {
dvByteLengthGetter.call(V);
} catch (e) {
throw makeException(TypeError, "is not a DataView", opts);
}
if (!opts.allowShared && isSharedArrayBuffer(V.buffer)) {
throw makeException(TypeError, "is backed by a SharedArrayBuffer, which is not allowed", opts);
}
if (isArrayBufferDetached(V.buffer)) {
throw makeException(TypeError, "is backed by a detached ArrayBuffer", opts);
}
return V;
};
// Returns the unforgeable `TypedArray` constructor name or `undefined`,
// if the `this` value isn't a valid `TypedArray` object.
//
// https://tc39.es/ecma262/#sec-get-%typedarray%.prototype-@@tostringtag
const typedArrayNameGetter = Object.getOwnPropertyDescriptor(
Object.getPrototypeOf(Uint8Array).prototype,
Symbol.toStringTag
).get;
[
Error,
ArrayBuffer, // The IsDetachedBuffer abstract operation is not exposed in JS
DataView, Int8Array, Int16Array, Int32Array, Uint8Array,
Int8Array, Int16Array, Int32Array, Uint8Array,
Uint16Array, Uint32Array, Uint8ClampedArray, Float32Array, Float64Array
].forEach(func => {
const name = func.name;
const article = /^[AEIOU]/.test(name) ? "an" : "a";
exports[name] = (V, opts) => {
if (!(V instanceof func)) {
throw new TypeError(_(`is not ${article} ${name} object`, opts));
exports[name] = (V, opts = {}) => {
if (!ArrayBuffer.isView(V) || typedArrayNameGetter.call(V) !== name) {
throw makeException(TypeError, `is not ${article} ${name} object`, opts);
}
if (!opts.allowShared && isSharedArrayBuffer(V.buffer)) {
throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", opts);
}
if (isArrayBufferDetached(V.buffer)) {
throw makeException(TypeError, "is a view on a detached ArrayBuffer", opts);
}
return V;
@@ -309,17 +442,41 @@ function convertCallbackFunction(V, opts) {
// Common definitions
exports.ArrayBufferView = (V, opts) => {
exports.ArrayBufferView = (V, opts = {}) => {
if (!ArrayBuffer.isView(V)) {
throw new TypeError(_("is not a view on an ArrayBuffer object", opts));
throw makeException(TypeError, "is not a view on an ArrayBuffer or SharedArrayBuffer", opts);
}
if (!opts.allowShared && isSharedArrayBuffer(V.buffer)) {
throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", opts);
}
if (isArrayBufferDetached(V.buffer)) {
throw makeException(TypeError, "is a view on a detached ArrayBuffer", opts);
}
return V;
};
exports.BufferSource = (V, opts) => {
if (!(ArrayBuffer.isView(V) || V instanceof ArrayBuffer)) {
throw new TypeError(_("is not an ArrayBuffer object or a view on one", opts));
exports.BufferSource = (V, opts = {}) => {
if (ArrayBuffer.isView(V)) {
if (!opts.allowShared && isSharedArrayBuffer(V.buffer)) {
throw makeException(TypeError, "is a view on a SharedArrayBuffer, which is not allowed", opts);
}
if (isArrayBufferDetached(V.buffer)) {
throw makeException(TypeError, "is a view on a detached ArrayBuffer", opts);
}
return V;
}
if (!opts.allowShared && !isNonSharedArrayBuffer(V)) {
throw makeException(TypeError, "is not an ArrayBuffer or a view on one", opts);
}
if (opts.allowShared && !isSharedArrayBuffer(V) && !isNonSharedArrayBuffer(V)) {
throw makeException(TypeError, "is not an ArrayBuffer, SharedArrayBufer, or a view on one", opts);
}
if (isArrayBufferDetached(V)) {
throw makeException(TypeError, "is a detached ArrayBuffer", opts);
}
return V;

36
node_modules/webidl-conversions/package.json generated vendored
View File

@@ -1,30 +1,27 @@
{
"_from": "webidl-conversions@^4.0.2",
"_id": "webidl-conversions@4.0.2",
"_from": "webidl-conversions@^6.1.0",
"_id": "webidl-conversions@6.1.0",
"_inBundle": false,
"_integrity": "sha512-YQ+BmxuTgd6UXZW3+ICGfyqRyHXVlD5GtQr5+qjiNW7bF0cqrzX500HVXPBOvgXb5YnzDd+h0zqyv61KUD7+Sg==",
"_integrity": "sha512-qBIvFLGiBpLjfwmYAaHPXsn+ho5xZnGvyGvsarywGNc8VyQJUMHJ8OBKGGrPER0okBeMDaan4mNBlgBROxuI8w==",
"_location": "/webidl-conversions",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "webidl-conversions@^4.0.2",
"raw": "webidl-conversions@^6.1.0",
"name": "webidl-conversions",
"escapedName": "webidl-conversions",
"rawSpec": "^4.0.2",
"rawSpec": "^6.1.0",
"saveSpec": null,
"fetchSpec": "^4.0.2"
"fetchSpec": "^6.1.0"
},
"_requiredBy": [
"/domexception",
"/jsdom",
"/w3c-xmlserializer",
"/whatwg-url"
"/jsdom"
],
"_resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-4.0.2.tgz",
"_shasum": "a855980b1f0b6b359ba1d5d9fb39ae941faa63ad",
"_spec": "webidl-conversions@^4.0.2",
"_where": "F:\\projects\\p\\minifyfromhtml\\node_modules\\jsdom",
"_resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-6.1.0.tgz",
"_shasum": "9111b4d7ea80acd40f5270d666621afa78b69514",
"_spec": "webidl-conversions@^6.1.0",
"_where": "D:\\Projects\\minifyfromhtml\\node_modules\\jsdom",
"author": {
"name": "Domenic Denicola",
"email": "d@domenic.me",
@@ -37,9 +34,12 @@
"deprecated": false,
"description": "Implements the WebIDL algorithms for converting to and from JavaScript values",
"devDependencies": {
"eslint": "^3.15.0",
"mocha": "^1.21.4",
"nyc": "^10.1.2"
"eslint": "^6.8.0",
"mocha": "^7.1.1",
"nyc": "^15.0.0"
},
"engines": {
"node": ">=10.4"
},
"files": [
"lib/"
@@ -62,5 +62,5 @@
"lint": "eslint .",
"test": "mocha test/*.js"
},
"version": "4.0.2"
"version": "6.1.0"
}