jlacoste
209 lines
7.4 KiB
JavaScript
209 lines
7.4 KiB
JavaScript
"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; |