robojerk/codeql-action

Update checked-in dependencies

Browse source
This commit is contained in:
github-actions[bot] 2025-04-02 12:43:14 +00:00
parent 4b72bef651
commit dbb232a3d8
1389 changed files with 209949 additions and 542 deletions
Download patch file Download diff file Expand all files Collapse all files

20
node_modules/cssstyle/LICENSE generated vendored Normal file
View file

@ -0,0 +1,20 @@
Copyright (c) Chad Walker
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

11
node_modules/cssstyle/README.md generated vendored Normal file
View file

@ -0,0 +1,11 @@
# CSSStyleDeclaration
A Node.js implementation of the CSS Object Model [`CSSStyleDeclaration` class](https://drafts.csswg.org/cssom/#the-cssstyledeclaration-interface).
## Background
This package is an extension of the `CSSStyleDeclaration` class in Nikita Vasilyev's [CSSOM](https://github.com/NV/CSSOM), with added support for modern specifications. The primary use case is for testing browser code in a Node environment.
It was originally created by Chad Walker, it is now maintained by the jsdom community.
Bug reports and pull requests are welcome.

273
node_modules/cssstyle/lib/CSSStyleDeclaration.js generated vendored Normal file
View file

@ -0,0 +1,273 @@
/*********************************************************************
* This is a fork from the CSS Style Declaration part of
* https://github.com/NV/CSSOM
********************************************************************/
'use strict';
var CSSOM = require('rrweb-cssom');
var allProperties = require('./allProperties');
var allExtraProperties = require('./allExtraProperties');
var implementedProperties = require('./implementedProperties');
var { dashedToCamelCase } = require('./parsers');
var getBasicPropertyDescriptor = require('./utils/getBasicPropertyDescriptor');
/**
* @constructor
* @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration
*/
var CSSStyleDeclaration = function CSSStyleDeclaration(onChangeCallback) {
this._values = {};
this._importants = {};
this._length = 0;
this._onChange = onChangeCallback;
this._setInProgress = false;
};
CSSStyleDeclaration.prototype = {
constructor: CSSStyleDeclaration,
/**
*
* @param {string} name
* @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-getPropertyValue
* @return {string} the value of the property if it has been explicitly set for this declaration block.
* Returns the empty string if the property has not been set.
*/
getPropertyValue: function (name) {
if (!this._values.hasOwnProperty(name)) {
return '';
}
return this._values[name].toString();
},
/**
*
* @param {string} name
* @param {string} value
* @param {string} [priority=null] "important" or null
* @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-setProperty
*/
setProperty: function (name, value, priority) {
if (value === undefined) {
return;
}
if (value === null || value === '') {
this.removeProperty(name);
return;
}
var isCustomProperty =
name.indexOf('--') === 0 ||
(typeof value === 'string' && /^var\(--[-\w]+,?.*\)$/.test(value));
if (isCustomProperty) {
this._setProperty(name, value, priority);
return;
}
var lowercaseName = name.toLowerCase();
if (!allProperties.has(lowercaseName) && !allExtraProperties.has(lowercaseName)) {
return;
}
this[lowercaseName] = value;
this._importants[lowercaseName] = priority;
},
_setProperty: function (name, value, priority) {
if (value === undefined) {
return;
}
if (value === null || value === '') {
this.removeProperty(name);
return;
}
var originalText;
if (this._onChange) {
originalText = this.cssText;
}
if (this._values[name]) {
// Property already exist. Overwrite it.
var index = Array.prototype.indexOf.call(this, name);
if (index < 0) {
this[this._length] = name;
this._length++;
}
} else {
// New property.
this[this._length] = name;
this._length++;
}
this._values[name] = value;
this._importants[name] = priority;
if (this._onChange && this.cssText !== originalText && !this._setInProgress) {
this._onChange(this.cssText);
}
},
/**
*
* @param {string} name
* @see http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-removeProperty
* @return {string} the value of the property if it has been explicitly set for this declaration block.
* Returns the empty string if the property has not been set or the property name does not correspond to a known CSS property.
*/
removeProperty: function (name) {
if (!this._values.hasOwnProperty(name)) {
return '';
}
var prevValue = this._values[name];
delete this._values[name];
delete this._importants[name];
var index = Array.prototype.indexOf.call(this, name);
if (index < 0) {
return prevValue;
}
// That's what WebKit and Opera do
Array.prototype.splice.call(this, index, 1);
// That's what Firefox does
//this[index] = ""
if (this._onChange) {
this._onChange(this.cssText);
}
return prevValue;
},
/**
*
* @param {String} name
*/
getPropertyPriority: function (name) {
return this._importants[name] || '';
},
getPropertyCSSValue: function () {
//FIXME
return;
},
/**
* element.style.overflow = "auto"
* element.style.getPropertyShorthand("overflow-x")
* -> "overflow"
*/
getPropertyShorthand: function () {
//FIXME
return;
},
isPropertyImplicit: function () {
//FIXME
return;
},
/**
* http://www.w3.org/TR/DOM-Level-2-Style/css.html#CSS-CSSStyleDeclaration-item
*/
item: function (index) {
index = parseInt(index, 10);
if (index < 0 || index >= this._length) {
return '';
}
return this[index];
},
};
Object.defineProperties(CSSStyleDeclaration.prototype, {
cssText: {
get: function () {
var properties = [];
var i;
var name;
var value;
var priority;
for (i = 0; i < this._length; i++) {
name = this[i];
value = this.getPropertyValue(name);
priority = this.getPropertyPriority(name);
if (priority !== '') {
priority = ' !' + priority;
}
properties.push([name, ': ', value, priority, ';'].join(''));
}
return properties.join(' ');
},
set: function (value) {
var i;
this._values = {};
Array.prototype.splice.call(this, 0, this._length);
this._importants = {};
var dummyRule;
try {
dummyRule = CSSOM.parse('#bogus{' + value + '}').cssRules[0].style;
} catch (err) {
// malformed css, just return
return;
}
this._setInProgress = true;
var rule_length = dummyRule.length;
var name;
for (i = 0; i < rule_length; ++i) {
name = dummyRule[i];
this.setProperty(
dummyRule[i],
dummyRule.getPropertyValue(name),
dummyRule.getPropertyPriority(name)
);
}
this._setInProgress = false;
if (this._onChange) {
this._onChange(this.cssText);
}
},
enumerable: true,
configurable: true,
},
parentRule: {
get: function () {
return null;
},
enumerable: true,
configurable: true,
},
length: {
get: function () {
return this._length;
},
/**
* This deletes indices if the new length is less then the current
* length. If the new length is more, it does nothing, the new indices
* will be undefined until set.
**/
set: function (value) {
var i;
for (i = value; i < this._length; i++) {
delete this[i];
}
this._length = value;
},
enumerable: true,
configurable: true,
},
});
require('./properties')(CSSStyleDeclaration.prototype);
allProperties.forEach(function (property) {
if (!implementedProperties.has(property)) {
var declaration = getBasicPropertyDescriptor(property);
Object.defineProperty(CSSStyleDeclaration.prototype, property, declaration);
Object.defineProperty(CSSStyleDeclaration.prototype, dashedToCamelCase(property), declaration);
}
});
allExtraProperties.forEach(function (property) {
if (!implementedProperties.has(property)) {
var declaration = getBasicPropertyDescriptor(property);
Object.defineProperty(CSSStyleDeclaration.prototype, property, declaration);
Object.defineProperty(CSSStyleDeclaration.prototype, dashedToCamelCase(property), declaration);
}
});
exports.CSSStyleDeclaration = CSSStyleDeclaration;

67
node_modules/cssstyle/lib/allExtraProperties.js generated vendored Normal file
View file

@ -0,0 +1,67 @@
'use strict';
/**
* This file contains all implemented properties that are not a part of any
* current specifications or drafts, but are handled by browsers nevertheless.
*/
var allWebkitProperties = require('./allWebkitProperties');
module.exports = new Set(
[
'background-position-x',
'background-position-y',
'background-repeat-x',
'background-repeat-y',
'color-interpolation',
'color-profile',
'color-rendering',
'css-float',
'enable-background',
'fill',
'fill-opacity',
'fill-rule',
'glyph-orientation-horizontal',
'image-rendering',
'kerning',
'marker',
'marker-end',
'marker-mid',
'marker-offset',
'marker-start',
'marks',
'pointer-events',
'shape-rendering',
'size',
'src',
'stop-color',
'stop-opacity',
'stroke',
'stroke-dasharray',
'stroke-dashoffset',
'stroke-linecap',
'stroke-linejoin',
'stroke-miterlimit',
'stroke-opacity',
'stroke-width',
'text-anchor',
'text-line-through',
'text-line-through-color',
'text-line-through-mode',
'text-line-through-style',
'text-line-through-width',
'text-overline',
'text-overline-color',
'text-overline-mode',
'text-overline-style',
'text-overline-width',
'text-rendering',
'text-underline',
'text-underline-color',
'text-underline-mode',
'text-underline-style',
'text-underline-width',
'unicode-range',
'vector-effect',
].concat(allWebkitProperties)
);

529
node_modules/cssstyle/lib/allProperties.js generated vendored Normal file
View file

@ -0,0 +1,529 @@
'use strict';
// autogenerated - 2024-09-07
// https://www.w3.org/Style/CSS/all-properties.en.html
module.exports = new Set([
'-webkit-line-clamp',
'accent-color',
'align-content',
'align-items',
'align-self',
'alignment-baseline',
'all',
'anchor-name',
'anchor-scope',
'animation',
'animation-composition',
'animation-delay',
'animation-direction',
'animation-duration',
'animation-fill-mode',
'animation-iteration-count',
'animation-name',
'animation-play-state',
'animation-range',
'animation-range-end',
'animation-range-start',
'animation-timeline',
'animation-timing-function',
'appearance',
'aspect-ratio',
'azimuth',
'backface-visibility',
'background',
'background-attachment',
'background-blend-mode',
'background-clip',
'background-color',
'background-image',
'background-origin',
'background-position',
'background-repeat',
'background-size',
'baseline-shift',
'baseline-source',
'block-ellipsis',
'block-size',
'bookmark-label',
'bookmark-level',
'bookmark-state',
'border',
'border-block',
'border-block-color',
'border-block-end',
'border-block-end-color',
'border-block-end-style',
'border-block-end-width',
'border-block-start',
'border-block-start-color',
'border-block-start-style',
'border-block-start-width',
'border-block-style',
'border-block-width',
'border-bottom',
'border-bottom-color',
'border-bottom-left-radius',
'border-bottom-right-radius',
'border-bottom-style',
'border-bottom-width',
'border-boundary',
'border-collapse',
'border-color',
'border-end-end-radius',
'border-end-start-radius',
'border-image',
'border-image-outset',
'border-image-repeat',
'border-image-slice',
'border-image-source',
'border-image-width',
'border-inline',
'border-inline-color',
'border-inline-end',
'border-inline-end-color',
'border-inline-end-style',
'border-inline-end-width',
'border-inline-start',
'border-inline-start-color',
'border-inline-start-style',
'border-inline-start-width',
'border-inline-style',
'border-inline-width',
'border-left',
'border-left-color',
'border-left-style',
'border-left-width',
'border-radius',
'border-right',
'border-right-color',
'border-right-style',
'border-right-width',
'border-spacing',
'border-start-end-radius',
'border-start-start-radius',
'border-style',
'border-top',
'border-top-color',
'border-top-left-radius',
'border-top-right-radius',
'border-top-style',
'border-top-width',
'border-width',
'bottom',
'box-decoration-break',
'box-shadow',
'box-sizing',
'box-snap',
'break-after',
'break-before',
'break-inside',
'caption-side',
'caret',
'caret-color',
'caret-shape',
'clear',
'clip',
'clip-path',
'clip-rule',
'color',
'color-adjust',
'color-interpolation-filters',
'color-scheme',
'column-count',
'column-fill',
'column-gap',
'column-rule',
'column-rule-color',
'column-rule-style',
'column-rule-width',
'column-span',
'column-width',
'columns',
'contain',
'contain-intrinsic-block-size',
'contain-intrinsic-height',
'contain-intrinsic-inline-size',
'contain-intrinsic-size',
'contain-intrinsic-width',
'container',
'container-name',
'container-type',
'content',
'content-visibility',
'continue',
'counter-increment',
'counter-reset',
'counter-set',
'cue',
'cue-after',
'cue-before',
'cursor',
'direction',
'display',
'dominant-baseline',
'elevation',
'empty-cells',
'filter',
'flex',
'flex-basis',
'flex-direction',
'flex-flow',
'flex-grow',
'flex-shrink',
'flex-wrap',
'float',
'flood-color',
'flood-opacity',
'flow-from',
'flow-into',
'font',
'font-family',
'font-feature-settings',
'font-kerning',
'font-language-override',
'font-optical-sizing',
'font-palette',
'font-size',
'font-size-adjust',
'font-stretch',
'font-style',
'font-synthesis',
'font-synthesis-position',
'font-synthesis-small-caps',
'font-synthesis-style',
'font-synthesis-weight',
'font-variant',
'font-variant-alternates',
'font-variant-caps',
'font-variant-east-asian',
'font-variant-emoji',
'font-variant-ligatures',
'font-variant-numeric',
'font-variant-position',
'font-variation-settings',
'font-weight',
'font-width',
'footnote-display',
'footnote-policy',
'forced-color-adjust',
'gap',
'glyph-orientation-vertical',
'grid',
'grid-area',
'grid-auto-columns',
'grid-auto-flow',
'grid-auto-rows',
'grid-column',
'grid-column-end',
'grid-column-start',
'grid-row',
'grid-row-end',
'grid-row-start',
'grid-template',
'grid-template-areas',
'grid-template-columns',
'grid-template-rows',
'hanging-punctuation',
'height',
'hyphenate-character',
'hyphenate-limit-chars',
'hyphenate-limit-last',
'hyphenate-limit-lines',
'hyphenate-limit-zone',
'hyphens',
'image-orientation',
'image-rendering',
'image-resolution',
'initial-letter',
'initial-letter-align',
'initial-letter-wrap',
'inline-size',
'inline-sizing',
'inset',
'inset-area',
'inset-block',
'inset-block-end',
'inset-block-start',
'inset-inline',
'inset-inline-end',
'inset-inline-start',
'isolation',
'justify-content',
'justify-items',
'justify-self',
'left',
'letter-spacing',
'lighting-color',
'line-break',
'line-clamp',
'line-fit-edge',
'line-grid',
'line-height',
'line-padding',
'line-snap',
'list-style',
'list-style-image',
'list-style-position',
'list-style-type',
'margin',
'margin-block',
'margin-block-end',
'margin-block-start',
'margin-bottom',
'margin-inline',
'margin-inline-end',
'margin-inline-start',
'margin-left',
'margin-right',
'margin-top',
'margin-trim',
'marker-side',
'mask',
'mask-border',
'mask-border-mode',
'mask-border-outset',
'mask-border-repeat',
'mask-border-slice',
'mask-border-source',
'mask-border-width',
'mask-clip',
'mask-composite',
'mask-image',
'mask-mode',
'mask-origin',
'mask-position',
'mask-repeat',
'mask-size',
'mask-type',
'max-block-size',
'max-height',
'max-inline-size',
'max-lines',
'max-width',
'min-block-size',
'min-height',
'min-inline-size',
'min-intrinsic-sizing',
'min-width',
'mix-blend-mode',
'nav-down',
'nav-left',
'nav-right',
'nav-up',
'object-fit',
'object-position',
'offset',
'offset-anchor',
'offset-distance',
'offset-path',
'offset-position',
'offset-rotate',
'opacity',
'order',
'orphans',
'outline',
'outline-color',
'outline-offset',
'outline-style',
'outline-width',
'overflow',
'overflow-anchor',
'overflow-block',
'overflow-clip-margin',
'overflow-clip-margin-block',
'overflow-clip-margin-block-end',
'overflow-clip-margin-block-start',
'overflow-clip-margin-bottom',
'overflow-clip-margin-inline',
'overflow-clip-margin-inline-end',
'overflow-clip-margin-inline-start',
'overflow-clip-margin-left',
'overflow-clip-margin-right',
'overflow-clip-margin-top',
'overflow-inline',
'overflow-wrap',
'overflow-x',
'overflow-y',
'padding',
'padding-block',
'padding-block-end',
'padding-block-start',
'padding-bottom',
'padding-inline',
'padding-inline-end',
'padding-inline-start',
'padding-left',
'padding-right',
'padding-top',
'page',
'page-break-after',
'page-break-before',
'page-break-inside',
'pause',
'pause-after',
'pause-before',
'perspective',
'perspective-origin',
'pitch',
'pitch-range',
'place-content',
'place-items',
'place-self',
'play-during',
'position',
'position-anchor',
'position-try',
'position-try-options',
'position-try-order',
'print-color-adjust',
'quotes',
'region-fragment',
'resize',
'rest',
'rest-after',
'rest-before',
'richness',
'right',
'rotate',
'row-gap',
'ruby-align',
'ruby-merge',
'ruby-overhang',
'ruby-position',
'running',
'scale',
'scroll-behavior',
'scroll-margin',
'scroll-margin-block',
'scroll-margin-block-end',
'scroll-margin-block-start',
'scroll-margin-bottom',
'scroll-margin-inline',
'scroll-margin-inline-end',
'scroll-margin-inline-start',
'scroll-margin-left',
'scroll-margin-right',
'scroll-margin-top',
'scroll-padding',
'scroll-padding-block',
'scroll-padding-block-end',
'scroll-padding-block-start',
'scroll-padding-bottom',
'scroll-padding-inline',
'scroll-padding-inline-end',
'scroll-padding-inline-start',
'scroll-padding-left',
'scroll-padding-right',
'scroll-padding-top',
'scroll-snap-align',
'scroll-snap-stop',
'scroll-snap-type',
'scroll-timeline',
'scroll-timeline-axis',
'scroll-timeline-name',
'scrollbar-color',
'scrollbar-gutter',
'scrollbar-width',
'shape-image-threshold',
'shape-inside',
'shape-margin',
'shape-outside',
'spatial-navigation-action',
'spatial-navigation-contain',
'spatial-navigation-function',
'speak',
'speak-as',
'speak-header',
'speak-numeral',
'speak-punctuation',
'speech-rate',
'stress',
'string-set',
'tab-size',
'table-layout',
'text-align',
'text-align-all',
'text-align-last',
'text-autospace',
'text-box',
'text-box-edge',
'text-box-trim',
'text-combine-upright',
'text-decoration',
'text-decoration-color',
'text-decoration-line',
'text-decoration-skip',
'text-decoration-skip-box',
'text-decoration-skip-ink',
'text-decoration-skip-inset',
'text-decoration-skip-self',
'text-decoration-skip-spaces',
'text-decoration-style',
'text-decoration-thickness',
'text-emphasis',
'text-emphasis-color',
'text-emphasis-position',
'text-emphasis-skip',
'text-emphasis-style',
'text-group-align',
'text-indent',
'text-justify',
'text-orientation',
'text-overflow',
'text-shadow',
'text-spacing',
'text-spacing-trim',
'text-transform',
'text-underline-offset',
'text-underline-position',
'text-wrap',
'text-wrap-mode',
'text-wrap-style',
'timeline-scope',
'top',
'transform',
'transform-box',
'transform-origin',
'transform-style',
'transition',
'transition-delay',
'transition-duration',
'transition-property',
'transition-timing-function',
'translate',
'unicode-bidi',
'user-select',
'vertical-align',
'view-timeline',
'view-timeline-axis',
'view-timeline-inset',
'view-timeline-name',
'view-transition-name',
'visibility',
'voice-balance',
'voice-duration',
'voice-family',
'voice-pitch',
'voice-range',
'voice-rate',
'voice-stress',
'voice-volume',
'volume',
'white-space',
'white-space-collapse',
'white-space-trim',
'widows',
'width',
'will-change',
'word-break',
'word-space-transform',
'word-spacing',
'word-wrap',
'wrap-after',
'wrap-before',
'wrap-flow',
'wrap-inside',
'wrap-through',
'writing-mode',
'z-index',
]);

194
node_modules/cssstyle/lib/allWebkitProperties.js generated vendored Normal file
View file

@ -0,0 +1,194 @@
'use strict';
/**
* This file contains all implemented properties that are not a part of any
* current specifications or drafts, but are handled by browsers nevertheless.
*/
module.exports = [
'animation',
'animation-delay',
'animation-direction',
'animation-duration',
'animation-fill-mode',
'animation-iteration-count',
'animation-name',
'animation-play-state',
'animation-timing-function',
'appearance',
'aspect-ratio',
'backface-visibility',
'background-clip',
'background-composite',
'background-origin',
'background-size',
'border-after',
'border-after-color',
'border-after-style',
'border-after-width',
'border-before',
'border-before-color',
'border-before-style',
'border-before-width',
'border-end',
'border-end-color',
'border-end-style',
'border-end-width',
'border-fit',
'border-horizontal-spacing',
'border-image',
'border-radius',
'border-start',
'border-start-color',
'border-start-style',
'border-start-width',
'border-vertical-spacing',
'box-align',
'box-direction',
'box-flex',
'box-flex-group',
'box-lines',
'box-ordinal-group',
'box-orient',
'box-pack',
'box-reflect',
'box-shadow',
'color-correction',
'column-axis',
'column-break-after',
'column-break-before',
'column-break-inside',
'column-count',
'column-gap',
'column-rule',
'column-rule-color',
'column-rule-style',
'column-rule-width',
'columns',
'column-span',
'column-width',
'filter',
'flex-align',
'flex-direction',
'flex-flow',
'flex-item-align',
'flex-line-pack',
'flex-order',
'flex-pack',
'flex-wrap',
'flow-from',
'flow-into',
'font-feature-settings',
'font-kerning',
'font-size-delta',
'font-smoothing',
'font-variant-ligatures',
'highlight',
'hyphenate-character',
'hyphenate-limit-after',
'hyphenate-limit-before',
'hyphenate-limit-lines',
'hyphens',
'line-align',
'line-box-contain',
'line-break',
'line-clamp',
'line-grid',
'line-snap',
'locale',
'logical-height',
'logical-width',
'margin-after',
'margin-after-collapse',
'margin-before',
'margin-before-collapse',
'margin-bottom-collapse',
'margin-collapse',
'margin-end',
'margin-start',
'margin-top-collapse',
'marquee',
'marquee-direction',
'marquee-increment',
'marquee-repetition',
'marquee-speed',
'marquee-style',
'mask',
'mask-attachment',
'mask-box-image',
'mask-box-image-outset',
'mask-box-image-repeat',
'mask-box-image-slice',
'mask-box-image-source',
'mask-box-image-width',
'mask-clip',
'mask-composite',
'mask-image',
'mask-origin',
'mask-position',
'mask-position-x',
'mask-position-y',
'mask-repeat',
'mask-repeat-x',
'mask-repeat-y',
'mask-size',
'match-nearest-mail-blockquote-color',
'max-logical-height',
'max-logical-width',
'min-logical-height',
'min-logical-width',
'nbsp-mode',
'overflow-scrolling',
'padding-after',
'padding-before',
'padding-end',
'padding-start',
'perspective',
'perspective-origin',
'perspective-origin-x',
'perspective-origin-y',
'print-color-adjust',
'region-break-after',
'region-break-before',
'region-break-inside',
'region-overflow',
'rtl-ordering',
'svg-shadow',
'tap-highlight-color',
'text-combine',
'text-decorations-in-effect',
'text-emphasis',
'text-emphasis-color',
'text-emphasis-position',
'text-emphasis-style',
'text-fill-color',
'text-orientation',
'text-security',
'text-size-adjust',
'text-stroke',
'text-stroke-color',
'text-stroke-width',
'transform',
'transform-origin',
'transform-origin-x',
'transform-origin-y',
'transform-origin-z',
'transform-style',
'transition',
'transition-delay',
'transition-duration',
'transition-property',
'transition-timing-function',
'user-drag',
'user-modify',
'user-select',
'wrap',
'wrap-flow',
'wrap-margin',
'wrap-padding',
'wrap-shape-inside',
'wrap-shape-outside',
'wrap-through',
'writing-mode',
'zoom',
].map((prop) => 'webkit-' + prop);

6
node_modules/cssstyle/lib/constants.js generated vendored Normal file
View file

@ -0,0 +1,6 @@
'use strict';
module.exports.POSITION_AT_SHORTHAND = {
first: 0,
second: 1,
};

86
node_modules/cssstyle/lib/implementedProperties.js generated vendored Normal file
View file

@ -0,0 +1,86 @@
'use strict';
// autogenerated - 2025-03-09
// https://www.w3.org/Style/CSS/all-properties.en.html
module.exports = new Set([
"azimuth",
"background",
"background-attachment",
"background-color",
"background-image",
"background-position",
"background-repeat",
"border",
"border-bottom",
"border-bottom-color",
"border-bottom-style",
"border-bottom-width",
"border-collapse",
"border-color",
"border-left",
"border-left-color",
"border-left-style",
"border-left-width",
"border-right",
"border-right-color",
"border-right-style",
"border-right-width",
"border-spacing",
"border-style",
"border-top",
"border-top-color",
"border-top-style",
"border-top-width",
"border-width",
"bottom",
"clear",
"clip",
"color",
"css-float",
"flex",
"flex-basis",
"flex-grow",
"flex-shrink",
"float",
"flood-color",
"font",
"font-family",
"font-size",
"font-style",
"font-variant",
"font-weight",
"height",
"left",
"lighting-color",
"line-height",
"margin",
"margin-bottom",
"margin-left",
"margin-right",
"margin-top",
"opacity",
"outline-color",
"padding",
"padding-bottom",
"padding-left",
"padding-right",
"padding-top",
"right",
"stop-color",
"text-line-through-color",
"text-overline-color",
"text-underline-color",
"top",
"webkit-border-after-color",
"webkit-border-before-color",
"webkit-border-end-color",
"webkit-border-start-color",
"webkit-column-rule-color",
"webkit-match-nearest-mail-blockquote-color",
"webkit-tap-highlight-color",
"webkit-text-emphasis-color",
"webkit-text-fill-color",
"webkit-text-stroke-color",
"width"
]);

152
node_modules/cssstyle/lib/named_colors.json generated vendored Normal file
View file

@ -0,0 +1,152 @@
[
"aliceblue",
"antiquewhite",
"aqua",
"aquamarine",
"azure",
"beige",
"bisque",
"black",
"blanchedalmond",
"blue",
"blueviolet",
"brown",
"burlywood",
"cadetblue",
"chartreuse",
"chocolate",
"coral",
"cornflowerblue",
"cornsilk",
"crimson",
"cyan",
"darkblue",
"darkcyan",
"darkgoldenrod",
"darkgray",
"darkgreen",
"darkgrey",
"darkkhaki",
"darkmagenta",
"darkolivegreen",
"darkorange",
"darkorchid",
"darkred",
"darksalmon",
"darkseagreen",
"darkslateblue",
"darkslategray",
"darkslategrey",
"darkturquoise",
"darkviolet",
"deeppink",
"deepskyblue",
"dimgray",
"dimgrey",
"dodgerblue",
"firebrick",
"floralwhite",
"forestgreen",
"fuchsia",
"gainsboro",
"ghostwhite",
"gold",
"goldenrod",
"gray",
"green",
"greenyellow",
"grey",
"honeydew",
"hotpink",
"indianred",
"indigo",
"ivory",
"khaki",
"lavender",
"lavenderblush",
"lawngreen",
"lemonchiffon",
"lightblue",
"lightcoral",
"lightcyan",
"lightgoldenrodyellow",
"lightgray",
"lightgreen",
"lightgrey",
"lightpink",
"lightsalmon",
"lightseagreen",
"lightskyblue",
"lightslategray",
"lightslategrey",
"lightsteelblue",
"lightyellow",
"lime",
"limegreen",
"linen",
"magenta",
"maroon",
"mediumaquamarine",
"mediumblue",
"mediumorchid",
"mediumpurple",
"mediumseagreen",
"mediumslateblue",
"mediumspringgreen",
"mediumturquoise",
"mediumvioletred",
"midnightblue",
"mintcream",
"mistyrose",
"moccasin",
"navajowhite",
"navy",
"oldlace",
"olive",
"olivedrab",
"orange",
"orangered",
"orchid",
"palegoldenrod",
"palegreen",
"paleturquoise",
"palevioletred",
"papayawhip",
"peachpuff",
"peru",
"pink",
"plum",
"powderblue",
"purple",
"rebeccapurple",
"red",
"rosybrown",
"royalblue",
"saddlebrown",
"salmon",
"sandybrown",
"seagreen",
"seashell",
"sienna",
"silver",
"skyblue",
"slateblue",
"slategray",
"slategrey",
"snow",
"springgreen",
"steelblue",
"tan",
"teal",
"thistle",
"tomato",
"turquoise",
"violet",
"wheat",
"white",
"whitesmoke",
"yellow",
"yellowgreen",
"transparent",
"currentcolor"
]

646
node_modules/cssstyle/lib/parsers.js generated vendored Normal file
View file

@ -0,0 +1,646 @@
/*********************************************************************
* These are commonly used parsers for CSS Values they take a string *
* to parse and return a string after it's been converted, if needed *
********************************************************************/
'use strict';
const { resolve: resolveColor, utils } = require('@asamuzakjp/css-color');
const { cssCalc, isColor, isGradient, splitValue } = utils;
exports.TYPES = {
INTEGER: 1,
NUMBER: 2,
LENGTH: 3,
PERCENT: 4,
URL: 5,
COLOR: 6,
STRING: 7,
ANGLE: 8,
KEYWORD: 9,
NULL_OR_EMPTY_STR: 10,
CALC: 11,
VAR: 12,
GRADIENT: 13,
};
// regular expressions
var DIGIT = '(?:0|[1-9]\\d*)';
var NUMBER = `[+-]?(?:${DIGIT}(?:\\.\\d*)?|\\.\\d+)(?:e-?${DIGIT})?`;
var integerRegEx = new RegExp(`^[+-]?${DIGIT}$`);
var numberRegEx = new RegExp(`^${NUMBER}$`);
var lengthRegEx = new RegExp(
`^${NUMBER}(?:[cm]m|[dls]?v(?:[bhiw]|max|min)|in|p[ctx]|q|r?(?:[cl]h|cap|e[mx]|ic))$`
);
var percentRegEx = new RegExp(`^${NUMBER}%$`);
var angleRegEx = new RegExp(`^${NUMBER}(?:deg|g?rad|turn)$`);
var urlRegEx = /^url\(\s*([^)]*)\s*\)$/;
var stringRegEx = /^("[^"]*"|'[^']*')$/;
var varRegEx = /^var\(|(?<=[*/\s(])var\(/;
var calcRegEx =
/^(?:a?(?:cos|sin|tan)|abs|atan2|calc|clamp|exp|hypot|log|max|min|mod|pow|rem|round|sign|sqrt)\(/;
// This will return one of the above types based on the passed in string
exports.valueType = function valueType(val) {
if (val === '' || val === null) {
return exports.TYPES.NULL_OR_EMPTY_STR;
}
if (typeof val === 'number') {
val = val.toString();
}
if (typeof val !== 'string') {
return undefined;
}
if (integerRegEx.test(val)) {
return exports.TYPES.INTEGER;
}
if (numberRegEx.test(val)) {
return exports.TYPES.NUMBER;
}
if (lengthRegEx.test(val)) {
return exports.TYPES.LENGTH;
}
if (percentRegEx.test(val)) {
return exports.TYPES.PERCENT;
}
if (urlRegEx.test(val)) {
return exports.TYPES.URL;
}
if (varRegEx.test(val)) {
return exports.TYPES.VAR;
}
if (calcRegEx.test(val)) {
return exports.TYPES.CALC;
}
if (stringRegEx.test(val)) {
return exports.TYPES.STRING;
}
if (angleRegEx.test(val)) {
return exports.TYPES.ANGLE;
}
if (isColor(val)) {
return exports.TYPES.COLOR;
}
if (isGradient(val)) {
return exports.TYPES.GRADIENT;
}
switch (val.toLowerCase()) {
// the following are deprecated in CSS3
case 'activeborder':
case 'activecaption':
case 'appworkspace':
case 'background':
case 'buttonface':
case 'buttonhighlight':
case 'buttonshadow':
case 'buttontext':
case 'captiontext':
case 'graytext':
case 'highlight':
case 'highlighttext':
case 'inactiveborder':
case 'inactivecaption':
case 'inactivecaptiontext':
case 'infobackground':
case 'infotext':
case 'menu':
case 'menutext':
case 'scrollbar':
case 'threeddarkshadow':
case 'threedface':
case 'threedhighlight':
case 'threedlightshadow':
case 'threedshadow':
case 'window':
case 'windowframe':
case 'windowtext':
return exports.TYPES.COLOR;
default:
return exports.TYPES.KEYWORD;
}
};
exports.parseInteger = function parseInteger(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.INTEGER) {
return undefined;
}
return String(parseInt(val, 10));
};
exports.parseNumber = function parseNumber(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.NUMBER && type !== exports.TYPES.INTEGER) {
return undefined;
}
return String(parseFloat(val));
};
exports.parseLength = function parseLength(val) {
if (val === 0 || val === '0') {
return '0px';
}
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.LENGTH) {
return undefined;
}
return val;
};
exports.parsePercent = function parsePercent(val) {
if (val === 0 || val === '0') {
return '0%';
}
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.PERCENT) {
return undefined;
}
return val;
};
// either a length or a percent
exports.parseMeasurement = function parseMeasurement(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.VAR) {
return val;
}
if (type === exports.TYPES.CALC) {
return cssCalc(val, {
format: 'specifiedValue',
});
}
var length = exports.parseLength(val);
if (length !== undefined) {
return length;
}
return exports.parsePercent(val);
};
exports.parseInheritingMeasurement = function parseInheritingMeasurement(v) {
if (String(v).toLowerCase() === 'auto') {
return 'auto';
}
if (String(v).toLowerCase() === 'inherit') {
return 'inherit';
}
return exports.parseMeasurement(v);
};
exports.parseUrl = function parseUrl(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
var res = urlRegEx.exec(val);
// does it match the regex?
if (!res) {
return undefined;
}
var str = res[1];
// if it starts with single or double quotes, does it end with the same?
if ((str[0] === '"' || str[0] === "'") && str[0] !== str[str.length - 1]) {
return undefined;
}
if (str[0] === '"' || str[0] === "'") {
str = str.substr(1, str.length - 2);
}
var i;
for (i = 0; i < str.length; i++) {
switch (str[i]) {
case '(':
case ')':
case ' ':
case '\t':
case '\n':
case "'":
case '"':
return undefined;
case '\\':
i++;
break;
}
}
return 'url(' + str + ')';
};
exports.parseString = function parseString(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.STRING) {
return undefined;
}
var i;
for (i = 1; i < val.length - 1; i++) {
switch (val[i]) {
case val[0]:
return undefined;
case '\\':
i++;
while (i < val.length - 1 && /[0-9A-Fa-f]/.test(val[i])) {
i++;
}
break;
}
}
if (i >= val.length) {
return undefined;
}
return val;
};
exports.parseColor = function parseColor(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (/^[a-z]+$/i.test(val) && type === exports.TYPES.COLOR) {
return val;
}
var res = resolveColor(val, {
format: 'specifiedValue',
});
if (res) {
return res;
}
return undefined;
};
exports.parseAngle = function parseAngle(val) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.ANGLE) {
return undefined;
}
var res = angleRegEx.exec(val);
var flt = parseFloat(res[1]);
if (res[2] === 'rad') {
flt *= 180 / Math.PI;
} else if (res[2] === 'grad') {
flt *= 360 / 400;
}
while (flt < 0) {
flt += 360;
}
while (flt > 360) {
flt -= 360;
}
return flt + 'deg';
};
exports.parseKeyword = function parseKeyword(val, valid_keywords) {
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
return val;
}
if (type !== exports.TYPES.KEYWORD) {
return undefined;
}
val = val.toString().toLowerCase();
var i;
for (i = 0; i < valid_keywords.length; i++) {
if (valid_keywords[i].toLowerCase() === val) {
return valid_keywords[i];
}
}
return undefined;
};
exports.parseImage = function parseImage(val) {
if (/^(?:none|inherit)$/i.test(val)) {
return val;
}
var type = exports.valueType(val);
if (type === exports.TYPES.NULL_OR_EMPTY_STR || type === exports.TYPES.VAR) {
return val;
}
var values = splitValue(val, ',');
var isImage = !!values.length;
var i;
for (i = 0; i < values.length; i++) {
var image = values[i];
var t = exports.valueType(image);
if (t === exports.TYPES.NULL_OR_EMPTY_STR) {
return image;
}
if (t === exports.TYPES.GRADIENT || /^(?:none|inherit)$/i.test(image)) {
continue;
}
var imageUrl = exports.parseUrl(image);
if (exports.valueType(imageUrl) === exports.TYPES.URL) {
values[i] = imageUrl;
} else {
isImage = false;
break;
}
}
if (isImage) {
return values.join(', ');
}
return undefined;
};
// utility to translate from border-width to borderWidth
var dashedToCamelCase = function (dashed) {
var i;
var camel = '';
var nextCap = false;
for (i = 0; i < dashed.length; i++) {
if (dashed[i] !== '-') {
camel += nextCap ? dashed[i].toUpperCase() : dashed[i];
nextCap = false;
} else {
nextCap = true;
}
}
return camel;
};
exports.dashedToCamelCase = dashedToCamelCase;
var is_space = /\s/;
var opening_deliminators = ['"', "'", '('];
var closing_deliminators = ['"', "'", ')'];
// this splits on whitespace, but keeps quoted and parened parts together
var getParts = function (str) {
var deliminator_stack = [];
var length = str.length;
var i;
var parts = [];
var current_part = '';
var opening_index;
var closing_index;
for (i = 0; i < length; i++) {
opening_index = opening_deliminators.indexOf(str[i]);
closing_index = closing_deliminators.indexOf(str[i]);
if (is_space.test(str[i])) {
if (deliminator_stack.length === 0) {
if (current_part !== '') {
parts.push(current_part);
}
current_part = '';
} else {
current_part += str[i];
}
} else {
if (str[i] === '\\') {
i++;
current_part += str[i];
} else {
current_part += str[i];
if (
closing_index !== -1 &&
closing_index === deliminator_stack[deliminator_stack.length - 1]
) {
deliminator_stack.pop();
} else if (opening_index !== -1) {
deliminator_stack.push(opening_index);
}
}
}
}
if (current_part !== '') {
parts.push(current_part);
}
return parts;
};
/*
* this either returns undefined meaning that it isn't valid
* or returns an object where the keys are dashed short
* hand properties and the values are the values to set
* on them
*/
exports.shorthandParser = function parse(v, shorthand_for) {
var obj = {};
var type = exports.valueType(v);
if (type === exports.TYPES.NULL_OR_EMPTY_STR) {
Object.keys(shorthand_for).forEach(function (property) {
obj[property] = '';
});
return obj;
}
if (typeof v === 'number') {
v = v.toString();
}
if (typeof v !== 'string') {
return undefined;
}
if (v.toLowerCase() === 'inherit') {
return {};
}
var parts = getParts(v);
var valid = true;
parts.forEach(function (part, i) {
var part_valid = false;
Object.keys(shorthand_for).forEach(function (property) {
if (shorthand_for[property].isValid(part, i)) {
part_valid = true;
obj[property] = part;
}
});
valid = valid && part_valid;
});
if (!valid) {
return undefined;
}
return obj;
};
exports.shorthandSetter = function (property, shorthand_for) {
return function (v) {
var obj = exports.shorthandParser(v, shorthand_for);
if (obj === undefined) {
return;
}
//console.log('shorthandSetter for:', property, 'obj:', obj);
Object.keys(obj).forEach(function (subprop) {
// in case subprop is an implicit property, this will clear
// *its* subpropertiesX
var camel = dashedToCamelCase(subprop);
this[camel] = obj[subprop];
// in case it gets translated into something else (0 -> 0px)
obj[subprop] = this[camel];
this.removeProperty(subprop);
// don't add in empty properties
if (obj[subprop] !== '') {
this._values[subprop] = obj[subprop];
}
}, this);
Object.keys(shorthand_for).forEach(function (subprop) {
if (!obj.hasOwnProperty(subprop)) {
this.removeProperty(subprop);
delete this._values[subprop];
}
}, this);
// in case the value is something like 'none' that removes all values,
// check that the generated one is not empty, first remove the property
// if it already exists, then call the shorthandGetter, if it's an empty
// string, don't set the property
this.removeProperty(property);
var calculated = exports.shorthandGetter(property, shorthand_for).call(this);
if (calculated !== '') {
this._setProperty(property, calculated);
}
};
};
exports.shorthandGetter = function (property, shorthand_for) {
return function () {
if (this._values[property] !== undefined) {
return this.getPropertyValue(property);
}
return Object.keys(shorthand_for)
.map(function (subprop) {
return this.getPropertyValue(subprop);
}, this)
.filter(function (value) {
return value !== '';
})
.join(' ');
};
};
// isValid(){1,4} | inherit
// if one, it applies to all
// if two, the first applies to the top and bottom, and the second to left and right
// if three, the first applies to the top, the second to left and right, the third bottom
// if four, top, right, bottom, left
exports.implicitSetter = function (property_before, property_after, isValid, parser) {
property_after = property_after || '';
if (property_after !== '') {
property_after = '-' + property_after;
}
var part_names = ['top', 'right', 'bottom', 'left'];
return function (v) {
if (typeof v === 'number') {
v = v.toString();
}
if (typeof v !== 'string') {
return undefined;
}
var parts;
if (v.toLowerCase() === 'inherit' || v === '') {
parts = [v];
} else {
parts = getParts(v);
}
if (parts.length < 1 || parts.length > 4) {
return undefined;
}
if (!parts.every(isValid)) {
return undefined;
}
parts = parts.map(function (part) {
return parser(part);
});
this._setProperty(property_before + property_after, parts.join(' '));
if (parts.length === 1) {
parts[1] = parts[0];
}
if (parts.length === 2) {
parts[2] = parts[0];
}
if (parts.length === 3) {
parts[3] = parts[1];
}
for (var i = 0; i < 4; i++) {
var property = property_before + '-' + part_names[i] + property_after;
this.removeProperty(property);
if (parts[i] !== '') {
this._values[property] = parts[i];
}
}
return v;
};
};
//
// Companion to implicitSetter, but for the individual parts.
// This sets the individual value, and checks to see if all four
// sub-parts are set. If so, it sets the shorthand version and removes
// the individual parts from the cssText.
//
exports.subImplicitSetter = function (prefix, part, isValid, parser) {
var property = prefix + '-' + part;
var subparts = [prefix + '-top', prefix + '-right', prefix + '-bottom', prefix + '-left'];
return function (v) {
if (typeof v === 'number') {
v = v.toString();
}
if (v === null) {
v = '';
}
if (typeof v !== 'string') {
return undefined;
}
if (!isValid(v)) {
return undefined;
}
v = parser(v);
this._setProperty(property, v);
var combinedPriority = this.getPropertyPriority(prefix);
var parts = subparts.map((subpart) => this._values[subpart]);
var priorities = subparts.map((subpart) => this.getPropertyPriority(subpart));
// Combine into a single property if all values are set and have the same priority
if (
parts.every((p) => p !== '' && p != null) &&
priorities.every((p) => p === priorities[0]) &&
priorities[0] === combinedPriority
) {
for (var i = 0; i < subparts.length; i++) {
this.removeProperty(subparts[i]);
this._values[subparts[i]] = parts[i];
}
this._setProperty(prefix, parts.join(' '), priorities[0]);
} else {
this.removeProperty(prefix);
for (var j = 0; j < subparts.length; j++) {
// The property we're setting won't be important, the rest will either keep their priority or inherit it from the combined property
var priority = subparts[j] === property ? '' : priorities[j] || combinedPriority;
this._setProperty(subparts[j], parts[j], priority);
}
}
return v;
};
};
var camel_to_dashed = /[A-Z]/g;
var first_segment = /^\([^-]\)-/;
var vendor_prefixes = ['o', 'moz', 'ms', 'webkit'];
exports.camelToDashed = function (camel_case) {
var match;
var dashed = camel_case.replace(camel_to_dashed, '-$&').toLowerCase();
match = dashed.match(first_segment);
if (match && vendor_prefixes.indexOf(match[1]) !== -1) {
dashed = '-' + dashed;
}
return dashed;
};

1672
node_modules/cssstyle/lib/properties.js generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

64
node_modules/cssstyle/lib/properties/azimuth.js generated vendored Normal file
View file

@ -0,0 +1,64 @@
'use strict';
var parsers = require('../parsers');
module.exports.definition = {
set: function (v) {
var valueType = parsers.valueType(v);
if (valueType === parsers.TYPES.ANGLE) {
return this._setProperty('azimuth', parsers.parseAngle(v));
}
if (valueType === parsers.TYPES.KEYWORD) {
var keywords = v.toLowerCase().trim().split(/\s+/);
var hasBehind = false;
if (keywords.length > 2) {
return;
}
var behindIndex = keywords.indexOf('behind');
hasBehind = behindIndex !== -1;
if (keywords.length === 2) {
if (!hasBehind) {
return;
}
keywords.splice(behindIndex, 1);
}
if (keywords[0] === 'leftwards' || keywords[0] === 'rightwards') {
if (hasBehind) {
return;
}
return this._setProperty('azimuth', keywords[0]);
}
if (keywords[0] === 'behind') {
return this._setProperty('azimuth', '180deg');
}
switch (keywords[0]) {
case 'left-side':
return this._setProperty('azimuth', '270deg');
case 'far-left':
return this._setProperty('azimuth', (hasBehind ? 240 : 300) + 'deg');
case 'left':
return this._setProperty('azimuth', (hasBehind ? 220 : 320) + 'deg');
case 'center-left':
return this._setProperty('azimuth', (hasBehind ? 200 : 340) + 'deg');
case 'center':
return this._setProperty('azimuth', (hasBehind ? 180 : 0) + 'deg');
case 'center-right':
return this._setProperty('azimuth', (hasBehind ? 160 : 20) + 'deg');
case 'right':
return this._setProperty('azimuth', (hasBehind ? 140 : 40) + 'deg');
case 'far-right':
return this._setProperty('azimuth', (hasBehind ? 120 : 60) + 'deg');
case 'right-side':
return this._setProperty('azimuth', '90deg');
default:
return;
}
}
},
get: function () {
return this.getPropertyValue('azimuth');
},
enumerable: true,
configurable: true,
};

19
node_modules/cssstyle/lib/properties/background.js generated vendored Normal file
View file

@ -0,0 +1,19 @@
'use strict';
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'background-color': require('./backgroundColor'),
'background-image': require('./backgroundImage'),
'background-repeat': require('./backgroundRepeat'),
'background-attachment': require('./backgroundAttachment'),
'background-position': require('./backgroundPosition'),
};
module.exports.definition = {
set: shorthandSetter('background', shorthand_for),
get: shorthandGetter('background', shorthand_for),
enumerable: true,
configurable: true,
};

24
node_modules/cssstyle/lib/properties/backgroundAttachment.js generated vendored Normal file
View file

@ -0,0 +1,24 @@
'use strict';
var parsers = require('../parsers');
var isValid = (module.exports.isValid = function isValid(v) {
return (
parsers.valueType(v) === parsers.TYPES.KEYWORD &&
(v.toLowerCase() === 'scroll' || v.toLowerCase() === 'fixed' || v.toLowerCase() === 'inherit')
);
});
module.exports.definition = {
set: function (v) {
if (!isValid(v)) {
return;
}
this._setProperty('background-attachment', v);
},
get: function () {
return this.getPropertyValue('background-attachment');
},
enumerable: true,
configurable: true,
};

33
node_modules/cssstyle/lib/properties/backgroundColor.js generated vendored Normal file
View file

@ -0,0 +1,33 @@
'use strict';
var parsers = require('../parsers');
var parse = function parse(v) {
var parsed = parsers.parseColor(v);
if (parsed !== undefined) {
return parsed;
}
if (parsers.valueType(v) === parsers.TYPES.KEYWORD && v.toLowerCase() === 'inherit') {
return v;
}
return undefined;
};
module.exports.isValid = function isValid(v) {
return parse(v) !== undefined;
};
module.exports.definition = {
set: function (v) {
var parsed = parse(v);
if (parsed === undefined) {
return;
}
this._setProperty('background-color', parsed);
},
get: function () {
return this.getPropertyValue('background-color');
},
enumerable: true,
configurable: true,
};

26
node_modules/cssstyle/lib/properties/backgroundImage.js generated vendored Normal file
View file

@ -0,0 +1,26 @@
'use strict';
var parsers = require('../parsers');
var parse = function parse(v) {
var parsed = parsers.parseImage(v);
if (parsed !== undefined) {
return parsed;
}
return undefined;
};
module.exports.isValid = function isValid(v) {
return parse(v) !== undefined;
};
module.exports.definition = {
set: function (v) {
this._setProperty('background-image', parse(v));
},
get: function () {
return this.getPropertyValue('background-image');
},
enumerable: true,
configurable: true,
};

58
node_modules/cssstyle/lib/properties/backgroundPosition.js generated vendored Normal file
View file

@ -0,0 +1,58 @@
'use strict';
var parsers = require('../parsers');
var valid_keywords = ['top', 'center', 'bottom', 'left', 'right'];
var parse = function parse(v) {
if (v === '' || v === null) {
return undefined;
}
var parts = v.split(/\s+/);
if (parts.length > 2 || parts.length < 1) {
return undefined;
}
var types = [];
parts.forEach(function (part, index) {
types[index] = parsers.valueType(part);
});
if (parts.length === 1) {
if (types[0] === parsers.TYPES.LENGTH || types[0] === parsers.TYPES.PERCENT) {
return v;
}
if (types[0] === parsers.TYPES.KEYWORD) {
if (valid_keywords.indexOf(v.toLowerCase()) !== -1 || v.toLowerCase() === 'inherit') {
return v;
}
}
return undefined;
}
if (
(types[0] === parsers.TYPES.LENGTH || types[0] === parsers.TYPES.PERCENT) &&
(types[1] === parsers.TYPES.LENGTH || types[1] === parsers.TYPES.PERCENT)
) {
return v;
}
if (types[0] !== parsers.TYPES.KEYWORD || types[1] !== parsers.TYPES.KEYWORD) {
return undefined;
}
if (valid_keywords.indexOf(parts[0]) !== -1 && valid_keywords.indexOf(parts[1]) !== -1) {
return v;
}
return undefined;
};
module.exports.isValid = function isValid(v) {
return parse(v) !== undefined;
};
module.exports.definition = {
set: function (v) {
this._setProperty('background-position', parse(v));
},
get: function () {
return this.getPropertyValue('background-position');
},
enumerable: true,
configurable: true,
};

32
node_modules/cssstyle/lib/properties/backgroundRepeat.js generated vendored Normal file
View file

@ -0,0 +1,32 @@
'use strict';
var parsers = require('../parsers');
var parse = function parse(v) {
if (
parsers.valueType(v) === parsers.TYPES.KEYWORD &&
(v.toLowerCase() === 'repeat' ||
v.toLowerCase() === 'repeat-x' ||
v.toLowerCase() === 'repeat-y' ||
v.toLowerCase() === 'no-repeat' ||
v.toLowerCase() === 'inherit')
) {
return v;
}
return undefined;
};
module.exports.isValid = function isValid(v) {
return parse(v) !== undefined;
};
module.exports.definition = {
set: function (v) {
this._setProperty('background-repeat', parse(v));
},
get: function () {
return this.getPropertyValue('background-repeat');
},
enumerable: true,
configurable: true,
};

33
node_modules/cssstyle/lib/properties/border.js generated vendored Normal file
View file

@ -0,0 +1,33 @@
'use strict';
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'border-width': require('./borderWidth'),
'border-style': require('./borderStyle'),
'border-color': require('./borderColor'),
};
var myShorthandSetter = shorthandSetter('border', shorthand_for);
var myShorthandGetter = shorthandGetter('border', shorthand_for);
module.exports.definition = {
set: function (v) {
if (v.toString().toLowerCase() === 'none') {
v = '';
}
myShorthandSetter.call(this, v);
this.removeProperty('border-top');
this.removeProperty('border-left');
this.removeProperty('border-right');
this.removeProperty('border-bottom');
this._values['border-top'] = this._values.border;
this._values['border-left'] = this._values.border;
this._values['border-right'] = this._values.border;
this._values['border-bottom'] = this._values.border;
},
get: myShorthandGetter,
enumerable: true,
configurable: true,
};

17
node_modules/cssstyle/lib/properties/borderBottom.js generated vendored Normal file
View file

@ -0,0 +1,17 @@
'use strict';
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'border-bottom-width': require('./borderBottomWidth'),
'border-bottom-style': require('./borderBottomStyle'),
'border-bottom-color': require('./borderBottomColor'),
};
module.exports.definition = {
set: shorthandSetter('border-bottom', shorthand_for),
get: shorthandGetter('border-bottom', shorthand_for),
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderBottomColor.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderColor').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-bottom-color', v);
}
},
get: function () {
return this.getPropertyValue('border-bottom-color');
},
enumerable: true,
configurable: true,
};

21
node_modules/cssstyle/lib/properties/borderBottomStyle.js generated vendored Normal file
View file

@ -0,0 +1,21 @@
'use strict';
var isValid = require('./borderStyle').isValid;
module.exports.isValid = isValid;
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
if (v.toLowerCase() === 'none') {
v = '';
this.removeProperty('border-bottom-width');
}
this._setProperty('border-bottom-style', v);
}
},
get: function () {
return this.getPropertyValue('border-bottom-style');
},
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderBottomWidth.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderWidth').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-bottom-width', v);
}
},
get: function () {
return this.getPropertyValue('border-bottom-width');
},
enumerable: true,
configurable: true,
};

26
node_modules/cssstyle/lib/properties/borderCollapse.js generated vendored Normal file
View file

@ -0,0 +1,26 @@
'use strict';
var parsers = require('../parsers');
var parse = function parse(v) {
if (
parsers.valueType(v) === parsers.TYPES.KEYWORD &&
(v.toLowerCase() === 'collapse' ||
v.toLowerCase() === 'separate' ||
v.toLowerCase() === 'inherit')
) {
return v;
}
return undefined;
};
module.exports.definition = {
set: function (v) {
this._setProperty('border-collapse', parse(v));
},
get: function () {
return this.getPropertyValue('border-collapse');
},
enumerable: true,
configurable: true,
};

29
node_modules/cssstyle/lib/properties/borderColor.js generated vendored Normal file
View file

@ -0,0 +1,29 @@
'use strict';
var parsers = require('../parsers');
var implicitSetter = require('../parsers').implicitSetter;
var parser = function (v) {
var parsed = parsers.parseColor(v);
if (parsed !== undefined) {
return parsed;
}
if (parsers.valueType(v) === parsers.TYPES.KEYWORD && v.toLowerCase() === 'inherit') {
return v;
}
return undefined;
};
module.exports.isValid = function parse(v) {
return parser(v) !== undefined;
};
var isValid = module.exports.isValid;
module.exports.definition = {
set: implicitSetter('border', 'color', isValid, parser),
get: function () {
return this.getPropertyValue('border-color');
},
enumerable: true,
configurable: true,
};

17
node_modules/cssstyle/lib/properties/borderLeft.js generated vendored Normal file
View file

@ -0,0 +1,17 @@
'use strict';
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'border-left-width': require('./borderLeftWidth'),
'border-left-style': require('./borderLeftStyle'),
'border-left-color': require('./borderLeftColor'),
};
module.exports.definition = {
set: shorthandSetter('border-left', shorthand_for),
get: shorthandGetter('border-left', shorthand_for),
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderLeftColor.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderColor').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-left-color', v);
}
},
get: function () {
return this.getPropertyValue('border-left-color');
},
enumerable: true,
configurable: true,
};

21
node_modules/cssstyle/lib/properties/borderLeftStyle.js generated vendored Normal file
View file

@ -0,0 +1,21 @@
'use strict';
var isValid = require('./borderStyle').isValid;
module.exports.isValid = isValid;
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
if (v.toLowerCase() === 'none') {
v = '';
this.removeProperty('border-left-width');
}
this._setProperty('border-left-style', v);
}
},
get: function () {
return this.getPropertyValue('border-left-style');
},
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderLeftWidth.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderWidth').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-left-width', v);
}
},
get: function () {
return this.getPropertyValue('border-left-width');
},
enumerable: true,
configurable: true,
};

17
node_modules/cssstyle/lib/properties/borderRight.js generated vendored Normal file
View file

@ -0,0 +1,17 @@
'use strict';
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'border-right-width': require('./borderRightWidth'),
'border-right-style': require('./borderRightStyle'),
'border-right-color': require('./borderRightColor'),
};
module.exports.definition = {
set: shorthandSetter('border-right', shorthand_for),
get: shorthandGetter('border-right', shorthand_for),
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderRightColor.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderColor').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-right-color', v);
}
},
get: function () {
return this.getPropertyValue('border-right-color');
},
enumerable: true,
configurable: true,
};

21
node_modules/cssstyle/lib/properties/borderRightStyle.js generated vendored Normal file
View file

@ -0,0 +1,21 @@
'use strict';
var isValid = require('./borderStyle').isValid;
module.exports.isValid = isValid;
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
if (v.toLowerCase() === 'none') {
v = '';
this.removeProperty('border-right-width');
}
this._setProperty('border-right-style', v);
}
},
get: function () {
return this.getPropertyValue('border-right-style');
},
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderRightWidth.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderWidth').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-right-width', v);
}
},
get: function () {
return this.getPropertyValue('border-right-width');
},
enumerable: true,
configurable: true,
};

41
node_modules/cssstyle/lib/properties/borderSpacing.js generated vendored Normal file
View file

@ -0,0 +1,41 @@
'use strict';
var parsers = require('../parsers');
// <length> <length>? | inherit
// if one, it applies to both horizontal and verical spacing
// if two, the first applies to the horizontal and the second applies to vertical spacing
var parse = function parse(v) {
if (v === '' || v === null) {
return undefined;
}
if (v === 0) {
return '0px';
}
if (v.toLowerCase() === 'inherit') {
return v;
}
var parts = v.split(/\s+/);
if (parts.length !== 1 && parts.length !== 2) {
return undefined;
}
parts.forEach(function (part) {
if (parsers.valueType(part) !== parsers.TYPES.LENGTH) {
return undefined;
}
});
return v;
};
module.exports.definition = {
set: function (v) {
this._setProperty('border-spacing', parse(v));
},
get: function () {
return this.getPropertyValue('border-spacing');
},
enumerable: true,
configurable: true,
};

38
node_modules/cssstyle/lib/properties/borderStyle.js generated vendored Normal file
View file

@ -0,0 +1,38 @@
'use strict';
var implicitSetter = require('../parsers').implicitSetter;
// the valid border-styles:
var styles = [
'none',
'hidden',
'dotted',
'dashed',
'solid',
'double',
'groove',
'ridge',
'inset',
'outset',
];
module.exports.isValid = function parse(v) {
return typeof v === 'string' && (v === '' || styles.indexOf(v) !== -1);
};
var isValid = module.exports.isValid;
var parser = function (v) {
if (isValid(v)) {
return v.toLowerCase();
}
return undefined;
};
module.exports.definition = {
set: implicitSetter('border', 'style', isValid, parser),
get: function () {
return this.getPropertyValue('border-style');
},
enumerable: true,
configurable: true,
};

17
node_modules/cssstyle/lib/properties/borderTop.js generated vendored Normal file
View file

@ -0,0 +1,17 @@
'use strict';
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'border-top-width': require('./borderTopWidth'),
'border-top-style': require('./borderTopStyle'),
'border-top-color': require('./borderTopColor'),
};
module.exports.definition = {
set: shorthandSetter('border-top', shorthand_for),
get: shorthandGetter('border-top', shorthand_for),
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/borderTopColor.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var isValid = (module.exports.isValid = require('./borderColor').isValid);
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-top-color', v);
}
},
get: function () {
return this.getPropertyValue('border-top-color');
},
enumerable: true,
configurable: true,
};

21
node_modules/cssstyle/lib/properties/borderTopStyle.js generated vendored Normal file
View file

@ -0,0 +1,21 @@
'use strict';
var isValid = require('./borderStyle').isValid;
module.exports.isValid = isValid;
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
if (v.toLowerCase() === 'none') {
v = '';
this.removeProperty('border-top-width');
}
this._setProperty('border-top-style', v);
}
},
get: function () {
return this.getPropertyValue('border-top-style');
},
enumerable: true,
configurable: true,
};

17
node_modules/cssstyle/lib/properties/borderTopWidth.js generated vendored Normal file
View file

@ -0,0 +1,17 @@
'use strict';
var isValid = require('./borderWidth').isValid;
module.exports.isValid = isValid;
module.exports.definition = {
set: function (v) {
if (isValid(v)) {
this._setProperty('border-top-width', v);
}
},
get: function () {
return this.getPropertyValue('border-top-width');
},
enumerable: true,
configurable: true,
};

46
node_modules/cssstyle/lib/properties/borderWidth.js generated vendored Normal file
View file

@ -0,0 +1,46 @@
'use strict';
var parsers = require('../parsers');
var implicitSetter = require('../parsers').implicitSetter;
// the valid border-widths:
var widths = ['thin', 'medium', 'thick'];
module.exports.isValid = function parse(v) {
var length = parsers.parseLength(v);
if (length !== undefined) {
return true;
}
if (typeof v !== 'string') {
return false;
}
if (v === '') {
return true;
}
v = v.toLowerCase();
if (widths.indexOf(v) === -1) {
return false;
}
return true;
};
var isValid = module.exports.isValid;
var parser = function (v) {
var length = parsers.parseLength(v);
if (length !== undefined) {
return length;
}
if (isValid(v)) {
return v.toLowerCase();
}
return undefined;
};
module.exports.definition = {
set: implicitSetter('border', 'width', isValid, parser),
get: function () {
return this.getPropertyValue('border-width');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/bottom.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseMeasurement = require('../parsers').parseInheritingMeasurement;
module.exports.definition = {
set: function (v) {
this._setProperty('bottom', parseMeasurement(v));
},
get: function () {
return this.getPropertyValue('bottom');
},
enumerable: true,
configurable: true,
};

16
node_modules/cssstyle/lib/properties/clear.js generated vendored Normal file
View file

@ -0,0 +1,16 @@
'use strict';
var parseKeyword = require('../parsers').parseKeyword;
var clear_keywords = ['none', 'left', 'right', 'both', 'inherit'];
module.exports.definition = {
set: function (v) {
this._setProperty('clear', parseKeyword(v, clear_keywords));
},
get: function () {
return this.getPropertyValue('clear');
},
enumerable: true,
configurable: true,
};

47
node_modules/cssstyle/lib/properties/clip.js generated vendored Normal file
View file

@ -0,0 +1,47 @@
'use strict';
var parseMeasurement = require('../parsers').parseMeasurement;
var shape_regex = /^rect\((.*)\)$/i;
var parse = function (val) {
if (val === '' || val === null) {
return val;
}
if (typeof val !== 'string') {
return undefined;
}
val = val.toLowerCase();
if (val === 'auto' || val === 'inherit') {
return val;
}
var matches = val.match(shape_regex);
if (!matches) {
return undefined;
}
var parts = matches[1].split(/\s*,\s*/);
if (parts.length !== 4) {
return undefined;
}
var valid = parts.every(function (part, index) {
var measurement = parseMeasurement(part);
parts[index] = measurement;
return measurement !== undefined;
});
if (!valid) {
return undefined;
}
parts = parts.join(', ');
return val.replace(matches[1], parts);
};
module.exports.definition = {
set: function (v) {
this._setProperty('clip', parse(v));
},
get: function () {
return this.getPropertyValue('clip');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/color.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('color', parseColor(v));
},
get: function () {
return this.getPropertyValue('color');
},
enumerable: true,
configurable: true,
};

12
node_modules/cssstyle/lib/properties/cssFloat.js generated vendored Normal file
View file

@ -0,0 +1,12 @@
'use strict';
module.exports.definition = {
set: function (v) {
this._setProperty('float', v);
},
get: function () {
return this.getPropertyValue('float');
},
enumerable: true,
configurable: true,
};

43
node_modules/cssstyle/lib/properties/flex.js generated vendored Normal file
View file

@ -0,0 +1,43 @@
'use strict';
var shorthandParser = require('../parsers').shorthandParser;
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'flex-grow': require('./flexGrow'),
'flex-shrink': require('./flexShrink'),
'flex-basis': require('./flexBasis'),
};
var myShorthandSetter = shorthandSetter('flex', shorthand_for);
module.exports.isValid = function isValid(v) {
return shorthandParser(v, shorthand_for) !== undefined;
};
module.exports.definition = {
set: function (v) {
var normalizedValue = String(v).trim().toLowerCase();
if (normalizedValue === 'none') {
myShorthandSetter.call(this, '0 0 auto');
return;
}
if (normalizedValue === 'initial') {
myShorthandSetter.call(this, '0 1 auto');
return;
}
if (normalizedValue === 'auto') {
this.removeProperty('flex-grow');
this.removeProperty('flex-shrink');
this.setProperty('flex-basis', normalizedValue);
return;
}
myShorthandSetter.call(this, v);
},
get: shorthandGetter('flex', shorthand_for),
enumerable: true,
configurable: true,
};

28
node_modules/cssstyle/lib/properties/flexBasis.js generated vendored Normal file
View file

@ -0,0 +1,28 @@
'use strict';
var parseMeasurement = require('../parsers').parseMeasurement;
function parse(v) {
if (String(v).toLowerCase() === 'auto') {
return 'auto';
}
if (String(v).toLowerCase() === 'inherit') {
return 'inherit';
}
return parseMeasurement(v);
}
module.exports.isValid = function isValid(v) {
return parse(v) !== undefined;
};
module.exports.definition = {
set: function (v) {
this._setProperty('flex-basis', parse(v));
},
get: function () {
return this.getPropertyValue('flex-basis');
},
enumerable: true,
configurable: true,
};

19
node_modules/cssstyle/lib/properties/flexGrow.js generated vendored Normal file
View file

@ -0,0 +1,19 @@
'use strict';
var parseNumber = require('../parsers').parseNumber;
var POSITION_AT_SHORTHAND = require('../constants').POSITION_AT_SHORTHAND;
module.exports.isValid = function isValid(v, positionAtFlexShorthand) {
return parseNumber(v) !== undefined && positionAtFlexShorthand === POSITION_AT_SHORTHAND.first;
};
module.exports.definition = {
set: function (v) {
this._setProperty('flex-grow', parseNumber(v));
},
get: function () {
return this.getPropertyValue('flex-grow');
},
enumerable: true,
configurable: true,
};

19
node_modules/cssstyle/lib/properties/flexShrink.js generated vendored Normal file
View file

@ -0,0 +1,19 @@
'use strict';
var parseNumber = require('../parsers').parseNumber;
var POSITION_AT_SHORTHAND = require('../constants').POSITION_AT_SHORTHAND;
module.exports.isValid = function isValid(v, positionAtFlexShorthand) {
return parseNumber(v) !== undefined && positionAtFlexShorthand === POSITION_AT_SHORTHAND.second;
};
module.exports.definition = {
set: function (v) {
this._setProperty('flex-shrink', parseNumber(v));
},
get: function () {
return this.getPropertyValue('flex-shrink');
},
enumerable: true,
configurable: true,
};

12
node_modules/cssstyle/lib/properties/float.js generated vendored Normal file
View file

@ -0,0 +1,12 @@
'use strict';
module.exports.definition = {
set: function (v) {
this._setProperty('float', v);
},
get: function () {
return this.getPropertyValue('float');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/floodColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('flood-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('flood-color');
},
enumerable: true,
configurable: true,
};

43
node_modules/cssstyle/lib/properties/font.js generated vendored Normal file
View file

@ -0,0 +1,43 @@
'use strict';
var TYPES = require('../parsers').TYPES;
var valueType = require('../parsers').valueType;
var shorthandParser = require('../parsers').shorthandParser;
var shorthandSetter = require('../parsers').shorthandSetter;
var shorthandGetter = require('../parsers').shorthandGetter;
var shorthand_for = {
'font-family': require('./fontFamily'),
'font-size': require('./fontSize'),
'font-style': require('./fontStyle'),
'font-variant': require('./fontVariant'),
'font-weight': require('./fontWeight'),
'line-height': require('./lineHeight'),
};
var static_fonts = [
'caption',
'icon',
'menu',
'message-box',
'small-caption',
'status-bar',
'inherit',
];
var setter = shorthandSetter('font', shorthand_for);
module.exports.definition = {
set: function (v) {
var short = shorthandParser(v, shorthand_for);
if (short !== undefined) {
return setter.call(this, v);
}
if (valueType(v) === TYPES.KEYWORD && static_fonts.indexOf(v.toLowerCase()) !== -1) {
this._setProperty('font', v);
}
},
get: shorthandGetter('font', shorthand_for),
enumerable: true,
configurable: true,
};

33
node_modules/cssstyle/lib/properties/fontFamily.js generated vendored Normal file
View file

@ -0,0 +1,33 @@
'use strict';
var TYPES = require('../parsers').TYPES;
var valueType = require('../parsers').valueType;
var partsRegEx = /\s*,\s*/;
module.exports.isValid = function isValid(v) {
if (v === '' || v === null) {
return true;
}
var parts = v.split(partsRegEx);
var len = parts.length;
var i;
var type;
for (i = 0; i < len; i++) {
type = valueType(parts[i]);
if (type === TYPES.STRING || type === TYPES.KEYWORD) {
return true;
}
}
return false;
};
module.exports.definition = {
set: function (v) {
this._setProperty('font-family', v);
},
get: function () {
return this.getPropertyValue('font-family');
},
enumerable: true,
configurable: true,
};

38
node_modules/cssstyle/lib/properties/fontSize.js generated vendored Normal file
View file

@ -0,0 +1,38 @@
'use strict';
var TYPES = require('../parsers').TYPES;
var valueType = require('../parsers').valueType;
var parseMeasurement = require('../parsers').parseMeasurement;
var absoluteSizes = ['xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'];
var relativeSizes = ['larger', 'smaller'];
module.exports.isValid = function (v) {
var type = valueType(v.toLowerCase());
return (
type === TYPES.LENGTH ||
type === TYPES.PERCENT ||
(type === TYPES.KEYWORD && absoluteSizes.indexOf(v.toLowerCase()) !== -1) ||
(type === TYPES.KEYWORD && relativeSizes.indexOf(v.toLowerCase()) !== -1)
);
};
function parse(v) {
const valueAsString = String(v).toLowerCase();
const optionalArguments = absoluteSizes.concat(relativeSizes);
const isOptionalArgument = optionalArguments.some(
(stringValue) => stringValue.toLowerCase() === valueAsString
);
return isOptionalArgument ? valueAsString : parseMeasurement(v);
}
module.exports.definition = {
set: function (v) {
this._setProperty('font-size', parse(v));
},
get: function () {
return this.getPropertyValue('font-size');
},
enumerable: true,
configurable: true,
};

18
node_modules/cssstyle/lib/properties/fontStyle.js generated vendored Normal file
View file

@ -0,0 +1,18 @@
'use strict';
var valid_styles = ['normal', 'italic', 'oblique', 'inherit'];
module.exports.isValid = function (v) {
return valid_styles.indexOf(v.toLowerCase()) !== -1;
};
module.exports.definition = {
set: function (v) {
this._setProperty('font-style', v);
},
get: function () {
return this.getPropertyValue('font-style');
},
enumerable: true,
configurable: true,
};

18
node_modules/cssstyle/lib/properties/fontVariant.js generated vendored Normal file
View file

@ -0,0 +1,18 @@
'use strict';
var valid_variants = ['normal', 'small-caps', 'inherit'];
module.exports.isValid = function isValid(v) {
return valid_variants.indexOf(v.toLowerCase()) !== -1;
};
module.exports.definition = {
set: function (v) {
this._setProperty('font-variant', v);
},
get: function () {
return this.getPropertyValue('font-variant');
},
enumerable: true,
configurable: true,
};

33
node_modules/cssstyle/lib/properties/fontWeight.js generated vendored Normal file
View file

@ -0,0 +1,33 @@
'use strict';
var valid_weights = [
'normal',
'bold',
'bolder',
'lighter',
'100',
'200',
'300',
'400',
'500',
'600',
'700',
'800',
'900',
'inherit',
];
module.exports.isValid = function isValid(v) {
return valid_weights.indexOf(v.toLowerCase()) !== -1;
};
module.exports.definition = {
set: function (v) {
this._setProperty('font-weight', v);
},
get: function () {
return this.getPropertyValue('font-weight');
},
enumerable: true,
configurable: true,
};

24
node_modules/cssstyle/lib/properties/height.js generated vendored Normal file
View file

@ -0,0 +1,24 @@
'use strict';
var parseMeasurement = require('../parsers').parseMeasurement;
function parse(v) {
if (String(v).toLowerCase() === 'auto') {
return 'auto';
}
if (String(v).toLowerCase() === 'inherit') {
return 'inherit';
}
return parseMeasurement(v);
}
module.exports.definition = {
set: function (v) {
this._setProperty('height', parse(v));
},
get: function () {
return this.getPropertyValue('height');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/left.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseMeasurement = require('../parsers').parseInheritingMeasurement;
module.exports.definition = {
set: function (v) {
this._setProperty('left', parseMeasurement(v));
},
get: function () {
return this.getPropertyValue('left');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/lightingColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('lighting-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('lighting-color');
},
enumerable: true,
configurable: true,
};

26
node_modules/cssstyle/lib/properties/lineHeight.js generated vendored Normal file
View file

@ -0,0 +1,26 @@
'use strict';
var TYPES = require('../parsers').TYPES;
var valueType = require('../parsers').valueType;
module.exports.isValid = function isValid(v) {
var type = valueType(v);
return (
(type === TYPES.KEYWORD && v.toLowerCase() === 'normal') ||
v.toLowerCase() === 'inherit' ||
type === TYPES.NUMBER ||
type === TYPES.LENGTH ||
type === TYPES.PERCENT
);
};
module.exports.definition = {
set: function (v) {
this._setProperty('line-height', v);
},
get: function () {
return this.getPropertyValue('line-height');
},
enumerable: true,
configurable: true,
};

73
node_modules/cssstyle/lib/properties/margin.js generated vendored Normal file
View file

@ -0,0 +1,73 @@
'use strict';
var parsers = require('../parsers.js');
var TYPES = parsers.TYPES;
var isValid = function (v) {
if (v.toLowerCase() === 'auto') {
return true;
}
var type = parsers.valueType(v);
return (
type === TYPES.NULL_OR_EMPTY_STR ||
type === TYPES.LENGTH ||
type === TYPES.PERCENT ||
type === TYPES.CALC ||
(type === TYPES.INTEGER && (v === '0' || v === 0))
);
};
var parser = function (v) {
var V = v.toLowerCase();
if (V === 'auto') {
return V;
}
return parsers.parseMeasurement(v);
};
var mySetter = parsers.implicitSetter('margin', '', isValid, parser);
var myGlobal = parsers.implicitSetter(
'margin',
'',
function () {
return true;
},
function (v) {
return v;
}
);
module.exports.definition = {
set: function (v) {
if (typeof v === 'number') {
v = String(v);
}
if (v === null) {
v = '';
}
if (typeof v !== 'string') {
return;
}
var V = v.toLowerCase();
switch (V) {
case 'inherit':
case 'initial':
case 'unset':
case '':
myGlobal.call(this, V);
break;
default:
mySetter.call(this, v);
break;
}
},
get: function () {
return this.getPropertyValue('margin');
},
enumerable: true,
configurable: true,
};
module.exports.isValid = isValid;
module.exports.parser = parser;

13
node_modules/cssstyle/lib/properties/marginBottom.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var margin = require('./margin.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('margin', 'bottom', margin.isValid, margin.parser),
get: function () {
return this.getPropertyValue('margin-bottom');
},
enumerable: true,
configurable: true,
};

13
node_modules/cssstyle/lib/properties/marginLeft.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var margin = require('./margin.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('margin', 'left', margin.isValid, margin.parser),
get: function () {
return this.getPropertyValue('margin-left');
},
enumerable: true,
configurable: true,
};

13
node_modules/cssstyle/lib/properties/marginRight.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var margin = require('./margin.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('margin', 'right', margin.isValid, margin.parser),
get: function () {
return this.getPropertyValue('margin-right');
},
enumerable: true,
configurable: true,
};

13
node_modules/cssstyle/lib/properties/marginTop.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var margin = require('./margin.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('margin', 'top', margin.isValid, margin.parser),
get: function () {
return this.getPropertyValue('margin-top');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/opacity.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseNumber = require('../parsers').parseNumber;
module.exports.definition = {
set: function (v) {
this._setProperty('opacity', parseNumber(v));
},
get: function () {
return this.getPropertyValue('opacity');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/outlineColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('outline-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('outline-color');
},
enumerable: true,
configurable: true,
};

66
node_modules/cssstyle/lib/properties/padding.js generated vendored Normal file
View file

@ -0,0 +1,66 @@
'use strict';
var parsers = require('../parsers.js');
var TYPES = parsers.TYPES;
var isValid = function (v) {
var type = parsers.valueType(v);
return (
type === TYPES.NULL_OR_EMPTY_STR ||
type === TYPES.LENGTH ||
type === TYPES.PERCENT ||
type === TYPES.CALC ||
(type === TYPES.INTEGER && (v === '0' || v === 0))
);
};
var parser = function (v) {
return parsers.parseMeasurement(v);
};
var mySetter = parsers.implicitSetter('padding', '', isValid, parser);
var myGlobal = parsers.implicitSetter(
'padding',
'',
function () {
return true;
},
function (v) {
return v;
}
);
module.exports.definition = {
set: function (v) {
if (typeof v === 'number') {
v = String(v);
}
if (v === null) {
v = '';
}
if (typeof v !== 'string') {
return;
}
var V = v.toLowerCase();
switch (V) {
case 'inherit':
case 'initial':
case 'unset':
case '':
myGlobal.call(this, V);
break;
default:
mySetter.call(this, v);
break;
}
},
get: function () {
return this.getPropertyValue('padding');
},
enumerable: true,
configurable: true,
};
module.exports.isValid = isValid;
module.exports.parser = parser;

13
node_modules/cssstyle/lib/properties/paddingBottom.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var padding = require('./padding.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('padding', 'bottom', padding.isValid, padding.parser),
get: function () {
return this.getPropertyValue('padding-bottom');
},
enumerable: true,
configurable: true,
};

13
node_modules/cssstyle/lib/properties/paddingLeft.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var padding = require('./padding.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('padding', 'left', padding.isValid, padding.parser),
get: function () {
return this.getPropertyValue('padding-left');
},
enumerable: true,
configurable: true,
};

13
node_modules/cssstyle/lib/properties/paddingRight.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var padding = require('./padding.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('padding', 'right', padding.isValid, padding.parser),
get: function () {
return this.getPropertyValue('padding-right');
},
enumerable: true,
configurable: true,
};

13
node_modules/cssstyle/lib/properties/paddingTop.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
'use strict';
var padding = require('./padding.js');
var parsers = require('../parsers.js');
module.exports.definition = {
set: parsers.subImplicitSetter('padding', 'top', padding.isValid, padding.parser),
get: function () {
return this.getPropertyValue('padding-top');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/right.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseMeasurement = require('../parsers').parseInheritingMeasurement;
module.exports.definition = {
set: function (v) {
this._setProperty('right', parseMeasurement(v));
},
get: function () {
return this.getPropertyValue('right');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/stopColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('stop-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('stop-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/textLineThroughColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('text-line-through-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('text-line-through-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/textOverlineColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('text-overline-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('text-overline-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/textUnderlineColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('text-underline-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('text-underline-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/top.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseMeasurement = require('../parsers').parseInheritingMeasurement;
module.exports.definition = {
set: function (v) {
this._setProperty('top', parseMeasurement(v));
},
get: function () {
return this.getPropertyValue('top');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitBorderAfterColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-border-after-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-border-after-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitBorderBeforeColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-border-before-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-border-before-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitBorderEndColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-border-end-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-border-end-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitBorderStartColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-border-start-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-border-start-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitColumnRuleColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-column-rule-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-column-rule-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitMatchNearestMailBlockquoteColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-match-nearest-mail-blockquote-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-match-nearest-mail-blockquote-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitTapHighlightColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-tap-highlight-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-tap-highlight-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitTextEmphasisColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-text-emphasis-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-text-emphasis-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitTextFillColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-text-fill-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-text-fill-color');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/properties/webkitTextStrokeColor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
var parseColor = require('../parsers').parseColor;
module.exports.definition = {
set: function (v) {
this._setProperty('-webkit-text-stroke-color', parseColor(v));
},
get: function () {
return this.getPropertyValue('-webkit-text-stroke-color');
},
enumerable: true,
configurable: true,
};

24
node_modules/cssstyle/lib/properties/width.js generated vendored Normal file
View file

@ -0,0 +1,24 @@
'use strict';
var parseMeasurement = require('../parsers').parseMeasurement;
function parse(v) {
if (String(v).toLowerCase() === 'auto') {
return 'auto';
}
if (String(v).toLowerCase() === 'inherit') {
return 'inherit';
}
return parseMeasurement(v);
}
module.exports.definition = {
set: function (v) {
this._setProperty('width', parse(v));
},
get: function () {
return this.getPropertyValue('width');
},
enumerable: true,
configurable: true,
};

14
node_modules/cssstyle/lib/utils/getBasicPropertyDescriptor.js generated vendored Normal file
View file

@ -0,0 +1,14 @@
'use strict';
module.exports = function getBasicPropertyDescriptor(name) {
return {
set: function (v) {
this._setProperty(name, v);
},
get: function () {
return this.getPropertyValue(name);
},
enumerable: true,
configurable: true,
};
};

71
node_modules/cssstyle/package.json generated vendored Normal file
View file

@ -0,0 +1,71 @@
{
"name": "cssstyle",
"description": "CSSStyleDeclaration Object Model implementation",
"keywords": [
"CSS",
"CSSStyleDeclaration",
"StyleSheet"
],
"version": "4.3.0",
"homepage": "https://github.com/jsdom/cssstyle",
"maintainers": [
{
"name": "Jon Sakas",
"email": "jon.sakas@gmail.com",
"url": "https://jon.sakas.co/"
},
{
"name": "Rafał Ruciński",
"email": "fatfisz@gmail.com",
"url": "https://fatfisz.com"
}
],
"contributors": [
{
"name": "Chad Walker",
"email": "chad@chad-cat-lore-eddie.com",
"url": "https://github.com/chad3814"
}
],
"repository": "jsdom/cssstyle",
"bugs": "https://github.com/jsdom/cssstyle/issues",
"directories": {
"lib": "./lib"
},
"files": [
"lib/"
],
"main": "./lib/CSSStyleDeclaration.js",
"dependencies": {
"@asamuzakjp/css-color": "^3.1.1",
"rrweb-cssom": "^0.8.0"
},
"devDependencies": {
"@babel/generator": "^7.26.9",
"@babel/parser": "^7.26.9",
"@babel/traverse": "^7.26.9",
"@babel/types": "^7.26.9",
"eslint": "^9.22.0",
"eslint-config-prettier": "^10.1.1",
"eslint-plugin-prettier": "^5.2.3",
"globals": "^16.0.0",
"npm-run-all": "^4.1.5",
"prettier": "^3.5.3",
"resolve": "^1.22.10"
},
"scripts": {
"download": "node ./scripts/downloadLatestProperties.mjs && eslint lib/allProperties.js --fix",
"generate": "run-p generate:*",
"generate:implemented_properties": "node ./scripts/generateImplementedProperties.mjs",
"generate:properties": "node ./scripts/generate_properties.js",
"lint": "npm run generate && eslint --max-warnings 0",
"lint:fix": "eslint --fix --max-warnings 0",
"prepublishOnly": "npm run lint && npm run test",
"test": "npm run generate && node --test",
"test-ci": "npm run lint && npm run test"
},
"license": "MIT",
"engines": {
"node": ">=18"
}
}