@design.estate/dees-domtools
Version:
A package providing tools to simplify complex CSS structures and web development tasks, featuring TypeScript support and integration with various web technologies.
1,314 lines (1,306 loc) • 1.33 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __require = /* @__PURE__ */ ((x2) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x2, {
get: (a3, b4) => (typeof require !== "undefined" ? require : a3)[b4]
}) : x2)(function(x2) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x2 + '" is not supported');
});
var __commonJS = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all3) => {
for (var name in all3)
__defProp(target, name, { get: all3[name], enumerable: true });
};
var __copyProps = (to, from2, except, desc) => {
if (from2 && typeof from2 === "object" || typeof from2 === "function") {
for (let key2 of __getOwnPropNames(from2))
if (!__hasOwnProp.call(to, key2) && key2 !== except)
__defProp(to, key2, { get: () => from2[key2], enumerable: !(desc = __getOwnPropDesc(from2, key2)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
// node_modules/.pnpm/@push.rocks+isounique@1.0.5/node_modules/@push.rocks/isounique/dist_ts/index.js
var require_dist_ts = __commonJS({
"node_modules/.pnpm/@push.rocks+isounique@1.0.5/node_modules/@push.rocks/isounique/dist_ts/index.js"(exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.uni = void 0;
var uni3 = (prefix = "uni") => {
return `${prefix}_${`xxxxxxxxxxxxxxxxxxxxxxxx`.replace(/[xy]/g, (c4) => {
const r5 = Math.random() * 16 | 0;
const v3 = c4 === "x" ? r5 : r5 & 3 | 8;
return v3.toString(16);
})}`;
};
exports.uni = uni3;
}
});
// node_modules/.pnpm/dayjs@1.11.13/node_modules/dayjs/dayjs.min.js
var require_dayjs_min = __commonJS({
"node_modules/.pnpm/dayjs@1.11.13/node_modules/dayjs/dayjs.min.js"(exports, module) {
!function(t3, e4) {
"object" == typeof exports && "undefined" != typeof module ? module.exports = e4() : "function" == typeof define && define.amd ? define(e4) : (t3 = "undefined" != typeof globalThis ? globalThis : t3 || self).dayjs = e4();
}(exports, function() {
"use strict";
var t3 = 1e3, e4 = 6e4, n5 = 36e5, r5 = "millisecond", i5 = "second", s3 = "minute", u3 = "hour", a3 = "day", o4 = "week", c4 = "month", f4 = "quarter", h3 = "year", d4 = "date", l4 = "Invalid Date", $2 = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y4 = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M2 = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t4) {
var e5 = ["th", "st", "nd", "rd"], n6 = t4 % 100;
return "[" + t4 + (e5[(n6 - 20) % 10] || e5[n6] || e5[0]) + "]";
} }, m3 = function(t4, e5, n6) {
var r6 = String(t4);
return !r6 || r6.length >= e5 ? t4 : "" + Array(e5 + 1 - r6.length).join(n6) + t4;
}, v3 = { s: m3, z: function(t4) {
var e5 = -t4.utcOffset(), n6 = Math.abs(e5), r6 = Math.floor(n6 / 60), i6 = n6 % 60;
return (e5 <= 0 ? "+" : "-") + m3(r6, 2, "0") + ":" + m3(i6, 2, "0");
}, m: function t4(e5, n6) {
if (e5.date() < n6.date()) return -t4(n6, e5);
var r6 = 12 * (n6.year() - e5.year()) + (n6.month() - e5.month()), i6 = e5.clone().add(r6, c4), s4 = n6 - i6 < 0, u4 = e5.clone().add(r6 + (s4 ? -1 : 1), c4);
return +(-(r6 + (n6 - i6) / (s4 ? i6 - u4 : u4 - i6)) || 0);
}, a: function(t4) {
return t4 < 0 ? Math.ceil(t4) || 0 : Math.floor(t4);
}, p: function(t4) {
return { M: c4, y: h3, w: o4, d: a3, D: d4, h: u3, m: s3, s: i5, ms: r5, Q: f4 }[t4] || String(t4 || "").toLowerCase().replace(/s$/, "");
}, u: function(t4) {
return void 0 === t4;
} }, g3 = "en", D2 = {};
D2[g3] = M2;
var p5 = "$isDayjsObject", S4 = function(t4) {
return t4 instanceof _3 || !(!t4 || !t4[p5]);
}, w2 = function t4(e5, n6, r6) {
var i6;
if (!e5) return g3;
if ("string" == typeof e5) {
var s4 = e5.toLowerCase();
D2[s4] && (i6 = s4), n6 && (D2[s4] = n6, i6 = s4);
var u4 = e5.split("-");
if (!i6 && u4.length > 1) return t4(u4[0]);
} else {
var a4 = e5.name;
D2[a4] = e5, i6 = a4;
}
return !r6 && i6 && (g3 = i6), i6 || !r6 && g3;
}, O2 = function(t4, e5) {
if (S4(t4)) return t4.clone();
var n6 = "object" == typeof e5 ? e5 : {};
return n6.date = t4, n6.args = arguments, new _3(n6);
}, b4 = v3;
b4.l = w2, b4.i = S4, b4.w = function(t4, e5) {
return O2(t4, { locale: e5.$L, utc: e5.$u, x: e5.$x, $offset: e5.$offset });
};
var _3 = function() {
function M3(t4) {
this.$L = w2(t4.locale, null, true), this.parse(t4), this.$x = this.$x || t4.x || {}, this[p5] = true;
}
var m4 = M3.prototype;
return m4.parse = function(t4) {
this.$d = function(t5) {
var e5 = t5.date, n6 = t5.utc;
if (null === e5) return /* @__PURE__ */ new Date(NaN);
if (b4.u(e5)) return /* @__PURE__ */ new Date();
if (e5 instanceof Date) return new Date(e5);
if ("string" == typeof e5 && !/Z$/i.test(e5)) {
var r6 = e5.match($2);
if (r6) {
var i6 = r6[2] - 1 || 0, s4 = (r6[7] || "0").substring(0, 3);
return n6 ? new Date(Date.UTC(r6[1], i6, r6[3] || 1, r6[4] || 0, r6[5] || 0, r6[6] || 0, s4)) : new Date(r6[1], i6, r6[3] || 1, r6[4] || 0, r6[5] || 0, r6[6] || 0, s4);
}
}
return new Date(e5);
}(t4), this.init();
}, m4.init = function() {
var t4 = this.$d;
this.$y = t4.getFullYear(), this.$M = t4.getMonth(), this.$D = t4.getDate(), this.$W = t4.getDay(), this.$H = t4.getHours(), this.$m = t4.getMinutes(), this.$s = t4.getSeconds(), this.$ms = t4.getMilliseconds();
}, m4.$utils = function() {
return b4;
}, m4.isValid = function() {
return !(this.$d.toString() === l4);
}, m4.isSame = function(t4, e5) {
var n6 = O2(t4);
return this.startOf(e5) <= n6 && n6 <= this.endOf(e5);
}, m4.isAfter = function(t4, e5) {
return O2(t4) < this.startOf(e5);
}, m4.isBefore = function(t4, e5) {
return this.endOf(e5) < O2(t4);
}, m4.$g = function(t4, e5, n6) {
return b4.u(t4) ? this[e5] : this.set(n6, t4);
}, m4.unix = function() {
return Math.floor(this.valueOf() / 1e3);
}, m4.valueOf = function() {
return this.$d.getTime();
}, m4.startOf = function(t4, e5) {
var n6 = this, r6 = !!b4.u(e5) || e5, f5 = b4.p(t4), l5 = function(t5, e6) {
var i6 = b4.w(n6.$u ? Date.UTC(n6.$y, e6, t5) : new Date(n6.$y, e6, t5), n6);
return r6 ? i6 : i6.endOf(a3);
}, $3 = function(t5, e6) {
return b4.w(n6.toDate()[t5].apply(n6.toDate("s"), (r6 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e6)), n6);
}, y5 = this.$W, M4 = this.$M, m5 = this.$D, v4 = "set" + (this.$u ? "UTC" : "");
switch (f5) {
case h3:
return r6 ? l5(1, 0) : l5(31, 11);
case c4:
return r6 ? l5(1, M4) : l5(0, M4 + 1);
case o4:
var g4 = this.$locale().weekStart || 0, D3 = (y5 < g4 ? y5 + 7 : y5) - g4;
return l5(r6 ? m5 - D3 : m5 + (6 - D3), M4);
case a3:
case d4:
return $3(v4 + "Hours", 0);
case u3:
return $3(v4 + "Minutes", 1);
case s3:
return $3(v4 + "Seconds", 2);
case i5:
return $3(v4 + "Milliseconds", 3);
default:
return this.clone();
}
}, m4.endOf = function(t4) {
return this.startOf(t4, false);
}, m4.$set = function(t4, e5) {
var n6, o5 = b4.p(t4), f5 = "set" + (this.$u ? "UTC" : ""), l5 = (n6 = {}, n6[a3] = f5 + "Date", n6[d4] = f5 + "Date", n6[c4] = f5 + "Month", n6[h3] = f5 + "FullYear", n6[u3] = f5 + "Hours", n6[s3] = f5 + "Minutes", n6[i5] = f5 + "Seconds", n6[r5] = f5 + "Milliseconds", n6)[o5], $3 = o5 === a3 ? this.$D + (e5 - this.$W) : e5;
if (o5 === c4 || o5 === h3) {
var y5 = this.clone().set(d4, 1);
y5.$d[l5]($3), y5.init(), this.$d = y5.set(d4, Math.min(this.$D, y5.daysInMonth())).$d;
} else l5 && this.$d[l5]($3);
return this.init(), this;
}, m4.set = function(t4, e5) {
return this.clone().$set(t4, e5);
}, m4.get = function(t4) {
return this[b4.p(t4)]();
}, m4.add = function(r6, f5) {
var d5, l5 = this;
r6 = Number(r6);
var $3 = b4.p(f5), y5 = function(t4) {
var e5 = O2(l5);
return b4.w(e5.date(e5.date() + Math.round(t4 * r6)), l5);
};
if ($3 === c4) return this.set(c4, this.$M + r6);
if ($3 === h3) return this.set(h3, this.$y + r6);
if ($3 === a3) return y5(1);
if ($3 === o4) return y5(7);
var M4 = (d5 = {}, d5[s3] = e4, d5[u3] = n5, d5[i5] = t3, d5)[$3] || 1, m5 = this.$d.getTime() + r6 * M4;
return b4.w(m5, this);
}, m4.subtract = function(t4, e5) {
return this.add(-1 * t4, e5);
}, m4.format = function(t4) {
var e5 = this, n6 = this.$locale();
if (!this.isValid()) return n6.invalidDate || l4;
var r6 = t4 || "YYYY-MM-DDTHH:mm:ssZ", i6 = b4.z(this), s4 = this.$H, u4 = this.$m, a4 = this.$M, o5 = n6.weekdays, c5 = n6.months, f5 = n6.meridiem, h4 = function(t5, n7, i7, s5) {
return t5 && (t5[n7] || t5(e5, r6)) || i7[n7].slice(0, s5);
}, d5 = function(t5) {
return b4.s(s4 % 12 || 12, t5, "0");
}, $3 = f5 || function(t5, e6, n7) {
var r7 = t5 < 12 ? "AM" : "PM";
return n7 ? r7.toLowerCase() : r7;
};
return r6.replace(y4, function(t5, r7) {
return r7 || function(t6) {
switch (t6) {
case "YY":
return String(e5.$y).slice(-2);
case "YYYY":
return b4.s(e5.$y, 4, "0");
case "M":
return a4 + 1;
case "MM":
return b4.s(a4 + 1, 2, "0");
case "MMM":
return h4(n6.monthsShort, a4, c5, 3);
case "MMMM":
return h4(c5, a4);
case "D":
return e5.$D;
case "DD":
return b4.s(e5.$D, 2, "0");
case "d":
return String(e5.$W);
case "dd":
return h4(n6.weekdaysMin, e5.$W, o5, 2);
case "ddd":
return h4(n6.weekdaysShort, e5.$W, o5, 3);
case "dddd":
return o5[e5.$W];
case "H":
return String(s4);
case "HH":
return b4.s(s4, 2, "0");
case "h":
return d5(1);
case "hh":
return d5(2);
case "a":
return $3(s4, u4, true);
case "A":
return $3(s4, u4, false);
case "m":
return String(u4);
case "mm":
return b4.s(u4, 2, "0");
case "s":
return String(e5.$s);
case "ss":
return b4.s(e5.$s, 2, "0");
case "SSS":
return b4.s(e5.$ms, 3, "0");
case "Z":
return i6;
}
return null;
}(t5) || i6.replace(":", "");
});
}, m4.utcOffset = function() {
return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
}, m4.diff = function(r6, d5, l5) {
var $3, y5 = this, M4 = b4.p(d5), m5 = O2(r6), v4 = (m5.utcOffset() - this.utcOffset()) * e4, g4 = this - m5, D3 = function() {
return b4.m(y5, m5);
};
switch (M4) {
case h3:
$3 = D3() / 12;
break;
case c4:
$3 = D3();
break;
case f4:
$3 = D3() / 3;
break;
case o4:
$3 = (g4 - v4) / 6048e5;
break;
case a3:
$3 = (g4 - v4) / 864e5;
break;
case u3:
$3 = g4 / n5;
break;
case s3:
$3 = g4 / e4;
break;
case i5:
$3 = g4 / t3;
break;
default:
$3 = g4;
}
return l5 ? $3 : b4.a($3);
}, m4.daysInMonth = function() {
return this.endOf(c4).$D;
}, m4.$locale = function() {
return D2[this.$L];
}, m4.locale = function(t4, e5) {
if (!t4) return this.$L;
var n6 = this.clone(), r6 = w2(t4, e5, true);
return r6 && (n6.$L = r6), n6;
}, m4.clone = function() {
return b4.w(this.$d, this);
}, m4.toDate = function() {
return new Date(this.valueOf());
}, m4.toJSON = function() {
return this.isValid() ? this.toISOString() : null;
}, m4.toISOString = function() {
return this.$d.toISOString();
}, m4.toString = function() {
return this.$d.toUTCString();
}, M3;
}(), k2 = _3.prototype;
return O2.prototype = k2, [["$ms", r5], ["$s", i5], ["$m", s3], ["$H", u3], ["$W", a3], ["$M", c4], ["$y", h3], ["$D", d4]].forEach(function(t4) {
k2[t4[1]] = function(e5) {
return this.$g(e5, t4[0], t4[1]);
};
}), O2.extend = function(t4, e5) {
return t4.$i || (t4(e5, _3, O2), t4.$i = true), O2;
}, O2.locale = w2, O2.isDayjs = S4, O2.unix = function(t4) {
return O2(1e3 * t4);
}, O2.en = D2[g3], O2.Ls = D2, O2.p = {}, O2;
});
}
});
// node_modules/.pnpm/dayjs@1.11.13/node_modules/dayjs/plugin/isToday.js
var require_isToday = __commonJS({
"node_modules/.pnpm/dayjs@1.11.13/node_modules/dayjs/plugin/isToday.js"(exports, module) {
!function(e4, o4) {
"object" == typeof exports && "undefined" != typeof module ? module.exports = o4() : "function" == typeof define && define.amd ? define(o4) : (e4 = "undefined" != typeof globalThis ? globalThis : e4 || self).dayjs_plugin_isToday = o4();
}(exports, function() {
"use strict";
return function(e4, o4, t3) {
o4.prototype.isToday = function() {
var e5 = "YYYY-MM-DD", o5 = t3();
return this.format(e5) === o5.format(e5);
};
};
});
}
});
// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTreeNode.js
var require_SymbolTreeNode = __commonJS({
"node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTreeNode.js"(exports, module) {
"use strict";
module.exports = class SymbolTreeNode {
constructor() {
this.parent = null;
this.previousSibling = null;
this.nextSibling = null;
this.firstChild = null;
this.lastChild = null;
this.childrenVersion = 0;
this.childIndexCachedUpTo = null;
this.cachedIndex = -1;
this.cachedIndexVersion = NaN;
}
get isAttached() {
return Boolean(this.parent || this.previousSibling || this.nextSibling);
}
get hasChildren() {
return Boolean(this.firstChild);
}
childrenChanged() {
this.childrenVersion = this.childrenVersion + 1 & 4294967295;
this.childIndexCachedUpTo = null;
}
getCachedIndex(parentNode) {
if (this.cachedIndexVersion !== parentNode.childrenVersion) {
this.cachedIndexVersion = NaN;
return -1;
}
return this.cachedIndex;
}
setCachedIndex(parentNode, index2) {
this.cachedIndexVersion = parentNode.childrenVersion;
this.cachedIndex = index2;
}
};
}
});
// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreePosition.js
var require_TreePosition = __commonJS({
"node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreePosition.js"(exports, module) {
"use strict";
module.exports = Object.freeze({
// same as DOM DOCUMENT_POSITION_
DISCONNECTED: 1,
PRECEDING: 2,
FOLLOWING: 4,
CONTAINS: 8,
CONTAINED_BY: 16
});
}
});
// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreeIterator.js
var require_TreeIterator = __commonJS({
"node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/TreeIterator.js"(exports, module) {
"use strict";
var TREE = Symbol();
var ROOT = Symbol();
var NEXT = Symbol();
var ITERATE_FUNC = Symbol();
var TreeIterator = class {
constructor(tree, root6, firstResult, iterateFunction) {
this[TREE] = tree;
this[ROOT] = root6;
this[NEXT] = firstResult;
this[ITERATE_FUNC] = iterateFunction;
}
next() {
const tree = this[TREE];
const iterateFunc = this[ITERATE_FUNC];
const root6 = this[ROOT];
if (!this[NEXT]) {
return {
done: true,
value: root6
};
}
const value2 = this[NEXT];
if (iterateFunc === 1) {
this[NEXT] = tree._node(value2).previousSibling;
} else if (iterateFunc === 2) {
this[NEXT] = tree._node(value2).nextSibling;
} else if (iterateFunc === 3) {
this[NEXT] = tree._node(value2).parent;
} else if (iterateFunc === 4) {
this[NEXT] = tree.preceding(value2, { root: root6 });
} else {
this[NEXT] = tree.following(value2, { root: root6 });
}
return {
done: false,
value: value2
};
}
};
Object.defineProperty(TreeIterator.prototype, Symbol.iterator, {
value: function() {
return this;
},
writable: false
});
TreeIterator.PREV = 1;
TreeIterator.NEXT = 2;
TreeIterator.PARENT = 3;
TreeIterator.PRECEDING = 4;
TreeIterator.FOLLOWING = 5;
Object.freeze(TreeIterator);
Object.freeze(TreeIterator.prototype);
module.exports = TreeIterator;
}
});
// node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTree.js
var require_SymbolTree = __commonJS({
"node_modules/.pnpm/symbol-tree@3.2.4/node_modules/symbol-tree/lib/SymbolTree.js"(exports, module) {
"use strict";
var SymbolTreeNode = require_SymbolTreeNode();
var TreePosition = require_TreePosition();
var TreeIterator = require_TreeIterator();
function returnTrue() {
return true;
}
function reverseArrayIndex(array, reverseIndex) {
return array[array.length - 1 - reverseIndex];
}
var SymbolTree = class {
/**
* @constructor
* @alias module:symbol-tree
* @param {string} [description='SymbolTree data'] Description used for the Symbol
*/
constructor(description) {
this.symbol = Symbol(description || "SymbolTree data");
}
/**
* You can use this function to (optionally) initialize an object right after its creation,
* to take advantage of V8's fast properties. Also useful if you would like to
* freeze your object.
*
* `O(1)`
*
* @method
* @alias module:symbol-tree#initialize
* @param {Object} object
* @return {Object} object
*/
initialize(object) {
this._node(object);
return object;
}
_node(object) {
if (!object) {
return null;
}
const node2 = object[this.symbol];
if (node2) {
return node2;
}
return object[this.symbol] = new SymbolTreeNode();
}
/**
* Returns `true` if the object has any children. Otherwise it returns `false`.
*
* * `O(1)`
*
* @method hasChildren
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Boolean}
*/
hasChildren(object) {
return this._node(object).hasChildren;
}
/**
* Returns the first child of the given object.
*
* * `O(1)`
*
* @method firstChild
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object}
*/
firstChild(object) {
return this._node(object).firstChild;
}
/**
* Returns the last child of the given object.
*
* * `O(1)`
*
* @method lastChild
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object}
*/
lastChild(object) {
return this._node(object).lastChild;
}
/**
* Returns the previous sibling of the given object.
*
* * `O(1)`
*
* @method previousSibling
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object}
*/
previousSibling(object) {
return this._node(object).previousSibling;
}
/**
* Returns the next sibling of the given object.
*
* * `O(1)`
*
* @method nextSibling
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object}
*/
nextSibling(object) {
return this._node(object).nextSibling;
}
/**
* Return the parent of the given object.
*
* * `O(1)`
*
* @method parent
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object}
*/
parent(object) {
return this._node(object).parent;
}
/**
* Find the inclusive descendant that is last in tree order of the given object.
*
* * `O(n)` (worst case) where `n` is the depth of the subtree of `object`
*
* @method lastInclusiveDescendant
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object}
*/
lastInclusiveDescendant(object) {
let lastChild;
let current = object;
while (lastChild = this._node(current).lastChild) {
current = lastChild;
}
return current;
}
/**
* Find the preceding object (A) of the given object (B).
* An object A is preceding an object B if A and B are in the same tree
* and A comes before B in tree order.
*
* * `O(n)` (worst case)
* * `O(1)` (amortized when walking the entire tree)
*
* @method preceding
* @memberOf module:symbol-tree#
* @param {Object} object
* @param {Object} [options]
* @param {Object} [options.root] If set, `root` must be an inclusive ancestor
* of the return value (or else null is returned). This check _assumes_
* that `root` is also an inclusive ancestor of the given `object`
* @return {?Object}
*/
preceding(object, options) {
const treeRoot = options && options.root;
if (object === treeRoot) {
return null;
}
const previousSibling = this._node(object).previousSibling;
if (previousSibling) {
return this.lastInclusiveDescendant(previousSibling);
}
return this._node(object).parent;
}
/**
* Find the following object (A) of the given object (B).
* An object A is following an object B if A and B are in the same tree
* and A comes after B in tree order.
*
* * `O(n)` (worst case) where `n` is the amount of objects in the entire tree
* * `O(1)` (amortized when walking the entire tree)
*
* @method following
* @memberOf module:symbol-tree#
* @param {!Object} object
* @param {Object} [options]
* @param {Object} [options.root] If set, `root` must be an inclusive ancestor
* of the return value (or else null is returned). This check _assumes_
* that `root` is also an inclusive ancestor of the given `object`
* @param {Boolean} [options.skipChildren=false] If set, ignore the children of `object`
* @return {?Object}
*/
following(object, options) {
const treeRoot = options && options.root;
const skipChildren = options && options.skipChildren;
const firstChild = !skipChildren && this._node(object).firstChild;
if (firstChild) {
return firstChild;
}
let current = object;
do {
if (current === treeRoot) {
return null;
}
const nextSibling = this._node(current).nextSibling;
if (nextSibling) {
return nextSibling;
}
current = this._node(current).parent;
} while (current);
return null;
}
/**
* Append all children of the given object to an array.
*
* * `O(n)` where `n` is the amount of children of the given `parent`
*
* @method childrenToArray
* @memberOf module:symbol-tree#
* @param {Object} parent
* @param {Object} [options]
* @param {Object[]} [options.array=[]]
* @param {Function} [options.filter] Function to test each object before it is added to the array.
* Invoked with arguments (object). Should return `true` if an object
* is to be included.
* @param {*} [options.thisArg] Value to use as `this` when executing `filter`.
* @return {Object[]}
*/
childrenToArray(parent, options) {
const array = options && options.array || [];
const filter2 = options && options.filter || returnTrue;
const thisArg = options && options.thisArg || void 0;
const parentNode = this._node(parent);
let object = parentNode.firstChild;
let index2 = 0;
while (object) {
const node2 = this._node(object);
node2.setCachedIndex(parentNode, index2);
if (filter2.call(thisArg, object)) {
array.push(object);
}
object = node2.nextSibling;
++index2;
}
return array;
}
/**
* Append all inclusive ancestors of the given object to an array.
*
* * `O(n)` where `n` is the amount of ancestors of the given `object`
*
* @method ancestorsToArray
* @memberOf module:symbol-tree#
* @param {Object} object
* @param {Object} [options]
* @param {Object[]} [options.array=[]]
* @param {Function} [options.filter] Function to test each object before it is added to the array.
* Invoked with arguments (object). Should return `true` if an object
* is to be included.
* @param {*} [options.thisArg] Value to use as `this` when executing `filter`.
* @return {Object[]}
*/
ancestorsToArray(object, options) {
const array = options && options.array || [];
const filter2 = options && options.filter || returnTrue;
const thisArg = options && options.thisArg || void 0;
let ancestor = object;
while (ancestor) {
if (filter2.call(thisArg, ancestor)) {
array.push(ancestor);
}
ancestor = this._node(ancestor).parent;
}
return array;
}
/**
* Append all descendants of the given object to an array (in tree order).
*
* * `O(n)` where `n` is the amount of objects in the sub-tree of the given `object`
*
* @method treeToArray
* @memberOf module:symbol-tree#
* @param {Object} root
* @param {Object} [options]
* @param {Object[]} [options.array=[]]
* @param {Function} [options.filter] Function to test each object before it is added to the array.
* Invoked with arguments (object). Should return `true` if an object
* is to be included.
* @param {*} [options.thisArg] Value to use as `this` when executing `filter`.
* @return {Object[]}
*/
treeToArray(root6, options) {
const array = options && options.array || [];
const filter2 = options && options.filter || returnTrue;
const thisArg = options && options.thisArg || void 0;
let object = root6;
while (object) {
if (filter2.call(thisArg, object)) {
array.push(object);
}
object = this.following(object, { root: root6 });
}
return array;
}
/**
* Iterate over all children of the given object
*
* * `O(1)` for a single iteration
*
* @method childrenIterator
* @memberOf module:symbol-tree#
* @param {Object} parent
* @param {Object} [options]
* @param {Boolean} [options.reverse=false]
* @return {Object} An iterable iterator (ES6)
*/
childrenIterator(parent, options) {
const reverse = options && options.reverse;
const parentNode = this._node(parent);
return new TreeIterator(
this,
parent,
reverse ? parentNode.lastChild : parentNode.firstChild,
reverse ? TreeIterator.PREV : TreeIterator.NEXT
);
}
/**
* Iterate over all the previous siblings of the given object. (in reverse tree order)
*
* * `O(1)` for a single iteration
*
* @method previousSiblingsIterator
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object} An iterable iterator (ES6)
*/
previousSiblingsIterator(object) {
return new TreeIterator(
this,
object,
this._node(object).previousSibling,
TreeIterator.PREV
);
}
/**
* Iterate over all the next siblings of the given object. (in tree order)
*
* * `O(1)` for a single iteration
*
* @method nextSiblingsIterator
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object} An iterable iterator (ES6)
*/
nextSiblingsIterator(object) {
return new TreeIterator(
this,
object,
this._node(object).nextSibling,
TreeIterator.NEXT
);
}
/**
* Iterate over all inclusive ancestors of the given object
*
* * `O(1)` for a single iteration
*
* @method ancestorsIterator
* @memberOf module:symbol-tree#
* @param {Object} object
* @return {Object} An iterable iterator (ES6)
*/
ancestorsIterator(object) {
return new TreeIterator(
this,
object,
object,
TreeIterator.PARENT
);
}
/**
* Iterate over all descendants of the given object (in tree order).
*
* Where `n` is the amount of objects in the sub-tree of the given `root`:
*
* * `O(n)` (worst case for a single iteration)
* * `O(n)` (amortized, when completing the iterator)
*
* @method treeIterator
* @memberOf module:symbol-tree#
* @param {Object} root
* @param {Object} options
* @param {Boolean} [options.reverse=false]
* @return {Object} An iterable iterator (ES6)
*/
treeIterator(root6, options) {
const reverse = options && options.reverse;
return new TreeIterator(
this,
root6,
reverse ? this.lastInclusiveDescendant(root6) : root6,
reverse ? TreeIterator.PRECEDING : TreeIterator.FOLLOWING
);
}
/**
* Find the index of the given object (the number of preceding siblings).
*
* * `O(n)` where `n` is the amount of preceding siblings
* * `O(1)` (amortized, if the tree is not modified)
*
* @method index
* @memberOf module:symbol-tree#
* @param {Object} child
* @return {Number} The number of preceding siblings, or -1 if the object has no parent
*/
index(child) {
const childNode = this._node(child);
const parentNode = this._node(childNode.parent);
if (!parentNode) {
return -1;
}
let currentIndex = childNode.getCachedIndex(parentNode);
if (currentIndex >= 0) {
return currentIndex;
}
currentIndex = 0;
let object = parentNode.firstChild;
if (parentNode.childIndexCachedUpTo) {
const cachedUpToNode = this._node(parentNode.childIndexCachedUpTo);
object = cachedUpToNode.nextSibling;
currentIndex = cachedUpToNode.getCachedIndex(parentNode) + 1;
}
while (object) {
const node2 = this._node(object);
node2.setCachedIndex(parentNode, currentIndex);
if (object === child) {
break;
}
++currentIndex;
object = node2.nextSibling;
}
parentNode.childIndexCachedUpTo = child;
return currentIndex;
}
/**
* Calculate the number of children.
*
* * `O(n)` where `n` is the amount of children
* * `O(1)` (amortized, if the tree is not modified)
*
* @method childrenCount
* @memberOf module:symbol-tree#
* @param {Object} parent
* @return {Number}
*/
childrenCount(parent) {
const parentNode = this._node(parent);
if (!parentNode.lastChild) {
return 0;
}
return this.index(parentNode.lastChild) + 1;
}
/**
* Compare the position of an object relative to another object. A bit set is returned:
*
* <ul>
* <li>DISCONNECTED : 1</li>
* <li>PRECEDING : 2</li>
* <li>FOLLOWING : 4</li>
* <li>CONTAINS : 8</li>
* <li>CONTAINED_BY : 16</li>
* </ul>
*
* The semantics are the same as compareDocumentPosition in DOM, with the exception that
* DISCONNECTED never occurs with any other bit.
*
* where `n` and `m` are the amount of ancestors of `left` and `right`;
* where `o` is the amount of children of the lowest common ancestor of `left` and `right`:
*
* * `O(n + m + o)` (worst case)
* * `O(n + m)` (amortized, if the tree is not modified)
*
* @method compareTreePosition
* @memberOf module:symbol-tree#
* @param {Object} left
* @param {Object} right
* @return {Number}
*/
compareTreePosition(left, right) {
if (left === right) {
return 0;
}
const leftAncestors = [];
{
let leftAncestor = left;
while (leftAncestor) {
if (leftAncestor === right) {
return TreePosition.CONTAINS | TreePosition.PRECEDING;
}
leftAncestors.push(leftAncestor);
leftAncestor = this.parent(leftAncestor);
}
}
const rightAncestors = [];
{
let rightAncestor = right;
while (rightAncestor) {
if (rightAncestor === left) {
return TreePosition.CONTAINED_BY | TreePosition.FOLLOWING;
}
rightAncestors.push(rightAncestor);
rightAncestor = this.parent(rightAncestor);
}
}
const root6 = reverseArrayIndex(leftAncestors, 0);
if (!root6 || root6 !== reverseArrayIndex(rightAncestors, 0)) {
return TreePosition.DISCONNECTED;
}
let commonAncestorIndex = 0;
const ancestorsMinLength = Math.min(leftAncestors.length, rightAncestors.length);
for (let i5 = 0; i5 < ancestorsMinLength; ++i5) {
const leftAncestor = reverseArrayIndex(leftAncestors, i5);
const rightAncestor = reverseArrayIndex(rightAncestors, i5);
if (leftAncestor !== rightAncestor) {
break;
}
commonAncestorIndex = i5;
}
const leftIndex = this.index(reverseArrayIndex(leftAncestors, commonAncestorIndex + 1));
const rightIndex = this.index(reverseArrayIndex(rightAncestors, commonAncestorIndex + 1));
return rightIndex < leftIndex ? TreePosition.PRECEDING : TreePosition.FOLLOWING;
}
/**
* Remove the object from this tree.
* Has no effect if already removed.
*
* * `O(1)`
*
* @method remove
* @memberOf module:symbol-tree#
* @param {Object} removeObject
* @return {Object} removeObject
*/
remove(removeObject) {
const removeNode = this._node(removeObject);
const parentNode = this._node(removeNode.parent);
const prevNode = this._node(removeNode.previousSibling);
const nextNode = this._node(removeNode.nextSibling);
if (parentNode) {
if (parentNode.firstChild === removeObject) {
parentNode.firstChild = removeNode.nextSibling;
}
if (parentNode.lastChild === removeObject) {
parentNode.lastChild = removeNode.previousSibling;
}
}
if (prevNode) {
prevNode.nextSibling = removeNode.nextSibling;
}
if (nextNode) {
nextNode.previousSibling = removeNode.previousSibling;
}
removeNode.parent = null;
removeNode.previousSibling = null;
removeNode.nextSibling = null;
removeNode.cachedIndex = -1;
removeNode.cachedIndexVersion = NaN;
if (parentNode) {
parentNode.childrenChanged();
}
return removeObject;
}
/**
* Insert the given object before the reference object.
* `newObject` is now the previous sibling of `referenceObject`.
*
* * `O(1)`
*
* @method insertBefore
* @memberOf module:symbol-tree#
* @param {Object} referenceObject
* @param {Object} newObject
* @throws {Error} If the newObject is already present in this SymbolTree
* @return {Object} newObject
*/
insertBefore(referenceObject, newObject) {
const referenceNode = this._node(referenceObject);
const prevNode = this._node(referenceNode.previousSibling);
const newNode = this._node(newObject);
const parentNode = this._node(referenceNode.parent);
if (newNode.isAttached) {
throw Error("Given object is already present in this SymbolTree, remove it first");
}
newNode.parent = referenceNode.parent;
newNode.previousSibling = referenceNode.previousSibling;
newNode.nextSibling = referenceObject;
referenceNode.previousSibling = newObject;
if (prevNode) {
prevNode.nextSibling = newObject;
}
if (parentNode && parentNode.firstChild === referenceObject) {
parentNode.firstChild = newObject;
}
if (parentNode) {
parentNode.childrenChanged();
}
return newObject;
}
/**
* Insert the given object after the reference object.
* `newObject` is now the next sibling of `referenceObject`.
*
* * `O(1)`
*
* @method insertAfter
* @memberOf module:symbol-tree#
* @param {Object} referenceObject
* @param {Object} newObject
* @throws {Error} If the newObject is already present in this SymbolTree
* @return {Object} newObject
*/
insertAfter(referenceObject, newObject) {
const referenceNode = this._node(referenceObject);
const nextNode = this._node(referenceNode.nextSibling);
const newNode = this._node(newObject);
const parentNode = this._node(referenceNode.parent);
if (newNode.isAttached) {
throw Error("Given object is already present in this SymbolTree, remove it first");
}
newNode.parent = referenceNode.parent;
newNode.previousSibling = referenceObject;
newNode.nextSibling = referenceNode.nextSibling;
referenceNode.nextSibling = newObject;
if (nextNode) {
nextNode.previousSibling = newObject;
}
if (parentNode && parentNode.lastChild === referenceObject) {
parentNode.lastChild = newObject;
}
if (parentNode) {
parentNode.childrenChanged();
}
return newObject;
}
/**
* Insert the given object as the first child of the given reference object.
* `newObject` is now the first child of `referenceObject`.
*
* * `O(1)`
*
* @method prependChild
* @memberOf module:symbol-tree#
* @param {Object} referenceObject
* @param {Object} newObject
* @throws {Error} If the newObject is already present in this SymbolTree
* @return {Object} newObject
*/
prependChild(referenceObject, newObject) {
const referenceNode = this._node(referenceObject);
const newNode = this._node(newObject);
if (newNode.isAttached) {
throw Error("Given object is already present in this SymbolTree, remove it first");
}
if (referenceNode.hasChildren) {
this.insertBefore(referenceNode.firstChild, newObject);
} else {
newNode.parent = referenceObject;
referenceNode.firstChild = newObject;
referenceNode.lastChild = newObject;
referenceNode.childrenChanged();
}
return newObject;
}
/**
* Insert the given object as the last child of the given reference object.
* `newObject` is now the last child of `referenceObject`.
*
* * `O(1)`
*
* @method appendChild
* @memberOf module:symbol-tree#
* @param {Object} referenceObject
* @param {Object} newObject
* @throws {Error} If the newObject is already present in this SymbolTree
* @return {Object} newObject
*/
appendChild(referenceObject, newObject) {
const referenceNode = this._node(referenceObject);
const newNode = this._node(newObject);
if (newNode.isAttached) {
throw Error("Given object is already present in this SymbolTree, remove it first");
}
if (referenceNode.hasChildren) {
this.insertAfter(referenceNode.lastChild, newObject);
} else {
newNode.parent = referenceObject;
referenceNode.firstChild = newObject;
referenceNode.lastChild = newObject;
referenceNode.childrenChanged();
}
return newObject;
}
};
module.exports = SymbolTree;
SymbolTree.TreePosition = TreePosition;
}
});
// node_modules/.pnpm/punycode@1.4.1/node_modules/punycode/punycode.js
var require_punycode = __commonJS({
"node_modules/.pnpm/punycode@1.4.1/node_modules/punycode/punycode.js"(exports, module) {
(function(root6) {
var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
var freeModule = typeof module == "object" && module && !module.nodeType && module;
var freeGlobal = typeof global == "object" && global;
if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
root6 = freeGlobal;
}
var punycode, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
"overflow": "Overflow: input needs wider integers to process",
"not-basic": "Illegal input >= 0x80 (not a basic code point)",
"invalid-input": "Invalid input"
}, baseMinusTMin = base - tMin, floor = Math.floor, stringFromCharCode = String.fromCharCode, key2;
function error(type5) {
throw new RangeError(errors[type5]);
}
function map8(array, fn) {
var length = array.length;
var result = [];
while (length--) {
result[length] = fn(array[length]);
}
return result;
}
function mapDomain(string3, fn) {
var parts = string3.split("@");
var result = "";
if (parts.length > 1) {
result = parts[0] + "@";
string3 = parts[1];
}
string3 = string3.replace(regexSeparators, ".");
var labels = string3.split(".");
var encoded = map8(labels, fn).join(".");
return result + encoded;
}
function ucs2decode(string3) {
var output = [], counter = 0, length = string3.length, value2, extra;
while (counter < length) {
value2 = string3.charCodeAt(counter++);
if (value2 >= 55296 && value2 <= 56319 && counter < length) {
extra = string3.charCodeAt(counter++);
if ((extra & 64512) == 56320) {
output.push(((value2 & 1023) << 10) + (extra & 1023) + 65536);
} else {
output.push(value2);
counter--;
}
} else {
output.push(value2);
}
}
return output;
}
function ucs2encode(array) {
return map8(array, function(value2) {
var output = "";
if (value2 > 65535) {
value2 -= 65536;
output += stringFromCharCode(value2 >>> 10 & 1023 | 55296);
value2 = 56320 | value2 & 1023;
}
output += stringFromCharCode(value2);
return output;
}).join("");
}
function basicToDigit(codePoint) {
if (codePoint - 48 < 10) {
return codePoint - 22;
}
if (codePoint - 65 < 26) {
return codePoint - 65;
}
if (codePoint - 97 < 26) {
return codePoint - 97;
}
return base;
}
function digitToBasic(digit, flag) {
return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
}
function adapt(delta, numPoints, firstTime) {
var k2 = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
for (; delta > baseMinusTMin * tMax >> 1; k2 += base) {
delta = floor(delta / baseMinusTMin);
}
return floor(k2 + (baseMinusTMin + 1) * delta / (delta + skew));
}
function decode3(input) {
var output = [], inputLength = input.length, out, i5 = 0, n5 = initialN, bias = initialBias, basic, j2, index2, oldi, w2, k2, digit, t3, baseMinusT;
basic = input.lastIndexOf(delimiter);
if (basic < 0) {
basic = 0;
}
for (j2 = 0; j2 < basic; ++j2) {
if (input.charCodeAt(j2) >= 128) {
error("not-basic");
}
output.push(input.charCodeAt(j2));
}
for (index2 = basic > 0 ? basic + 1 : 0; index2 < inputLength; ) {
for (oldi = i5, w2 = 1, k2 = base; ; k2 += base) {
if (index2 >= inputLength) {
error("invalid-input");
}
digit = basicToDigit(input.charCodeAt(index2++));
if (digit >= base || digit > floor((maxInt - i5) / w2)) {
error("overflow");
}
i5 += digit * w2;
t3 = k2 <= bias ? tMin : k2 >= bias + tMax ? tMax : k2 - bias;
if (digit < t3) {
break;
}
baseMinusT = base - t3;
if (w2 > floor(maxInt / baseMinusT)) {
error("overflow");
}
w2 *= baseMinusT;
}
out = output.length + 1;
bias = adapt(i5 - oldi, out, oldi == 0);
if (floor(i5 / out) > maxInt - n5) {
error("overflow");
}
n5 += floor(i5 / out);
i5 %= out;
output.splice(i5++, 0, n5);
}
return ucs2encode(output);
}
function encode2(input) {
var n5, delta, handledCPCount, basicLength, bias, j2, m3, q, k2, t3, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
input = ucs2decode(input);
inputLength = input.length;
n5 = initialN;
delta = 0;
bias