Push V1 app
This commit is contained in:
jlacoste
+15
@@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _processor = _interopRequireDefault(require("./processor"));
|
||||
var selectors = _interopRequireWildcard(require("./selectors"));
|
||||
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) { "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); } return f; })(e, t); }
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
var parser = function parser(processor) {
|
||||
return new _processor["default"](processor);
|
||||
};
|
||||
Object.assign(parser, selectors);
|
||||
delete parser.__esModule;
|
||||
var _default = exports["default"] = parser;
|
||||
module.exports = exports.default;
|
||||
+1031
File diff suppressed because it is too large
Load Diff
+178
@@ -0,0 +1,178 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _parser = _interopRequireDefault(require("./parser"));
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
var Processor = exports["default"] = /*#__PURE__*/function () {
|
||||
function Processor(func, options) {
|
||||
this.func = func || function noop() {};
|
||||
this.funcRes = null;
|
||||
this.options = options;
|
||||
}
|
||||
var _proto = Processor.prototype;
|
||||
_proto._shouldUpdateSelector = function _shouldUpdateSelector(rule, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
var merged = Object.assign({}, this.options, options);
|
||||
if (merged.updateSelector === false) {
|
||||
return false;
|
||||
} else {
|
||||
return typeof rule !== "string";
|
||||
}
|
||||
};
|
||||
_proto._isLossy = function _isLossy(options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
var merged = Object.assign({}, this.options, options);
|
||||
if (merged.lossless === false) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
_proto._root = function _root(rule, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
var parser = new _parser["default"](rule, this._parseOptions(options));
|
||||
return parser.root;
|
||||
};
|
||||
_proto._parseOptions = function _parseOptions(options) {
|
||||
var merged = Object.assign({}, this.options, options);
|
||||
return {
|
||||
lossy: this._isLossy(merged),
|
||||
maxNestingDepth: merged.maxNestingDepth
|
||||
};
|
||||
};
|
||||
_proto._stringifyOptions = function _stringifyOptions(options) {
|
||||
var merged = Object.assign({}, this.options, options);
|
||||
return {
|
||||
maxNestingDepth: merged.maxNestingDepth
|
||||
};
|
||||
};
|
||||
_proto._run = function _run(rule, options) {
|
||||
var _this = this;
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
return new Promise(function (resolve, reject) {
|
||||
try {
|
||||
var root = _this._root(rule, options);
|
||||
Promise.resolve(_this.func(root)).then(function (transform) {
|
||||
var string = undefined;
|
||||
if (_this._shouldUpdateSelector(rule, options)) {
|
||||
string = root.toString(_this._stringifyOptions(options));
|
||||
rule.selector = string;
|
||||
}
|
||||
return {
|
||||
transform: transform,
|
||||
root: root,
|
||||
string: string
|
||||
};
|
||||
}).then(resolve, reject);
|
||||
} catch (e) {
|
||||
reject(e);
|
||||
return;
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto._runSync = function _runSync(rule, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
var root = this._root(rule, options);
|
||||
var transform = this.func(root);
|
||||
if (transform && typeof transform.then === "function") {
|
||||
throw new Error("Selector processor returned a promise to a synchronous call.");
|
||||
}
|
||||
var string = undefined;
|
||||
if (options.updateSelector && typeof rule !== "string") {
|
||||
string = root.toString(this._stringifyOptions(options));
|
||||
rule.selector = string;
|
||||
}
|
||||
return {
|
||||
transform: transform,
|
||||
root: root,
|
||||
string: string
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Process rule into a selector AST.
|
||||
*
|
||||
* @param rule {postcss.Rule | string} The css selector to be processed
|
||||
* @param options The options for processing
|
||||
* @returns {Promise<parser.Root>} The AST of the selector after processing it.
|
||||
*/;
|
||||
_proto.ast = function ast(rule, options) {
|
||||
return this._run(rule, options).then(function (result) {
|
||||
return result.root;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Process rule into a selector AST synchronously.
|
||||
*
|
||||
* @param rule {postcss.Rule | string} The css selector to be processed
|
||||
* @param options The options for processing
|
||||
* @returns {parser.Root} The AST of the selector after processing it.
|
||||
*/;
|
||||
_proto.astSync = function astSync(rule, options) {
|
||||
return this._runSync(rule, options).root;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a selector into a transformed value asynchronously
|
||||
*
|
||||
* @param rule {postcss.Rule | string} The css selector to be processed
|
||||
* @param options The options for processing
|
||||
* @returns {Promise<any>} The value returned by the processor.
|
||||
*/;
|
||||
_proto.transform = function transform(rule, options) {
|
||||
return this._run(rule, options).then(function (result) {
|
||||
return result.transform;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a selector into a transformed value synchronously.
|
||||
*
|
||||
* @param rule {postcss.Rule | string} The css selector to be processed
|
||||
* @param options The options for processing
|
||||
* @returns {any} The value returned by the processor.
|
||||
*/;
|
||||
_proto.transformSync = function transformSync(rule, options) {
|
||||
return this._runSync(rule, options).transform;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a selector into a new selector string asynchronously.
|
||||
*
|
||||
* @param rule {postcss.Rule | string} The css selector to be processed
|
||||
* @param options The options for processing
|
||||
* @returns {string} the selector after processing.
|
||||
*/;
|
||||
_proto.process = function process(rule, options) {
|
||||
var _this2 = this;
|
||||
return this._run(rule, options).then(function (result) {
|
||||
return result.string || result.root.toString(_this2._stringifyOptions(options));
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Process a selector into a new selector string synchronously.
|
||||
*
|
||||
* @param rule {postcss.Rule | string} The css selector to be processed
|
||||
* @param options The options for processing
|
||||
* @returns {string} the selector after processing.
|
||||
*/;
|
||||
_proto.processSync = function processSync(rule, options) {
|
||||
var result = this._runSync(rule, options);
|
||||
return result.string || result.root.toString(this._stringifyOptions(options));
|
||||
};
|
||||
return Processor;
|
||||
}();
|
||||
module.exports = exports.default;
|
||||
+449
@@ -0,0 +1,449 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
exports.unescapeValue = unescapeValue;
|
||||
var _cssesc = _interopRequireDefault(require("cssesc"));
|
||||
var _unesc = _interopRequireDefault(require("../util/unesc"));
|
||||
var _namespace = _interopRequireDefault(require("./namespace"));
|
||||
var _types = require("./types");
|
||||
var _CSSESC_QUOTE_OPTIONS;
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
|
||||
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var deprecate = require("util-deprecate");
|
||||
var WRAPPED_IN_QUOTES = /^('|")([^]*)\1$/;
|
||||
var warnOfDeprecatedValueAssignment = deprecate(function () {}, "Assigning an attribute a value containing characters that might need to be escaped is deprecated. " + "Call attribute.setValue() instead.");
|
||||
var warnOfDeprecatedQuotedAssignment = deprecate(function () {}, "Assigning attr.quoted is deprecated and has no effect. Assign to attr.quoteMark instead.");
|
||||
var warnOfDeprecatedConstructor = deprecate(function () {}, "Constructing an Attribute selector with a value without specifying quoteMark is deprecated. Note: The value should be unescaped now.");
|
||||
function unescapeValue(value) {
|
||||
var deprecatedUsage = false;
|
||||
var quoteMark = null;
|
||||
var unescaped = value;
|
||||
var m = unescaped.match(WRAPPED_IN_QUOTES);
|
||||
if (m) {
|
||||
quoteMark = m[1];
|
||||
unescaped = m[2];
|
||||
}
|
||||
unescaped = (0, _unesc["default"])(unescaped);
|
||||
if (unescaped !== value) {
|
||||
deprecatedUsage = true;
|
||||
}
|
||||
return {
|
||||
deprecatedUsage: deprecatedUsage,
|
||||
unescaped: unescaped,
|
||||
quoteMark: quoteMark
|
||||
};
|
||||
}
|
||||
function handleDeprecatedContructorOpts(opts) {
|
||||
if (opts.quoteMark !== undefined) {
|
||||
return opts;
|
||||
}
|
||||
if (opts.value === undefined) {
|
||||
return opts;
|
||||
}
|
||||
warnOfDeprecatedConstructor();
|
||||
var _unescapeValue = unescapeValue(opts.value),
|
||||
quoteMark = _unescapeValue.quoteMark,
|
||||
unescaped = _unescapeValue.unescaped;
|
||||
if (!opts.raws) {
|
||||
opts.raws = {};
|
||||
}
|
||||
if (opts.raws.value === undefined) {
|
||||
opts.raws.value = opts.value;
|
||||
}
|
||||
opts.value = unescaped;
|
||||
opts.quoteMark = quoteMark;
|
||||
return opts;
|
||||
}
|
||||
var Attribute = exports["default"] = /*#__PURE__*/function (_Namespace) {
|
||||
_inheritsLoose(Attribute, _Namespace);
|
||||
function Attribute(opts) {
|
||||
var _this;
|
||||
if (opts === void 0) {
|
||||
opts = {};
|
||||
}
|
||||
_this = _Namespace.call(this, handleDeprecatedContructorOpts(opts)) || this;
|
||||
_this.type = _types.ATTRIBUTE;
|
||||
_this.raws = _this.raws || {};
|
||||
Object.defineProperty(_this.raws, 'unquoted', {
|
||||
get: deprecate(function () {
|
||||
return _this.value;
|
||||
}, "attr.raws.unquoted is deprecated. Call attr.value instead."),
|
||||
set: deprecate(function () {
|
||||
return _this.value;
|
||||
}, "Setting attr.raws.unquoted is deprecated and has no effect. attr.value is unescaped by default now.")
|
||||
});
|
||||
_this._constructed = true;
|
||||
return _this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the Attribute's value quoted such that it would be legal to use
|
||||
* in the value of a css file. The original value's quotation setting
|
||||
* used for stringification is left unchanged. See `setValue(value, options)`
|
||||
* if you want to control the quote settings of a new value for the attribute.
|
||||
*
|
||||
* You can also change the quotation used for the current value by setting quoteMark.
|
||||
*
|
||||
* Options:
|
||||
* * quoteMark {'"' | "'" | null} - Use this value to quote the value. If this
|
||||
* option is not set, the original value for quoteMark will be used. If
|
||||
* indeterminate, a double quote is used. The legal values are:
|
||||
* * `null` - the value will be unquoted and characters will be escaped as necessary.
|
||||
* * `'` - the value will be quoted with a single quote and single quotes are escaped.
|
||||
* * `"` - the value will be quoted with a double quote and double quotes are escaped.
|
||||
* * preferCurrentQuoteMark {boolean} - if true, prefer the source quote mark
|
||||
* over the quoteMark option value.
|
||||
* * smart {boolean} - if true, will select a quote mark based on the value
|
||||
* and the other options specified here. See the `smartQuoteMark()`
|
||||
* method.
|
||||
**/
|
||||
var _proto = Attribute.prototype;
|
||||
_proto.getQuotedValue = function getQuotedValue(options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
var quoteMark = this._determineQuoteMark(options);
|
||||
var cssescopts = CSSESC_QUOTE_OPTIONS[quoteMark];
|
||||
var escaped = (0, _cssesc["default"])(this._value, cssescopts);
|
||||
return escaped;
|
||||
};
|
||||
_proto._determineQuoteMark = function _determineQuoteMark(options) {
|
||||
return options.smart ? this.smartQuoteMark(options) : this.preferredQuoteMark(options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the unescaped value with the specified quotation options. The value
|
||||
* provided must not include any wrapping quote marks -- those quotes will
|
||||
* be interpreted as part of the value and escaped accordingly.
|
||||
*/;
|
||||
_proto.setValue = function setValue(value, options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
this._value = value;
|
||||
this._quoteMark = this._determineQuoteMark(options);
|
||||
this._syncRawValue();
|
||||
}
|
||||
|
||||
/**
|
||||
* Intelligently select a quoteMark value based on the value's contents. If
|
||||
* the value is a legal CSS ident, it will not be quoted. Otherwise a quote
|
||||
* mark will be picked that minimizes the number of escapes.
|
||||
*
|
||||
* If there's no clear winner, the quote mark from these options is used,
|
||||
* then the source quote mark (this is inverted if `preferCurrentQuoteMark` is
|
||||
* true). If the quoteMark is unspecified, a double quote is used.
|
||||
*
|
||||
* @param options This takes the quoteMark and preferCurrentQuoteMark options
|
||||
* from the quoteValue method.
|
||||
*/;
|
||||
_proto.smartQuoteMark = function smartQuoteMark(options) {
|
||||
var v = this.value;
|
||||
var numSingleQuotes = v.replace(/[^']/g, '').length;
|
||||
var numDoubleQuotes = v.replace(/[^"]/g, '').length;
|
||||
if (numSingleQuotes + numDoubleQuotes === 0) {
|
||||
var escaped = (0, _cssesc["default"])(v, {
|
||||
isIdentifier: true
|
||||
});
|
||||
if (escaped === v) {
|
||||
return Attribute.NO_QUOTE;
|
||||
} else {
|
||||
var pref = this.preferredQuoteMark(options);
|
||||
if (pref === Attribute.NO_QUOTE) {
|
||||
// pick a quote mark that isn't none and see if it's smaller
|
||||
var quote = this.quoteMark || options.quoteMark || Attribute.DOUBLE_QUOTE;
|
||||
var opts = CSSESC_QUOTE_OPTIONS[quote];
|
||||
var quoteValue = (0, _cssesc["default"])(v, opts);
|
||||
if (quoteValue.length < escaped.length) {
|
||||
return quote;
|
||||
}
|
||||
}
|
||||
return pref;
|
||||
}
|
||||
} else if (numDoubleQuotes === numSingleQuotes) {
|
||||
return this.preferredQuoteMark(options);
|
||||
} else if (numDoubleQuotes < numSingleQuotes) {
|
||||
return Attribute.DOUBLE_QUOTE;
|
||||
} else {
|
||||
return Attribute.SINGLE_QUOTE;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects the preferred quote mark based on the options and the current quote mark value.
|
||||
* If you want the quote mark to depend on the attribute value, call `smartQuoteMark(opts)`
|
||||
* instead.
|
||||
*/;
|
||||
_proto.preferredQuoteMark = function preferredQuoteMark(options) {
|
||||
var quoteMark = options.preferCurrentQuoteMark ? this.quoteMark : options.quoteMark;
|
||||
if (quoteMark === undefined) {
|
||||
quoteMark = options.preferCurrentQuoteMark ? options.quoteMark : this.quoteMark;
|
||||
}
|
||||
if (quoteMark === undefined) {
|
||||
quoteMark = Attribute.DOUBLE_QUOTE;
|
||||
}
|
||||
return quoteMark;
|
||||
};
|
||||
_proto._syncRawValue = function _syncRawValue() {
|
||||
var rawValue = (0, _cssesc["default"])(this._value, CSSESC_QUOTE_OPTIONS[this.quoteMark]);
|
||||
if (rawValue === this._value) {
|
||||
if (this.raws) {
|
||||
delete this.raws.value;
|
||||
}
|
||||
} else {
|
||||
this.raws.value = rawValue;
|
||||
}
|
||||
};
|
||||
_proto._handleEscapes = function _handleEscapes(prop, value) {
|
||||
if (this._constructed) {
|
||||
var escaped = (0, _cssesc["default"])(value, {
|
||||
isIdentifier: true
|
||||
});
|
||||
if (escaped !== value) {
|
||||
this.raws[prop] = escaped;
|
||||
} else {
|
||||
delete this.raws[prop];
|
||||
}
|
||||
}
|
||||
};
|
||||
_proto._spacesFor = function _spacesFor(name) {
|
||||
var attrSpaces = {
|
||||
before: '',
|
||||
after: ''
|
||||
};
|
||||
var spaces = this.spaces[name] || {};
|
||||
var rawSpaces = this.raws.spaces && this.raws.spaces[name] || {};
|
||||
return Object.assign(attrSpaces, spaces, rawSpaces);
|
||||
};
|
||||
_proto._stringFor = function _stringFor(name, spaceName, concat) {
|
||||
if (spaceName === void 0) {
|
||||
spaceName = name;
|
||||
}
|
||||
if (concat === void 0) {
|
||||
concat = defaultAttrConcat;
|
||||
}
|
||||
var attrSpaces = this._spacesFor(spaceName);
|
||||
return concat(this.stringifyProperty(name), attrSpaces);
|
||||
}
|
||||
|
||||
/**
|
||||
* returns the offset of the attribute part specified relative to the
|
||||
* start of the node of the output string.
|
||||
*
|
||||
* * "ns" - alias for "namespace"
|
||||
* * "namespace" - the namespace if it exists.
|
||||
* * "attribute" - the attribute name
|
||||
* * "attributeNS" - the start of the attribute or its namespace
|
||||
* * "operator" - the match operator of the attribute
|
||||
* * "value" - The value (string or identifier)
|
||||
* * "insensitive" - the case insensitivity flag;
|
||||
* @param part One of the possible values inside an attribute.
|
||||
* @returns -1 if the name is invalid or the value doesn't exist in this attribute.
|
||||
*/;
|
||||
_proto.offsetOf = function offsetOf(name) {
|
||||
var count = 1;
|
||||
var attributeSpaces = this._spacesFor("attribute");
|
||||
count += attributeSpaces.before.length;
|
||||
if (name === "namespace" || name === "ns") {
|
||||
return this.namespace ? count : -1;
|
||||
}
|
||||
if (name === "attributeNS") {
|
||||
return count;
|
||||
}
|
||||
count += this.namespaceString.length;
|
||||
if (this.namespace) {
|
||||
count += 1;
|
||||
}
|
||||
if (name === "attribute") {
|
||||
return count;
|
||||
}
|
||||
count += this.stringifyProperty("attribute").length;
|
||||
count += attributeSpaces.after.length;
|
||||
var operatorSpaces = this._spacesFor("operator");
|
||||
count += operatorSpaces.before.length;
|
||||
var operator = this.stringifyProperty("operator");
|
||||
if (name === "operator") {
|
||||
return operator ? count : -1;
|
||||
}
|
||||
count += operator.length;
|
||||
count += operatorSpaces.after.length;
|
||||
var valueSpaces = this._spacesFor("value");
|
||||
count += valueSpaces.before.length;
|
||||
var value = this.stringifyProperty("value");
|
||||
if (name === "value") {
|
||||
return value ? count : -1;
|
||||
}
|
||||
count += value.length;
|
||||
count += valueSpaces.after.length;
|
||||
var insensitiveSpaces = this._spacesFor("insensitive");
|
||||
count += insensitiveSpaces.before.length;
|
||||
if (name === "insensitive") {
|
||||
return this.insensitive ? count : -1;
|
||||
}
|
||||
return -1;
|
||||
};
|
||||
_proto.toString = function toString() {
|
||||
var _this2 = this;
|
||||
var selector = [this.rawSpaceBefore, '['];
|
||||
selector.push(this._stringFor('qualifiedAttribute', 'attribute'));
|
||||
if (this.operator && (this.value || this.value === '')) {
|
||||
selector.push(this._stringFor('operator'));
|
||||
selector.push(this._stringFor('value'));
|
||||
selector.push(this._stringFor('insensitiveFlag', 'insensitive', function (attrValue, attrSpaces) {
|
||||
if (attrValue.length > 0 && !_this2.quoted && attrSpaces.before.length === 0 && !(_this2.spaces.value && _this2.spaces.value.after)) {
|
||||
attrSpaces.before = " ";
|
||||
}
|
||||
return defaultAttrConcat(attrValue, attrSpaces);
|
||||
}));
|
||||
}
|
||||
selector.push(']');
|
||||
selector.push(this.rawSpaceAfter);
|
||||
return selector.join('');
|
||||
};
|
||||
_createClass(Attribute, [{
|
||||
key: "quoted",
|
||||
get: function get() {
|
||||
var qm = this.quoteMark;
|
||||
return qm === "'" || qm === '"';
|
||||
},
|
||||
set: function set(value) {
|
||||
warnOfDeprecatedQuotedAssignment();
|
||||
}
|
||||
|
||||
/**
|
||||
* returns a single (`'`) or double (`"`) quote character if the value is quoted.
|
||||
* returns `null` if the value is not quoted.
|
||||
* returns `undefined` if the quotation state is unknown (this can happen when
|
||||
* the attribute is constructed without specifying a quote mark.)
|
||||
*/
|
||||
}, {
|
||||
key: "quoteMark",
|
||||
get: function get() {
|
||||
return this._quoteMark;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the quote mark to be used by this attribute's value.
|
||||
* If the quote mark changes, the raw (escaped) value at `attr.raws.value` of the attribute
|
||||
* value is updated accordingly.
|
||||
*
|
||||
* @param {"'" | '"' | null} quoteMark The quote mark or `null` if the value should be unquoted.
|
||||
*/,
|
||||
set: function set(quoteMark) {
|
||||
if (!this._constructed) {
|
||||
this._quoteMark = quoteMark;
|
||||
return;
|
||||
}
|
||||
if (this._quoteMark !== quoteMark) {
|
||||
this._quoteMark = quoteMark;
|
||||
this._syncRawValue();
|
||||
}
|
||||
}
|
||||
}, {
|
||||
key: "qualifiedAttribute",
|
||||
get: function get() {
|
||||
return this.qualifiedName(this.raws.attribute || this.attribute);
|
||||
}
|
||||
}, {
|
||||
key: "insensitiveFlag",
|
||||
get: function get() {
|
||||
return this.insensitive ? 'i' : '';
|
||||
}
|
||||
}, {
|
||||
key: "value",
|
||||
get: function get() {
|
||||
return this._value;
|
||||
},
|
||||
set:
|
||||
/**
|
||||
* Before 3.0, the value had to be set to an escaped value including any wrapped
|
||||
* quote marks. In 3.0, the semantics of `Attribute.value` changed so that the value
|
||||
* is unescaped during parsing and any quote marks are removed.
|
||||
*
|
||||
* Because the ambiguity of this semantic change, if you set `attr.value = newValue`,
|
||||
* a deprecation warning is raised when the new value contains any characters that would
|
||||
* require escaping (including if it contains wrapped quotes).
|
||||
*
|
||||
* Instead, you should call `attr.setValue(newValue, opts)` and pass options that describe
|
||||
* how the new value is quoted.
|
||||
*/
|
||||
function set(v) {
|
||||
if (this._constructed) {
|
||||
var _unescapeValue2 = unescapeValue(v),
|
||||
deprecatedUsage = _unescapeValue2.deprecatedUsage,
|
||||
unescaped = _unescapeValue2.unescaped,
|
||||
quoteMark = _unescapeValue2.quoteMark;
|
||||
if (deprecatedUsage) {
|
||||
warnOfDeprecatedValueAssignment();
|
||||
}
|
||||
if (unescaped === this._value && quoteMark === this._quoteMark) {
|
||||
return;
|
||||
}
|
||||
this._value = unescaped;
|
||||
this._quoteMark = quoteMark;
|
||||
this._syncRawValue();
|
||||
} else {
|
||||
this._value = v;
|
||||
}
|
||||
}
|
||||
}, {
|
||||
key: "insensitive",
|
||||
get: function get() {
|
||||
return this._insensitive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the case insensitive flag.
|
||||
* If the case insensitive flag changes, the raw (escaped) value at `attr.raws.insensitiveFlag`
|
||||
* of the attribute is updated accordingly.
|
||||
*
|
||||
* @param {true | false} insensitive true if the attribute should match case-insensitively.
|
||||
*/,
|
||||
set: function set(insensitive) {
|
||||
if (!insensitive) {
|
||||
this._insensitive = false;
|
||||
|
||||
// "i" and "I" can be used in "this.raws.insensitiveFlag" to store the original notation.
|
||||
// When setting `attr.insensitive = false` both should be erased to ensure correct serialization.
|
||||
if (this.raws && (this.raws.insensitiveFlag === 'I' || this.raws.insensitiveFlag === 'i')) {
|
||||
this.raws.insensitiveFlag = undefined;
|
||||
}
|
||||
}
|
||||
this._insensitive = insensitive;
|
||||
}
|
||||
}, {
|
||||
key: "attribute",
|
||||
get: function get() {
|
||||
return this._attribute;
|
||||
},
|
||||
set: function set(name) {
|
||||
this._handleEscapes("attribute", name);
|
||||
this._attribute = name;
|
||||
}
|
||||
}]);
|
||||
return Attribute;
|
||||
}(_namespace["default"]);
|
||||
Attribute.NO_QUOTE = null;
|
||||
Attribute.SINGLE_QUOTE = "'";
|
||||
Attribute.DOUBLE_QUOTE = '"';
|
||||
var CSSESC_QUOTE_OPTIONS = (_CSSESC_QUOTE_OPTIONS = {
|
||||
"'": {
|
||||
quotes: 'single',
|
||||
wrap: true
|
||||
},
|
||||
'"': {
|
||||
quotes: 'double',
|
||||
wrap: true
|
||||
}
|
||||
}, _CSSESC_QUOTE_OPTIONS[null] = {
|
||||
isIdentifier: true
|
||||
}, _CSSESC_QUOTE_OPTIONS);
|
||||
function defaultAttrConcat(attrValue, attrSpaces) {
|
||||
return "" + attrSpaces.before + attrValue + attrSpaces.after;
|
||||
}
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _cssesc = _interopRequireDefault(require("cssesc"));
|
||||
var _util = require("../util");
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
|
||||
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var ClassName = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(ClassName, _Node);
|
||||
function ClassName(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
_this.type = _types.CLASS;
|
||||
_this._constructed = true;
|
||||
return _this;
|
||||
}
|
||||
var _proto = ClassName.prototype;
|
||||
_proto.valueToString = function valueToString() {
|
||||
return '.' + _Node.prototype.valueToString.call(this);
|
||||
};
|
||||
_createClass(ClassName, [{
|
||||
key: "value",
|
||||
get: function get() {
|
||||
return this._value;
|
||||
},
|
||||
set: function set(v) {
|
||||
if (this._constructed) {
|
||||
var escaped = (0, _cssesc["default"])(v, {
|
||||
isIdentifier: true
|
||||
});
|
||||
if (escaped !== v) {
|
||||
(0, _util.ensureObject)(this, "raws");
|
||||
this.raws.value = escaped;
|
||||
} else if (this.raws) {
|
||||
delete this.raws.value;
|
||||
}
|
||||
}
|
||||
this._value = v;
|
||||
}
|
||||
}]);
|
||||
return ClassName;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Combinator = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(Combinator, _Node);
|
||||
function Combinator(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
_this.type = _types.COMBINATOR;
|
||||
return _this;
|
||||
}
|
||||
return Combinator;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Comment = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(Comment, _Node);
|
||||
function Comment(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
_this.type = _types.COMMENT;
|
||||
return _this;
|
||||
}
|
||||
return Comment;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+53
@@ -0,0 +1,53 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.universal = exports.tag = exports.string = exports.selector = exports.root = exports.pseudo = exports.nesting = exports.id = exports.comment = exports.combinator = exports.className = exports.attribute = void 0;
|
||||
var _attribute = _interopRequireDefault(require("./attribute"));
|
||||
var _className = _interopRequireDefault(require("./className"));
|
||||
var _combinator = _interopRequireDefault(require("./combinator"));
|
||||
var _comment = _interopRequireDefault(require("./comment"));
|
||||
var _id = _interopRequireDefault(require("./id"));
|
||||
var _nesting = _interopRequireDefault(require("./nesting"));
|
||||
var _pseudo = _interopRequireDefault(require("./pseudo"));
|
||||
var _root = _interopRequireDefault(require("./root"));
|
||||
var _selector = _interopRequireDefault(require("./selector"));
|
||||
var _string = _interopRequireDefault(require("./string"));
|
||||
var _tag = _interopRequireDefault(require("./tag"));
|
||||
var _universal = _interopRequireDefault(require("./universal"));
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
var attribute = exports.attribute = function attribute(opts) {
|
||||
return new _attribute["default"](opts);
|
||||
};
|
||||
var className = exports.className = function className(opts) {
|
||||
return new _className["default"](opts);
|
||||
};
|
||||
var combinator = exports.combinator = function combinator(opts) {
|
||||
return new _combinator["default"](opts);
|
||||
};
|
||||
var comment = exports.comment = function comment(opts) {
|
||||
return new _comment["default"](opts);
|
||||
};
|
||||
var id = exports.id = function id(opts) {
|
||||
return new _id["default"](opts);
|
||||
};
|
||||
var nesting = exports.nesting = function nesting(opts) {
|
||||
return new _nesting["default"](opts);
|
||||
};
|
||||
var pseudo = exports.pseudo = function pseudo(opts) {
|
||||
return new _pseudo["default"](opts);
|
||||
};
|
||||
var root = exports.root = function root(opts) {
|
||||
return new _root["default"](opts);
|
||||
};
|
||||
var selector = exports.selector = function selector(opts) {
|
||||
return new _selector["default"](opts);
|
||||
};
|
||||
var string = exports.string = function string(opts) {
|
||||
return new _string["default"](opts);
|
||||
};
|
||||
var tag = exports.tag = function tag(opts) {
|
||||
return new _tag["default"](opts);
|
||||
};
|
||||
var universal = exports.universal = function universal(opts) {
|
||||
return new _universal["default"](opts);
|
||||
};
|
||||
+336
@@ -0,0 +1,336 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _util = require("../util");
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var types = _interopRequireWildcard(require("./types"));
|
||||
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) { "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); } return f; })(e, t); }
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _createForOfIteratorHelperLoose(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (t) return (t = t.call(r)).next.bind(t); if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var o = 0; return function () { return o >= r.length ? { done: !0 } : { done: !1, value: r[o++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
|
||||
function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
|
||||
function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) { n[e] = r[e]; } return n; }
|
||||
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
|
||||
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Container = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(Container, _Node);
|
||||
function Container(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
if (!_this.nodes) {
|
||||
_this.nodes = [];
|
||||
}
|
||||
return _this;
|
||||
}
|
||||
var _proto = Container.prototype;
|
||||
_proto.append = function append(selector) {
|
||||
selector.parent = this;
|
||||
this.nodes.push(selector);
|
||||
return this;
|
||||
};
|
||||
_proto.prepend = function prepend(selector) {
|
||||
selector.parent = this;
|
||||
this.nodes.unshift(selector);
|
||||
return this;
|
||||
};
|
||||
_proto.at = function at(index) {
|
||||
return this.nodes[index];
|
||||
};
|
||||
_proto.index = function index(child) {
|
||||
if (typeof child === 'number') {
|
||||
return child;
|
||||
}
|
||||
return this.nodes.indexOf(child);
|
||||
};
|
||||
_proto.removeChild = function removeChild(child) {
|
||||
child = this.index(child);
|
||||
this.at(child).parent = undefined;
|
||||
this.nodes.splice(child, 1);
|
||||
var index;
|
||||
for (var id in this.indexes) {
|
||||
index = this.indexes[id];
|
||||
if (index >= child) {
|
||||
this.indexes[id] = index - 1;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
};
|
||||
_proto.removeAll = function removeAll() {
|
||||
for (var _iterator = _createForOfIteratorHelperLoose(this.nodes), _step; !(_step = _iterator()).done;) {
|
||||
var node = _step.value;
|
||||
node.parent = undefined;
|
||||
}
|
||||
this.nodes = [];
|
||||
return this;
|
||||
};
|
||||
_proto.empty = function empty() {
|
||||
return this.removeAll();
|
||||
};
|
||||
_proto.insertAfter = function insertAfter(oldNode, newNode) {
|
||||
newNode.parent = this;
|
||||
var oldIndex = this.index(oldNode);
|
||||
this.nodes.splice(oldIndex + 1, 0, newNode);
|
||||
newNode.parent = this;
|
||||
var index;
|
||||
for (var id in this.indexes) {
|
||||
index = this.indexes[id];
|
||||
if (oldIndex <= index) {
|
||||
this.indexes[id] = index + 1;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
};
|
||||
_proto.insertBefore = function insertBefore(oldNode, newNode) {
|
||||
newNode.parent = this;
|
||||
var oldIndex = this.index(oldNode);
|
||||
this.nodes.splice(oldIndex, 0, newNode);
|
||||
newNode.parent = this;
|
||||
var index;
|
||||
for (var id in this.indexes) {
|
||||
index = this.indexes[id];
|
||||
if (index <= oldIndex) {
|
||||
this.indexes[id] = index + 1;
|
||||
}
|
||||
}
|
||||
return this;
|
||||
};
|
||||
_proto._findChildAtPosition = function _findChildAtPosition(line, col) {
|
||||
var found = undefined;
|
||||
this.each(function (node) {
|
||||
if (node.atPosition) {
|
||||
var foundChild = node.atPosition(line, col);
|
||||
if (foundChild) {
|
||||
found = foundChild;
|
||||
return false;
|
||||
}
|
||||
} else if (node.isAtPosition(line, col)) {
|
||||
found = node;
|
||||
return false;
|
||||
}
|
||||
});
|
||||
return found;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the most specific node at the line and column number given.
|
||||
* The source location is based on the original parsed location, locations aren't
|
||||
* updated as selector nodes are mutated.
|
||||
*
|
||||
* Note that this location is relative to the location of the first character
|
||||
* of the selector, and not the location of the selector in the overall document
|
||||
* when used in conjunction with postcss.
|
||||
*
|
||||
* If not found, returns undefined.
|
||||
* @param {number} line The line number of the node to find. (1-based index)
|
||||
* @param {number} col The column number of the node to find. (1-based index)
|
||||
*/;
|
||||
_proto.atPosition = function atPosition(line, col) {
|
||||
if (this.isAtPosition(line, col)) {
|
||||
return this._findChildAtPosition(line, col) || this;
|
||||
} else {
|
||||
return undefined;
|
||||
}
|
||||
};
|
||||
_proto._inferEndPosition = function _inferEndPosition() {
|
||||
if (this.last && this.last.source && this.last.source.end) {
|
||||
this.source = this.source || {};
|
||||
this.source.end = this.source.end || {};
|
||||
Object.assign(this.source.end, this.last.source.end);
|
||||
}
|
||||
};
|
||||
_proto.each = function each(callback) {
|
||||
if (!this.lastEach) {
|
||||
this.lastEach = 0;
|
||||
}
|
||||
if (!this.indexes) {
|
||||
this.indexes = {};
|
||||
}
|
||||
this.lastEach++;
|
||||
var id = this.lastEach;
|
||||
this.indexes[id] = 0;
|
||||
if (!this.length) {
|
||||
return undefined;
|
||||
}
|
||||
var index, result;
|
||||
while (this.indexes[id] < this.length) {
|
||||
index = this.indexes[id];
|
||||
result = callback(this.at(index), index);
|
||||
if (result === false) {
|
||||
break;
|
||||
}
|
||||
this.indexes[id] += 1;
|
||||
}
|
||||
delete this.indexes[id];
|
||||
if (result === false) {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
_proto.walk = function walk(callback, depth) {
|
||||
if (depth === void 0) {
|
||||
depth = 0;
|
||||
}
|
||||
// Bound recursion so a pathologically deep node tree raises a catchable
|
||||
// error instead of overflowing the call stack (CVE-2026-9358 / CWE-674).
|
||||
if (depth > _util.MAX_NESTING_DEPTH) {
|
||||
throw new Error("Cannot walk selector: nesting depth exceeds the maximum of " + _util.MAX_NESTING_DEPTH + ".");
|
||||
}
|
||||
return this.each(function (node, i) {
|
||||
var result = callback(node, i);
|
||||
if (result !== false && node.length) {
|
||||
result = node.walk(callback, depth + 1);
|
||||
}
|
||||
if (result === false) {
|
||||
return false;
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkAttributes = function walkAttributes(callback) {
|
||||
var _this2 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.ATTRIBUTE) {
|
||||
return callback.call(_this2, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkClasses = function walkClasses(callback) {
|
||||
var _this3 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.CLASS) {
|
||||
return callback.call(_this3, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkCombinators = function walkCombinators(callback) {
|
||||
var _this4 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.COMBINATOR) {
|
||||
return callback.call(_this4, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkComments = function walkComments(callback) {
|
||||
var _this5 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.COMMENT) {
|
||||
return callback.call(_this5, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkIds = function walkIds(callback) {
|
||||
var _this6 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.ID) {
|
||||
return callback.call(_this6, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkNesting = function walkNesting(callback) {
|
||||
var _this7 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.NESTING) {
|
||||
return callback.call(_this7, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkPseudos = function walkPseudos(callback) {
|
||||
var _this8 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.PSEUDO) {
|
||||
return callback.call(_this8, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkTags = function walkTags(callback) {
|
||||
var _this9 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.TAG) {
|
||||
return callback.call(_this9, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.walkUniversals = function walkUniversals(callback) {
|
||||
var _this0 = this;
|
||||
return this.walk(function (selector) {
|
||||
if (selector.type === types.UNIVERSAL) {
|
||||
return callback.call(_this0, selector);
|
||||
}
|
||||
});
|
||||
};
|
||||
_proto.split = function split(callback) {
|
||||
var _this1 = this;
|
||||
var current = [];
|
||||
return this.reduce(function (memo, node, index) {
|
||||
var split = callback.call(_this1, node);
|
||||
current.push(node);
|
||||
if (split) {
|
||||
memo.push(current);
|
||||
current = [];
|
||||
} else if (index === _this1.length - 1) {
|
||||
memo.push(current);
|
||||
}
|
||||
return memo;
|
||||
}, []);
|
||||
};
|
||||
_proto.map = function map(callback) {
|
||||
return this.nodes.map(callback);
|
||||
};
|
||||
_proto.reduce = function reduce(callback, memo) {
|
||||
return this.nodes.reduce(callback, memo);
|
||||
};
|
||||
_proto.every = function every(callback) {
|
||||
return this.nodes.every(callback);
|
||||
};
|
||||
_proto.some = function some(callback) {
|
||||
return this.nodes.some(callback);
|
||||
};
|
||||
_proto.filter = function filter(callback) {
|
||||
return this.nodes.filter(callback);
|
||||
};
|
||||
_proto.sort = function sort(callback) {
|
||||
return this.nodes.sort(callback);
|
||||
};
|
||||
_proto.toString = function toString(options) {
|
||||
if (options === void 0) {
|
||||
options = {};
|
||||
}
|
||||
return this._stringify(options, 0, (0, _util.resolveMaxNestingDepth)(options.maxNestingDepth));
|
||||
};
|
||||
_proto._stringify = function _stringify(options, depth, max) {
|
||||
var _this10 = this;
|
||||
return this.map(function (child) {
|
||||
return _this10._stringifyChild(child, options, depth, max);
|
||||
}).join('');
|
||||
}
|
||||
|
||||
// Serialize a child node. Historically `toString` used `this.map(String)`,
|
||||
// which leniently coerced anything — including raw arrays inserted via
|
||||
// `replaceWith(array)` / `insertBefore` / `insertAfter` (e.g. Tailwind's
|
||||
// `:merge()` expansion). Fall back to `String(child)` for values that are
|
||||
// not parser nodes so that behaviour is preserved.
|
||||
;
|
||||
_proto._stringifyChild = function _stringifyChild(child, options, depth, max) {
|
||||
return typeof child._stringify === 'function' ? child._stringify(options, depth, max) : String(child);
|
||||
};
|
||||
_createClass(Container, [{
|
||||
key: "first",
|
||||
get: function get() {
|
||||
return this.at(0);
|
||||
}
|
||||
}, {
|
||||
key: "last",
|
||||
get: function get() {
|
||||
return this.at(this.length - 1);
|
||||
}
|
||||
}, {
|
||||
key: "length",
|
||||
get: function get() {
|
||||
return this.nodes.length;
|
||||
}
|
||||
}]);
|
||||
return Container;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.isComment = exports.isCombinator = exports.isClassName = exports.isAttribute = void 0;
|
||||
exports.isContainer = isContainer;
|
||||
exports.isIdentifier = void 0;
|
||||
exports.isNamespace = isNamespace;
|
||||
exports.isNesting = void 0;
|
||||
exports.isNode = isNode;
|
||||
exports.isPseudo = void 0;
|
||||
exports.isPseudoClass = isPseudoClass;
|
||||
exports.isPseudoElement = isPseudoElement;
|
||||
exports.isUniversal = exports.isTag = exports.isString = exports.isSelector = exports.isRoot = void 0;
|
||||
var _types = require("./types");
|
||||
var _IS_TYPE;
|
||||
var IS_TYPE = (_IS_TYPE = {}, _IS_TYPE[_types.ATTRIBUTE] = true, _IS_TYPE[_types.CLASS] = true, _IS_TYPE[_types.COMBINATOR] = true, _IS_TYPE[_types.COMMENT] = true, _IS_TYPE[_types.ID] = true, _IS_TYPE[_types.NESTING] = true, _IS_TYPE[_types.PSEUDO] = true, _IS_TYPE[_types.ROOT] = true, _IS_TYPE[_types.SELECTOR] = true, _IS_TYPE[_types.STRING] = true, _IS_TYPE[_types.TAG] = true, _IS_TYPE[_types.UNIVERSAL] = true, _IS_TYPE);
|
||||
function isNode(node) {
|
||||
return typeof node === "object" && IS_TYPE[node.type];
|
||||
}
|
||||
function isNodeType(type, node) {
|
||||
return isNode(node) && node.type === type;
|
||||
}
|
||||
var isAttribute = exports.isAttribute = isNodeType.bind(null, _types.ATTRIBUTE);
|
||||
var isClassName = exports.isClassName = isNodeType.bind(null, _types.CLASS);
|
||||
var isCombinator = exports.isCombinator = isNodeType.bind(null, _types.COMBINATOR);
|
||||
var isComment = exports.isComment = isNodeType.bind(null, _types.COMMENT);
|
||||
var isIdentifier = exports.isIdentifier = isNodeType.bind(null, _types.ID);
|
||||
var isNesting = exports.isNesting = isNodeType.bind(null, _types.NESTING);
|
||||
var isPseudo = exports.isPseudo = isNodeType.bind(null, _types.PSEUDO);
|
||||
var isRoot = exports.isRoot = isNodeType.bind(null, _types.ROOT);
|
||||
var isSelector = exports.isSelector = isNodeType.bind(null, _types.SELECTOR);
|
||||
var isString = exports.isString = isNodeType.bind(null, _types.STRING);
|
||||
var isTag = exports.isTag = isNodeType.bind(null, _types.TAG);
|
||||
var isUniversal = exports.isUniversal = isNodeType.bind(null, _types.UNIVERSAL);
|
||||
function isPseudoElement(node) {
|
||||
return isPseudo(node) && node.value && (node.value.startsWith("::") || node.value.toLowerCase() === ":before" || node.value.toLowerCase() === ":after" || node.value.toLowerCase() === ":first-letter" || node.value.toLowerCase() === ":first-line");
|
||||
}
|
||||
function isPseudoClass(node) {
|
||||
return isPseudo(node) && !isPseudoElement(node);
|
||||
}
|
||||
function isContainer(node) {
|
||||
return !!(isNode(node) && node.walk);
|
||||
}
|
||||
function isNamespace(node) {
|
||||
return isAttribute(node) || isTag(node);
|
||||
}
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var ID = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(ID, _Node);
|
||||
function ID(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
_this.type = _types.ID;
|
||||
return _this;
|
||||
}
|
||||
var _proto = ID.prototype;
|
||||
_proto.valueToString = function valueToString() {
|
||||
return '#' + _Node.prototype.valueToString.call(this);
|
||||
};
|
||||
return ID;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
var _types = require("./types");
|
||||
Object.keys(_types).forEach(function (key) {
|
||||
if (key === "default" || key === "__esModule") return;
|
||||
if (key in exports && exports[key] === _types[key]) return;
|
||||
exports[key] = _types[key];
|
||||
});
|
||||
var _constructors = require("./constructors");
|
||||
Object.keys(_constructors).forEach(function (key) {
|
||||
if (key === "default" || key === "__esModule") return;
|
||||
if (key in exports && exports[key] === _constructors[key]) return;
|
||||
exports[key] = _constructors[key];
|
||||
});
|
||||
var _guards = require("./guards");
|
||||
Object.keys(_guards).forEach(function (key) {
|
||||
if (key === "default" || key === "__esModule") return;
|
||||
if (key in exports && exports[key] === _guards[key]) return;
|
||||
exports[key] = _guards[key];
|
||||
});
|
||||
+81
@@ -0,0 +1,81 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _cssesc = _interopRequireDefault(require("cssesc"));
|
||||
var _util = require("../util");
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
|
||||
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Namespace = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(Namespace, _Node);
|
||||
function Namespace() {
|
||||
return _Node.apply(this, arguments) || this;
|
||||
}
|
||||
var _proto = Namespace.prototype;
|
||||
_proto.qualifiedName = function qualifiedName(value) {
|
||||
if (this.namespace) {
|
||||
return this.namespaceString + "|" + value;
|
||||
} else {
|
||||
return value;
|
||||
}
|
||||
};
|
||||
_proto.valueToString = function valueToString() {
|
||||
return this.qualifiedName(_Node.prototype.valueToString.call(this));
|
||||
};
|
||||
_createClass(Namespace, [{
|
||||
key: "namespace",
|
||||
get: function get() {
|
||||
return this._namespace;
|
||||
},
|
||||
set: function set(namespace) {
|
||||
if (namespace === true || namespace === "*" || namespace === "&") {
|
||||
this._namespace = namespace;
|
||||
if (this.raws) {
|
||||
delete this.raws.namespace;
|
||||
}
|
||||
return;
|
||||
}
|
||||
var escaped = (0, _cssesc["default"])(namespace, {
|
||||
isIdentifier: true
|
||||
});
|
||||
this._namespace = namespace;
|
||||
if (escaped !== namespace) {
|
||||
(0, _util.ensureObject)(this, "raws");
|
||||
this.raws.namespace = escaped;
|
||||
} else if (this.raws) {
|
||||
delete this.raws.namespace;
|
||||
}
|
||||
}
|
||||
}, {
|
||||
key: "ns",
|
||||
get: function get() {
|
||||
return this._namespace;
|
||||
},
|
||||
set: function set(namespace) {
|
||||
this.namespace = namespace;
|
||||
}
|
||||
}, {
|
||||
key: "namespaceString",
|
||||
get: function get() {
|
||||
if (this.namespace) {
|
||||
var ns = this.stringifyProperty("namespace");
|
||||
if (ns === true) {
|
||||
return '';
|
||||
} else {
|
||||
return ns;
|
||||
}
|
||||
} else {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
}]);
|
||||
return Namespace;
|
||||
}(_node["default"]);
|
||||
;
|
||||
module.exports = exports.default;
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Nesting = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(Nesting, _Node);
|
||||
function Nesting(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
_this.type = _types.NESTING;
|
||||
_this.value = '&';
|
||||
return _this;
|
||||
}
|
||||
return Nesting;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+209
@@ -0,0 +1,209 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _util = require("../util");
|
||||
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
|
||||
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
||||
var cloneNode = function cloneNode(obj, parent, depth) {
|
||||
if (depth === void 0) {
|
||||
depth = 0;
|
||||
}
|
||||
// Bound recursion so a pathologically deep node tree raises a catchable
|
||||
// error instead of overflowing the call stack (CVE-2026-9358 / CWE-674).
|
||||
if (depth > _util.MAX_NESTING_DEPTH) {
|
||||
throw new Error("Cannot clone selector: nesting depth exceeds the maximum of " + _util.MAX_NESTING_DEPTH + ".");
|
||||
}
|
||||
if (typeof obj !== 'object' || obj === null) {
|
||||
return obj;
|
||||
}
|
||||
var cloned = new obj.constructor();
|
||||
for (var i in obj) {
|
||||
if (!obj.hasOwnProperty(i)) {
|
||||
continue;
|
||||
}
|
||||
var value = obj[i];
|
||||
var type = typeof value;
|
||||
if (i === 'parent' && type === 'object') {
|
||||
if (parent) {
|
||||
cloned[i] = parent;
|
||||
}
|
||||
} else if (value instanceof Array) {
|
||||
cloned[i] = value.map(function (j) {
|
||||
return cloneNode(j, cloned, depth + 1);
|
||||
});
|
||||
} else {
|
||||
cloned[i] = cloneNode(value, cloned, depth + 1);
|
||||
}
|
||||
}
|
||||
return cloned;
|
||||
};
|
||||
var Node = exports["default"] = /*#__PURE__*/function () {
|
||||
function Node(opts) {
|
||||
if (opts === void 0) {
|
||||
opts = {};
|
||||
}
|
||||
Object.assign(this, opts);
|
||||
this.spaces = this.spaces || {};
|
||||
this.spaces.before = this.spaces.before || '';
|
||||
this.spaces.after = this.spaces.after || '';
|
||||
}
|
||||
var _proto = Node.prototype;
|
||||
_proto.remove = function remove() {
|
||||
if (this.parent) {
|
||||
this.parent.removeChild(this);
|
||||
}
|
||||
this.parent = undefined;
|
||||
return this;
|
||||
};
|
||||
_proto.replaceWith = function replaceWith() {
|
||||
if (this.parent) {
|
||||
for (var index in arguments) {
|
||||
this.parent.insertBefore(this, arguments[index]);
|
||||
}
|
||||
this.remove();
|
||||
}
|
||||
return this;
|
||||
};
|
||||
_proto.next = function next() {
|
||||
return this.parent.at(this.parent.index(this) + 1);
|
||||
};
|
||||
_proto.prev = function prev() {
|
||||
return this.parent.at(this.parent.index(this) - 1);
|
||||
};
|
||||
_proto.clone = function clone(overrides) {
|
||||
if (overrides === void 0) {
|
||||
overrides = {};
|
||||
}
|
||||
var cloned = cloneNode(this);
|
||||
for (var name in overrides) {
|
||||
cloned[name] = overrides[name];
|
||||
}
|
||||
return cloned;
|
||||
}
|
||||
|
||||
/**
|
||||
* Some non-standard syntax doesn't follow normal escaping rules for css.
|
||||
* This allows non standard syntax to be appended to an existing property
|
||||
* by specifying the escaped value. By specifying the escaped value,
|
||||
* illegal characters are allowed to be directly inserted into css output.
|
||||
* @param {string} name the property to set
|
||||
* @param {any} value the unescaped value of the property
|
||||
* @param {string} valueEscaped optional. the escaped value of the property.
|
||||
*/;
|
||||
_proto.appendToPropertyAndEscape = function appendToPropertyAndEscape(name, value, valueEscaped) {
|
||||
if (!this.raws) {
|
||||
this.raws = {};
|
||||
}
|
||||
var originalValue = this[name];
|
||||
var originalEscaped = this.raws[name];
|
||||
this[name] = originalValue + value; // this may trigger a setter that updates raws, so it has to be set first.
|
||||
if (originalEscaped || valueEscaped !== value) {
|
||||
this.raws[name] = (originalEscaped || originalValue) + valueEscaped;
|
||||
} else {
|
||||
delete this.raws[name]; // delete any escaped value that was created by the setter.
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Some non-standard syntax doesn't follow normal escaping rules for css.
|
||||
* This allows the escaped value to be specified directly, allowing illegal
|
||||
* characters to be directly inserted into css output.
|
||||
* @param {string} name the property to set
|
||||
* @param {any} value the unescaped value of the property
|
||||
* @param {string} valueEscaped the escaped value of the property.
|
||||
*/;
|
||||
_proto.setPropertyAndEscape = function setPropertyAndEscape(name, value, valueEscaped) {
|
||||
if (!this.raws) {
|
||||
this.raws = {};
|
||||
}
|
||||
this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
|
||||
this.raws[name] = valueEscaped;
|
||||
}
|
||||
|
||||
/**
|
||||
* When you want a value to passed through to CSS directly. This method
|
||||
* deletes the corresponding raw value causing the stringifier to fallback
|
||||
* to the unescaped value.
|
||||
* @param {string} name the property to set.
|
||||
* @param {any} value The value that is both escaped and unescaped.
|
||||
*/;
|
||||
_proto.setPropertyWithoutEscape = function setPropertyWithoutEscape(name, value) {
|
||||
this[name] = value; // this may trigger a setter that updates raws, so it has to be set first.
|
||||
if (this.raws) {
|
||||
delete this.raws[name];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param {number} line The number (starting with 1)
|
||||
* @param {number} column The column number (starting with 1)
|
||||
*/;
|
||||
_proto.isAtPosition = function isAtPosition(line, column) {
|
||||
if (this.source && this.source.start && this.source.end) {
|
||||
if (this.source.start.line > line) {
|
||||
return false;
|
||||
}
|
||||
if (this.source.end.line < line) {
|
||||
return false;
|
||||
}
|
||||
if (this.source.start.line === line && this.source.start.column > column) {
|
||||
return false;
|
||||
}
|
||||
if (this.source.end.line === line && this.source.end.column < column) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
_proto.stringifyProperty = function stringifyProperty(name) {
|
||||
return this.raws && this.raws[name] || this[name];
|
||||
};
|
||||
_proto.valueToString = function valueToString() {
|
||||
return String(this.stringifyProperty("value"));
|
||||
};
|
||||
_proto.toString = function toString() {
|
||||
return [this.rawSpaceBefore, this.valueToString(), this.rawSpaceAfter].join('');
|
||||
}
|
||||
|
||||
// Internal recursion entry point used by Container serialization. Leaf
|
||||
// nodes don't recurse, so they ignore the depth/limit and stringify
|
||||
// themselves. Containers override this to thread the nesting depth.
|
||||
;
|
||||
_proto._stringify = function _stringify() {
|
||||
return this.toString();
|
||||
};
|
||||
_createClass(Node, [{
|
||||
key: "rawSpaceBefore",
|
||||
get: function get() {
|
||||
var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.before;
|
||||
if (rawSpace === undefined) {
|
||||
rawSpace = this.spaces && this.spaces.before;
|
||||
}
|
||||
return rawSpace || "";
|
||||
},
|
||||
set: function set(raw) {
|
||||
(0, _util.ensureObject)(this, "raws", "spaces");
|
||||
this.raws.spaces.before = raw;
|
||||
}
|
||||
}, {
|
||||
key: "rawSpaceAfter",
|
||||
get: function get() {
|
||||
var rawSpace = this.raws && this.raws.spaces && this.raws.spaces.after;
|
||||
if (rawSpace === undefined) {
|
||||
rawSpace = this.spaces.after;
|
||||
}
|
||||
return rawSpace || "";
|
||||
},
|
||||
set: function set(raw) {
|
||||
(0, _util.ensureObject)(this, "raws", "spaces");
|
||||
this.raws.spaces.after = raw;
|
||||
}
|
||||
}]);
|
||||
return Node;
|
||||
}();
|
||||
module.exports = exports.default;
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _container = _interopRequireDefault(require("./container"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Pseudo = exports["default"] = /*#__PURE__*/function (_Container) {
|
||||
_inheritsLoose(Pseudo, _Container);
|
||||
function Pseudo(opts) {
|
||||
var _this;
|
||||
_this = _Container.call(this, opts) || this;
|
||||
_this.type = _types.PSEUDO;
|
||||
return _this;
|
||||
}
|
||||
var _proto = Pseudo.prototype;
|
||||
_proto._stringify = function _stringify(options, depth, max) {
|
||||
var _this2 = this;
|
||||
if (depth >= max) {
|
||||
throw new Error("Cannot serialize selector: nesting depth exceeds the maximum of " + max + ".");
|
||||
}
|
||||
var params = this.length ? '(' + this.map(function (child) {
|
||||
return _this2._stringifyChild(child, options, depth + 1, max);
|
||||
}).join(',') + ')' : '';
|
||||
return [this.rawSpaceBefore, this.stringifyProperty("value"), params, this.rawSpaceAfter].join('');
|
||||
};
|
||||
return Pseudo;
|
||||
}(_container["default"]);
|
||||
module.exports = exports.default;
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _container = _interopRequireDefault(require("./container"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
|
||||
function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
|
||||
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
|
||||
function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Root = exports["default"] = /*#__PURE__*/function (_Container) {
|
||||
_inheritsLoose(Root, _Container);
|
||||
function Root(opts) {
|
||||
var _this;
|
||||
_this = _Container.call(this, opts) || this;
|
||||
_this.type = _types.ROOT;
|
||||
return _this;
|
||||
}
|
||||
var _proto = Root.prototype;
|
||||
_proto._stringify = function _stringify(options, depth, max) {
|
||||
var _this2 = this;
|
||||
var str = this.reduce(function (memo, selector) {
|
||||
memo.push(_this2._stringifyChild(selector, options, depth, max));
|
||||
return memo;
|
||||
}, []).join(',');
|
||||
return this.trailingComma ? str + ',' : str;
|
||||
};
|
||||
_proto.error = function error(message, options) {
|
||||
if (this._error) {
|
||||
return this._error(message, options);
|
||||
} else {
|
||||
return new Error(message);
|
||||
}
|
||||
};
|
||||
_createClass(Root, [{
|
||||
key: "errorGenerator",
|
||||
set: function set(handler) {
|
||||
this._error = handler;
|
||||
}
|
||||
}]);
|
||||
return Root;
|
||||
}(_container["default"]);
|
||||
module.exports = exports.default;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _container = _interopRequireDefault(require("./container"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Selector = exports["default"] = /*#__PURE__*/function (_Container) {
|
||||
_inheritsLoose(Selector, _Container);
|
||||
function Selector(opts) {
|
||||
var _this;
|
||||
_this = _Container.call(this, opts) || this;
|
||||
_this.type = _types.SELECTOR;
|
||||
return _this;
|
||||
}
|
||||
return Selector;
|
||||
}(_container["default"]);
|
||||
module.exports = exports.default;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _node = _interopRequireDefault(require("./node"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var String = exports["default"] = /*#__PURE__*/function (_Node) {
|
||||
_inheritsLoose(String, _Node);
|
||||
function String(opts) {
|
||||
var _this;
|
||||
_this = _Node.call(this, opts) || this;
|
||||
_this.type = _types.STRING;
|
||||
return _this;
|
||||
}
|
||||
return String;
|
||||
}(_node["default"]);
|
||||
module.exports = exports.default;
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _namespace = _interopRequireDefault(require("./namespace"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Tag = exports["default"] = /*#__PURE__*/function (_Namespace) {
|
||||
_inheritsLoose(Tag, _Namespace);
|
||||
function Tag(opts) {
|
||||
var _this;
|
||||
_this = _Namespace.call(this, opts) || this;
|
||||
_this.type = _types.TAG;
|
||||
return _this;
|
||||
}
|
||||
return Tag;
|
||||
}(_namespace["default"]);
|
||||
module.exports = exports.default;
|
||||
+16
@@ -0,0 +1,16 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.UNIVERSAL = exports.TAG = exports.STRING = exports.SELECTOR = exports.ROOT = exports.PSEUDO = exports.NESTING = exports.ID = exports.COMMENT = exports.COMBINATOR = exports.CLASS = exports.ATTRIBUTE = void 0;
|
||||
var TAG = exports.TAG = 'tag';
|
||||
var STRING = exports.STRING = 'string';
|
||||
var SELECTOR = exports.SELECTOR = 'selector';
|
||||
var ROOT = exports.ROOT = 'root';
|
||||
var PSEUDO = exports.PSEUDO = 'pseudo';
|
||||
var NESTING = exports.NESTING = 'nesting';
|
||||
var ID = exports.ID = 'id';
|
||||
var COMMENT = exports.COMMENT = 'comment';
|
||||
var COMBINATOR = exports.COMBINATOR = 'combinator';
|
||||
var CLASS = exports.CLASS = 'class';
|
||||
var ATTRIBUTE = exports.ATTRIBUTE = 'attribute';
|
||||
var UNIVERSAL = exports.UNIVERSAL = 'universal';
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = void 0;
|
||||
var _namespace = _interopRequireDefault(require("./namespace"));
|
||||
var _types = require("./types");
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
function _inheritsLoose(t, o) { t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o); }
|
||||
function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
|
||||
var Universal = exports["default"] = /*#__PURE__*/function (_Namespace) {
|
||||
_inheritsLoose(Universal, _Namespace);
|
||||
function Universal(opts) {
|
||||
var _this;
|
||||
_this = _Namespace.call(this, opts) || this;
|
||||
_this.type = _types.UNIVERSAL;
|
||||
_this.value = '*';
|
||||
return _this;
|
||||
}
|
||||
return Universal;
|
||||
}(_namespace["default"]);
|
||||
module.exports = exports.default;
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = sortAscending;
|
||||
function sortAscending(list) {
|
||||
return list.sort(function (a, b) {
|
||||
return a - b;
|
||||
});
|
||||
}
|
||||
;
|
||||
module.exports = exports.default;
|
||||
+40
@@ -0,0 +1,40 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.word = exports.tilde = exports.tab = exports.str = exports.space = exports.slash = exports.singleQuote = exports.semicolon = exports.plus = exports.pipe = exports.openSquare = exports.openParenthesis = exports.newline = exports.greaterThan = exports.feed = exports.equals = exports.doubleQuote = exports.dollar = exports.cr = exports.comment = exports.comma = exports.combinator = exports.colon = exports.closeSquare = exports.closeParenthesis = exports.caret = exports.bang = exports.backslash = exports.at = exports.asterisk = exports.ampersand = void 0;
|
||||
var ampersand = exports.ampersand = 38; // `&`.charCodeAt(0);
|
||||
var asterisk = exports.asterisk = 42; // `*`.charCodeAt(0);
|
||||
var at = exports.at = 64; // `@`.charCodeAt(0);
|
||||
var comma = exports.comma = 44; // `,`.charCodeAt(0);
|
||||
var colon = exports.colon = 58; // `:`.charCodeAt(0);
|
||||
var semicolon = exports.semicolon = 59; // `;`.charCodeAt(0);
|
||||
var openParenthesis = exports.openParenthesis = 40; // `(`.charCodeAt(0);
|
||||
var closeParenthesis = exports.closeParenthesis = 41; // `)`.charCodeAt(0);
|
||||
var openSquare = exports.openSquare = 91; // `[`.charCodeAt(0);
|
||||
var closeSquare = exports.closeSquare = 93; // `]`.charCodeAt(0);
|
||||
var dollar = exports.dollar = 36; // `$`.charCodeAt(0);
|
||||
var tilde = exports.tilde = 126; // `~`.charCodeAt(0);
|
||||
var caret = exports.caret = 94; // `^`.charCodeAt(0);
|
||||
var plus = exports.plus = 43; // `+`.charCodeAt(0);
|
||||
var equals = exports.equals = 61; // `=`.charCodeAt(0);
|
||||
var pipe = exports.pipe = 124; // `|`.charCodeAt(0);
|
||||
var greaterThan = exports.greaterThan = 62; // `>`.charCodeAt(0);
|
||||
var space = exports.space = 32; // ` `.charCodeAt(0);
|
||||
var singleQuote = exports.singleQuote = 39; // `'`.charCodeAt(0);
|
||||
var doubleQuote = exports.doubleQuote = 34; // `"`.charCodeAt(0);
|
||||
var slash = exports.slash = 47; // `/`.charCodeAt(0);
|
||||
var bang = exports.bang = 33; // `!`.charCodeAt(0);
|
||||
|
||||
var backslash = exports.backslash = 92; // '\\'.charCodeAt(0);
|
||||
var cr = exports.cr = 13; // '\r'.charCodeAt(0);
|
||||
var feed = exports.feed = 12; // '\f'.charCodeAt(0);
|
||||
var newline = exports.newline = 10; // '\n'.charCodeAt(0);
|
||||
var tab = exports.tab = 9; // '\t'.charCodeAt(0);
|
||||
|
||||
// Expose aliases primarily for readability.
|
||||
var str = exports.str = singleQuote;
|
||||
|
||||
// No good single character representation!
|
||||
var comment = exports.comment = -1;
|
||||
var word = exports.word = -2;
|
||||
var combinator = exports.combinator = -3;
|
||||
+237
@@ -0,0 +1,237 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.FIELDS = void 0;
|
||||
exports["default"] = tokenize;
|
||||
var t = _interopRequireWildcard(require("./tokenTypes"));
|
||||
var _unescapable, _wordDelimiters;
|
||||
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) { "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); } return f; })(e, t); }
|
||||
var unescapable = (_unescapable = {}, _unescapable[t.tab] = true, _unescapable[t.newline] = true, _unescapable[t.cr] = true, _unescapable[t.feed] = true, _unescapable);
|
||||
var wordDelimiters = (_wordDelimiters = {}, _wordDelimiters[t.space] = true, _wordDelimiters[t.tab] = true, _wordDelimiters[t.newline] = true, _wordDelimiters[t.cr] = true, _wordDelimiters[t.feed] = true, _wordDelimiters[t.ampersand] = true, _wordDelimiters[t.asterisk] = true, _wordDelimiters[t.bang] = true, _wordDelimiters[t.comma] = true, _wordDelimiters[t.colon] = true, _wordDelimiters[t.semicolon] = true, _wordDelimiters[t.openParenthesis] = true, _wordDelimiters[t.closeParenthesis] = true, _wordDelimiters[t.openSquare] = true, _wordDelimiters[t.closeSquare] = true, _wordDelimiters[t.singleQuote] = true, _wordDelimiters[t.doubleQuote] = true, _wordDelimiters[t.plus] = true, _wordDelimiters[t.pipe] = true, _wordDelimiters[t.tilde] = true, _wordDelimiters[t.greaterThan] = true, _wordDelimiters[t.equals] = true, _wordDelimiters[t.dollar] = true, _wordDelimiters[t.caret] = true, _wordDelimiters[t.slash] = true, _wordDelimiters);
|
||||
var hex = {};
|
||||
var hexChars = "0123456789abcdefABCDEF";
|
||||
for (var i = 0; i < hexChars.length; i++) {
|
||||
hex[hexChars.charCodeAt(i)] = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last index of the bar css word
|
||||
* @param {string} css The string in which the word begins
|
||||
* @param {number} start The index into the string where word's first letter occurs
|
||||
*/
|
||||
function consumeWord(css, start) {
|
||||
var next = start;
|
||||
var code;
|
||||
do {
|
||||
code = css.charCodeAt(next);
|
||||
if (wordDelimiters[code]) {
|
||||
return next - 1;
|
||||
} else if (code === t.backslash) {
|
||||
next = consumeEscape(css, next) + 1;
|
||||
} else {
|
||||
// All other characters are part of the word
|
||||
next++;
|
||||
}
|
||||
} while (next < css.length);
|
||||
return next - 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the last index of the escape sequence
|
||||
* @param {string} css The string in which the sequence begins
|
||||
* @param {number} start The index into the string where escape character (`\`) occurs.
|
||||
*/
|
||||
function consumeEscape(css, start) {
|
||||
var next = start;
|
||||
var code = css.charCodeAt(next + 1);
|
||||
if (unescapable[code]) {
|
||||
// just consume the escape char
|
||||
} else if (hex[code]) {
|
||||
var hexDigits = 0;
|
||||
// consume up to 6 hex chars
|
||||
do {
|
||||
next++;
|
||||
hexDigits++;
|
||||
code = css.charCodeAt(next + 1);
|
||||
} while (hex[code] && hexDigits < 6);
|
||||
// if fewer than 6 hex chars, a trailing space ends the escape
|
||||
if (hexDigits < 6 && code === t.space) {
|
||||
next++;
|
||||
}
|
||||
} else {
|
||||
// the next char is part of the current word
|
||||
next++;
|
||||
}
|
||||
return next;
|
||||
}
|
||||
var FIELDS = exports.FIELDS = {
|
||||
TYPE: 0,
|
||||
START_LINE: 1,
|
||||
START_COL: 2,
|
||||
END_LINE: 3,
|
||||
END_COL: 4,
|
||||
START_POS: 5,
|
||||
END_POS: 6
|
||||
};
|
||||
function tokenize(input) {
|
||||
var tokens = [];
|
||||
var css = input.css.valueOf();
|
||||
var _css = css,
|
||||
length = _css.length;
|
||||
var offset = -1;
|
||||
var line = 1;
|
||||
var start = 0;
|
||||
var end = 0;
|
||||
var code, content, endColumn, endLine, escaped, escapePos, last, lines, next, nextLine, nextOffset, quote, tokenType;
|
||||
function unclosed(what, fix) {
|
||||
if (input.safe) {
|
||||
// fyi: this is never set to true.
|
||||
css += fix;
|
||||
next = css.length - 1;
|
||||
} else {
|
||||
throw input.error('Unclosed ' + what, line, start - offset, start);
|
||||
}
|
||||
}
|
||||
while (start < length) {
|
||||
code = css.charCodeAt(start);
|
||||
if (code === t.newline) {
|
||||
offset = start;
|
||||
line += 1;
|
||||
}
|
||||
switch (code) {
|
||||
case t.space:
|
||||
case t.tab:
|
||||
case t.newline:
|
||||
case t.cr:
|
||||
case t.feed:
|
||||
next = start;
|
||||
do {
|
||||
next += 1;
|
||||
code = css.charCodeAt(next);
|
||||
if (code === t.newline) {
|
||||
offset = next;
|
||||
line += 1;
|
||||
}
|
||||
} while (code === t.space || code === t.newline || code === t.tab || code === t.cr || code === t.feed);
|
||||
tokenType = t.space;
|
||||
endLine = line;
|
||||
endColumn = next - offset - 1;
|
||||
end = next;
|
||||
break;
|
||||
case t.plus:
|
||||
case t.greaterThan:
|
||||
case t.tilde:
|
||||
case t.pipe:
|
||||
next = start;
|
||||
do {
|
||||
next += 1;
|
||||
code = css.charCodeAt(next);
|
||||
} while (code === t.plus || code === t.greaterThan || code === t.tilde || code === t.pipe);
|
||||
tokenType = t.combinator;
|
||||
endLine = line;
|
||||
endColumn = start - offset;
|
||||
end = next;
|
||||
break;
|
||||
|
||||
// Consume these characters as single tokens.
|
||||
case t.asterisk:
|
||||
case t.ampersand:
|
||||
case t.bang:
|
||||
case t.comma:
|
||||
case t.equals:
|
||||
case t.dollar:
|
||||
case t.caret:
|
||||
case t.openSquare:
|
||||
case t.closeSquare:
|
||||
case t.colon:
|
||||
case t.semicolon:
|
||||
case t.openParenthesis:
|
||||
case t.closeParenthesis:
|
||||
next = start;
|
||||
tokenType = code;
|
||||
endLine = line;
|
||||
endColumn = start - offset;
|
||||
end = next + 1;
|
||||
break;
|
||||
case t.singleQuote:
|
||||
case t.doubleQuote:
|
||||
quote = code === t.singleQuote ? "'" : '"';
|
||||
next = start;
|
||||
do {
|
||||
escaped = false;
|
||||
next = css.indexOf(quote, next + 1);
|
||||
if (next === -1) {
|
||||
unclosed('quote', quote);
|
||||
}
|
||||
escapePos = next;
|
||||
while (css.charCodeAt(escapePos - 1) === t.backslash) {
|
||||
escapePos -= 1;
|
||||
escaped = !escaped;
|
||||
}
|
||||
} while (escaped);
|
||||
tokenType = t.str;
|
||||
endLine = line;
|
||||
endColumn = start - offset;
|
||||
end = next + 1;
|
||||
break;
|
||||
default:
|
||||
if (code === t.slash && css.charCodeAt(start + 1) === t.asterisk) {
|
||||
next = css.indexOf('*/', start + 2) + 1;
|
||||
if (next === 0) {
|
||||
unclosed('comment', '*/');
|
||||
}
|
||||
content = css.slice(start, next + 1);
|
||||
lines = content.split('\n');
|
||||
last = lines.length - 1;
|
||||
if (last > 0) {
|
||||
nextLine = line + last;
|
||||
nextOffset = next - lines[last].length;
|
||||
} else {
|
||||
nextLine = line;
|
||||
nextOffset = offset;
|
||||
}
|
||||
tokenType = t.comment;
|
||||
line = nextLine;
|
||||
endLine = nextLine;
|
||||
endColumn = next - nextOffset;
|
||||
} else if (code === t.slash) {
|
||||
next = start;
|
||||
tokenType = code;
|
||||
endLine = line;
|
||||
endColumn = start - offset;
|
||||
end = next + 1;
|
||||
} else {
|
||||
next = consumeWord(css, start);
|
||||
tokenType = t.word;
|
||||
endLine = line;
|
||||
endColumn = next - offset;
|
||||
}
|
||||
end = next + 1;
|
||||
break;
|
||||
}
|
||||
|
||||
// Ensure that the token structure remains consistent
|
||||
tokens.push([tokenType,
|
||||
// [0] Token type
|
||||
line,
|
||||
// [1] Starting line
|
||||
start - offset,
|
||||
// [2] Starting column
|
||||
endLine,
|
||||
// [3] Ending line
|
||||
endColumn,
|
||||
// [4] Ending column
|
||||
start,
|
||||
// [5] Start position / Source index
|
||||
end // [6] End position
|
||||
]);
|
||||
|
||||
// Reset offset for the next token
|
||||
if (nextOffset) {
|
||||
offset = nextOffset;
|
||||
nextOffset = null;
|
||||
}
|
||||
start = end;
|
||||
}
|
||||
return tokens;
|
||||
}
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = ensureObject;
|
||||
function ensureObject(obj) {
|
||||
for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||||
props[_key - 1] = arguments[_key];
|
||||
}
|
||||
while (props.length > 0) {
|
||||
var prop = props.shift();
|
||||
if (!obj[prop]) {
|
||||
obj[prop] = {};
|
||||
}
|
||||
obj = obj[prop];
|
||||
}
|
||||
}
|
||||
module.exports = exports.default;
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = getProp;
|
||||
function getProp(obj) {
|
||||
for (var _len = arguments.length, props = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
||||
props[_key - 1] = arguments[_key];
|
||||
}
|
||||
while (props.length > 0) {
|
||||
var prop = props.shift();
|
||||
if (!obj[prop]) {
|
||||
return undefined;
|
||||
}
|
||||
obj = obj[prop];
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
module.exports = exports.default;
|
||||
+17
@@ -0,0 +1,17 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.unesc = exports.stripComments = exports.resolveMaxNestingDepth = exports.getProp = exports.ensureObject = exports.MAX_NESTING_DEPTH = void 0;
|
||||
var _unesc = _interopRequireDefault(require("./unesc"));
|
||||
exports.unesc = _unesc["default"];
|
||||
var _getProp = _interopRequireDefault(require("./getProp"));
|
||||
exports.getProp = _getProp["default"];
|
||||
var _ensureObject = _interopRequireDefault(require("./ensureObject"));
|
||||
exports.ensureObject = _ensureObject["default"];
|
||||
var _stripComments = _interopRequireDefault(require("./stripComments"));
|
||||
exports.stripComments = _stripComments["default"];
|
||||
var _maxNestingDepth = _interopRequireWildcard(require("./maxNestingDepth"));
|
||||
exports.resolveMaxNestingDepth = _maxNestingDepth["default"];
|
||||
exports.MAX_NESTING_DEPTH = _maxNestingDepth.MAX_NESTING_DEPTH;
|
||||
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) { "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); } return f; })(e, t); }
|
||||
function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
|
||||
+26
@@ -0,0 +1,26 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports.MAX_NESTING_DEPTH = void 0;
|
||||
exports["default"] = resolveMaxNestingDepth;
|
||||
/**
|
||||
* The default maximum selector nesting depth allowed when parsing or
|
||||
* serializing a selector. Going beyond this would otherwise recurse deeply
|
||||
* enough to overflow the call stack (CVE-2026-9358 / CWE-674). Real-world
|
||||
* selectors never get anywhere near this, so it acts purely as a safety net
|
||||
* that turns an uncatchable stack overflow into a catchable error.
|
||||
*/
|
||||
var MAX_NESTING_DEPTH = exports.MAX_NESTING_DEPTH = 256;
|
||||
|
||||
/**
|
||||
* Coerce a user-supplied nesting-depth limit into a safe value. Anything that
|
||||
* is not a non-negative safe integer (NaN, Infinity, negative numbers, or a
|
||||
* non-number) would disable or break the guard, so it falls back to the
|
||||
* default.
|
||||
*
|
||||
* @param {unknown} value the limit provided through the `maxNestingDepth` option
|
||||
* @returns {number} a safe, non-negative integer limit
|
||||
*/
|
||||
function resolveMaxNestingDepth(value) {
|
||||
return Number.isSafeInteger(value) && value >= 0 ? value : MAX_NESTING_DEPTH;
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = stripComments;
|
||||
function stripComments(str) {
|
||||
var s = "";
|
||||
var commentStart = str.indexOf("/*");
|
||||
var lastEnd = 0;
|
||||
while (commentStart >= 0) {
|
||||
s = s + str.slice(lastEnd, commentStart);
|
||||
var commentEnd = str.indexOf("*/", commentStart + 2);
|
||||
if (commentEnd < 0) {
|
||||
return s;
|
||||
}
|
||||
lastEnd = commentEnd + 2;
|
||||
commentStart = str.indexOf("/*", lastEnd);
|
||||
}
|
||||
s = s + str.slice(lastEnd);
|
||||
return s;
|
||||
}
|
||||
module.exports = exports.default;
|
||||
+76
@@ -0,0 +1,76 @@
|
||||
"use strict";
|
||||
|
||||
exports.__esModule = true;
|
||||
exports["default"] = unesc;
|
||||
// Many thanks for this post which made this migration much easier.
|
||||
// https://mathiasbynens.be/notes/css-escapes
|
||||
|
||||
/**
|
||||
*
|
||||
* @param {string} str
|
||||
* @returns {[string, number]|undefined}
|
||||
*/
|
||||
function gobbleHex(str) {
|
||||
var lower = str.toLowerCase();
|
||||
var hex = '';
|
||||
var spaceTerminated = false;
|
||||
for (var i = 0; i < 6 && lower[i] !== undefined; i++) {
|
||||
var code = lower.charCodeAt(i);
|
||||
// check to see if we are dealing with a valid hex char [a-f|0-9]
|
||||
var valid = code >= 97 && code <= 102 || code >= 48 && code <= 57;
|
||||
// https://drafts.csswg.org/css-syntax/#consume-escaped-code-point
|
||||
spaceTerminated = code === 32;
|
||||
if (!valid) {
|
||||
break;
|
||||
}
|
||||
hex += lower[i];
|
||||
}
|
||||
if (hex.length === 0) {
|
||||
return undefined;
|
||||
}
|
||||
var codePoint = parseInt(hex, 16);
|
||||
var isSurrogate = codePoint >= 0xD800 && codePoint <= 0xDFFF;
|
||||
// Add special case for
|
||||
// "If this number is zero, or is for a surrogate, or is greater than the maximum allowed code point"
|
||||
// https://drafts.csswg.org/css-syntax/#maximum-allowed-code-point
|
||||
if (isSurrogate || codePoint === 0x0000 || codePoint > 0x10FFFF) {
|
||||
return ["\uFFFD", hex.length + (spaceTerminated ? 1 : 0)];
|
||||
}
|
||||
return [String.fromCodePoint(codePoint), hex.length + (spaceTerminated ? 1 : 0)];
|
||||
}
|
||||
var CONTAINS_ESCAPE = /\\/;
|
||||
function unesc(str) {
|
||||
var needToProcess = CONTAINS_ESCAPE.test(str);
|
||||
if (!needToProcess) {
|
||||
return str;
|
||||
}
|
||||
var ret = "";
|
||||
for (var i = 0; i < str.length; i++) {
|
||||
if (str[i] === "\\") {
|
||||
var gobbled = gobbleHex(str.slice(i + 1, i + 7));
|
||||
if (gobbled !== undefined) {
|
||||
ret += gobbled[0];
|
||||
i += gobbled[1];
|
||||
continue;
|
||||
}
|
||||
|
||||
// Retain a pair of \\ if double escaped `\\\\`
|
||||
// https://github.com/postcss/postcss-selector-parser/commit/268c9a7656fb53f543dc620aa5b73a30ec3ff20e
|
||||
if (str[i + 1] === "\\") {
|
||||
ret += "\\";
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
|
||||
// if \\ is at the end of the string retain it
|
||||
// https://github.com/postcss/postcss-selector-parser/commit/01a6b346e3612ce1ab20219acc26abdc259ccefb
|
||||
if (str.length === i + 1) {
|
||||
ret += str[i];
|
||||
}
|
||||
continue;
|
||||
}
|
||||
ret += str[i];
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
module.exports = exports.default;
|
||||
Reference in New Issue
Block a user