ts-bacnet
Version:
The BACnet protocol library written in pure JavaScript.
562 lines (561 loc) • 17.3 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__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
}) : x)(function(x) {
if (typeof require !== "undefined")
return require.apply(this, arguments);
throw Error('Dynamic require of "' + x + '" 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, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || 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
));
// dist/index.js
var require_dist = __commonJS({
"dist/index.js"(exports, module) {
var __create2 = Object.create;
var __defProp2 = Object.defineProperty;
var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2 = Object.getOwnPropertyNames;
var __getProtoOf2 = Object.getPrototypeOf;
var __hasOwnProp2 = Object.prototype.hasOwnProperty;
var __commonJS2 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2 = (target, all) => {
for (var name in all)
__defProp2(target, name, { get: all[name], enumerable: true });
};
var __copyProps2 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2(from))
if (!__hasOwnProp2.call(to, key) && key !== except)
__defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
// 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 ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
var require_dist2 = __commonJS2({
"dist/index.js"(exports2, module2) {
var __create22 = Object.create;
var __defProp22 = Object.defineProperty;
var __getOwnPropDesc22 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22 = Object.getOwnPropertyNames;
var __getProtoOf22 = Object.getPrototypeOf;
var __hasOwnProp22 = Object.prototype.hasOwnProperty;
var __commonJS22 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames22(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export22 = (target, all) => {
for (var name in all)
__defProp22(target, name, { get: all[name], enumerable: true });
};
var __copyProps22 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames22(from))
if (!__hasOwnProp22.call(to, key) && key !== except)
__defProp22(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22(from, key)) || desc.enumerable });
}
return to;
};
var __toESM22 = (mod, isNodeMode, target) => (target = mod != null ? __create22(__getProtoOf22(mod)) : {}, __copyProps22(
// 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 ? __defProp22(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS2 = (mod) => __copyProps22(__defProp22({}, "__esModule", { value: true }), mod);
var require_dist22 = __commonJS22({
"dist/index.js"(exports22, module22) {
var __create222 = Object.create;
var __defProp222 = Object.defineProperty;
var __getOwnPropDesc222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames222 = Object.getOwnPropertyNames;
var __getProtoOf222 = Object.getPrototypeOf;
var __hasOwnProp222 = Object.prototype.hasOwnProperty;
var __commonJS222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export222 = (target, all) => {
for (var name in all)
__defProp222(target, name, { get: all[name], enumerable: true });
};
var __copyProps222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames222(from))
if (!__hasOwnProp222.call(to, key) && key !== except)
__defProp222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM222 = (mod, isNodeMode, target) => (target = mod != null ? __create222(__getProtoOf222(mod)) : {}, __copyProps222(
// 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 ? __defProp222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS22 = (mod) => __copyProps222(__defProp222({}, "__esModule", { value: true }), mod);
var require_dist222 = __commonJS222({
"dist/index.js"(exports222, module222) {
var __create2222 = Object.create;
var __defProp2222 = Object.defineProperty;
var __getOwnPropDesc2222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2222 = Object.getOwnPropertyNames;
var __getProtoOf2222 = Object.getPrototypeOf;
var __hasOwnProp2222 = Object.prototype.hasOwnProperty;
var __commonJS2222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames2222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2222 = (target, all) => {
for (var name in all)
__defProp2222(target, name, { get: all[name], enumerable: true });
};
var __copyProps2222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2222(from))
if (!__hasOwnProp2222.call(to, key) && key !== except)
__defProp2222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2222 = (mod, isNodeMode, target) => (target = mod != null ? __create2222(__getProtoOf2222(mod)) : {}, __copyProps2222(
// 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 ? __defProp2222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS222 = (mod) => __copyProps2222(__defProp2222({}, "__esModule", { value: true }), mod);
var require_dist2222 = __commonJS2222({
"dist/index.js"(exports2222, module2222) {
var __create22222 = Object.create;
var __defProp22222 = Object.defineProperty;
var __getOwnPropDesc22222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22222 = Object.getOwnPropertyNames;
var __getProtoOf22222 = Object.getPrototypeOf;
var __hasOwnProp22222 = Object.prototype.hasOwnProperty;
var __commonJS22222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames22222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export22222 = (target, all) => {
for (var name in all)
__defProp22222(target, name, { get: all[name], enumerable: true });
};
var __copyProps22222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames22222(from))
if (!__hasOwnProp22222.call(to, key) && key !== except)
__defProp22222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM22222 = (mod, isNodeMode, target) => (target = mod != null ? __create22222(__getProtoOf22222(mod)) : {}, __copyProps22222(
// 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 ? __defProp22222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS2222 = (mod) => __copyProps22222(__defProp22222({}, "__esModule", { value: true }), mod);
var require_dist22222 = __commonJS22222({
"dist/index.js"(exports22222, module22222) {
var __create222222 = Object.create;
var __defProp222222 = Object.defineProperty;
var __getOwnPropDesc222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames222222 = Object.getOwnPropertyNames;
var __getProtoOf222222 = Object.getPrototypeOf;
var __hasOwnProp222222 = Object.prototype.hasOwnProperty;
var __commonJS222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export222222 = (target, all) => {
for (var name in all)
__defProp222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames222222(from))
if (!__hasOwnProp222222.call(to, key) && key !== except)
__defProp222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM222222 = (mod, isNodeMode, target) => (target = mod != null ? __create222222(__getProtoOf222222(mod)) : {}, __copyProps222222(
// 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 ? __defProp222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS22222 = (mod) => __copyProps222222(__defProp222222({}, "__esModule", { value: true }), mod);
var require_dist222222 = __commonJS222222({
"dist/index.js"(exports222222, module222222) {
var __create2222222 = Object.create;
var __defProp2222222 = Object.defineProperty;
var __getOwnPropDesc2222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2222222 = Object.getOwnPropertyNames;
var __getProtoOf2222222 = Object.getPrototypeOf;
var __hasOwnProp2222222 = Object.prototype.hasOwnProperty;
var __commonJS2222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames2222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2222222 = (target, all) => {
for (var name in all)
__defProp2222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps2222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2222222(from))
if (!__hasOwnProp2222222.call(to, key) && key !== except)
__defProp2222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2222222 = (mod, isNodeMode, target) => (target = mod != null ? __create2222222(__getProtoOf2222222(mod)) : {}, __copyProps2222222(
// 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 ? __defProp2222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS222222 = (mod) => __copyProps2222222(__defProp2222222({}, "__esModule", { value: true }), mod);
var require_dist2222222 = __commonJS2222222({
"dist/index.js"(exports2222222, module2222222) {
var __create22222222 = Object.create;
var __defProp22222222 = Object.defineProperty;
var __getOwnPropDesc22222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22222222 = Object.getOwnPropertyNames;
var __getProtoOf22222222 = Object.getPrototypeOf;
var __hasOwnProp22222222 = Object.prototype.hasOwnProperty;
var __commonJS22222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames22222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export22222222 = (target, all) => {
for (var name in all)
__defProp22222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps22222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames22222222(from))
if (!__hasOwnProp22222222.call(to, key) && key !== except)
__defProp22222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM22222222 = (mod, isNodeMode, target) => (target = mod != null ? __create22222222(__getProtoOf22222222(mod)) : {}, __copyProps22222222(
// 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 ? __defProp22222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS2222222 = (mod) => __copyProps22222222(__defProp22222222({}, "__esModule", { value: true }), mod);
var require_dist22222222 = __commonJS22222222({
"dist/index.js"(exports22222222, module22222222) {
var __create222222222 = Object.create;
var __defProp222222222 = Object.defineProperty;
var __getOwnPropDesc222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames222222222 = Object.getOwnPropertyNames;
var __getProtoOf222222222 = Object.getPrototypeOf;
var __hasOwnProp222222222 = Object.prototype.hasOwnProperty;
var __commonJS222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export222222222 = (target, all) => {
for (var name in all)
__defProp222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames222222222(from))
if (!__hasOwnProp222222222.call(to, key) && key !== except)
__defProp222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create222222222(__getProtoOf222222222(mod)) : {}, __copyProps222222222(
// 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 ? __defProp222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS22222222 = (mod) => __copyProps222222222(__defProp222222222({}, "__esModule", { value: true }), mod);
var require_dist222222222 = __commonJS222222222({
"dist/index.js"(exports222222222, module222222222) {
var __create2222222222 = Object.create;
var __defProp2222222222 = Object.defineProperty;
var __getOwnPropDesc2222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2222222222 = Object.getOwnPropertyNames;
var __getProtoOf2222222222 = Object.getPrototypeOf;
var __hasOwnProp2222222222 = Object.prototype.hasOwnProperty;
var __commonJS2222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames2222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2222222222 = (target, all) => {
for (var name in all)
__defProp2222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps2222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2222222222(from))
if (!__hasOwnProp2222222222.call(to, key) && key !== except)
__defProp2222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create2222222222(__getProtoOf2222222222(mod)) : {}, __copyProps2222222222(
// 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 ? __defProp2222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS222222222 = (mod) => __copyProps2222222222(__defProp2222222222({}, "__esModule", { value: true }), mod);
var require_dist2222222222 = __commonJS2222222222({
"dist/index.js"(exports2222222222, module2222222222) {
var __create22222222222 = Object.create;
var __defProp22222222222 = Object.defineProperty;
var __getOwnPropDesc22222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22222222222 = Object.getOwnPropertyNames;
var __getProtoOf22222222222 = Object.getPrototypeOf;
var __hasOwnProp22222222222 = Object.prototype.hasOwnProperty;
var __commonJS22222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames22222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export22222222222 = (target, all) => {
for (var name in all)
__defProp22222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps22222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames22222222222(from))
if (!__hasOwnProp22222222222.call(to, key) && key !== except)
__defProp22222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM22222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create22222222222(__getProtoOf22222222222(mod)) : {}, __copyProps22222222222(
// 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 ? __defProp22222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS2222222222 = (mod) => __copyProps22222222222(__defProp22222222222({}, "__esModule", { value: true }), mod);
var require_dist22222222222 = __commonJS22222222222({
"dist/index.js"(exports22222222222, module22222222222) {
var __create222222222222 = Object.create;
var __defProp222222222222 = Object.defineProperty;
var __getOwnPropDesc222222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames222222222222 = Object.getOwnPropertyNames;
var __getProtoOf222222222222 = Object.getPrototypeOf;
var __hasOwnProp222222222222 = Object.prototype.hasOwnProperty;
var __commonJS222222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames222222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export222222222222 = (target, all) => {
for (var name in all)
__defProp222222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps222222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames222222222222(from))
if (!__hasOwnProp222222222222.call(to, key) && key !== except)
__defProp222222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc222222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM222222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create222222222222(__getProtoOf222222222222(mod)) : {}, __copyProps222222222222(
// 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 ? __defProp222222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS22222222222 = (mod) => __copyProps222222222222(__defProp222222222222({}, "__esModule", { value: true }), mod);
var require_dist222222222222 = __commonJS222222222222({
"dist/index.js"(exports222222222222, module222222222222) {
var __create2222222222222 = Object.create;
var __defProp2222222222222 = Object.defineProperty;
var __getOwnPropDesc2222222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2222222222222 = Object.getOwnPropertyNames;
var __getProtoOf2222222222222 = Object.getPrototypeOf;
var __hasOwnProp2222222222222 = Object.prototype.hasOwnProperty;
var __commonJS2222222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames2222222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2222222222222 = (target, all) => {
for (var name in all)
__defProp2222222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps2222222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2222222222222(from))
if (!__hasOwnProp2222222222222.call(to, key) && key !== except)
__defProp2222222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2222222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2222222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create2222222222222(__getProtoOf2222222222222(mod)) : {}, __copyProps2222222222222(
// 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 ? __defProp2222222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS222222222222 = (mod) => __copyProps2222222222222(__defProp2222222222222({}, "__esModule", { value: true }), mod);
var require_dist2222222222222 = __commonJS2222222222222({
"dist/index.js"(exports2222222222222, module2222222222222) {
var __create22222222222222 = Object.create;
var __defProp22222222222222 = Object.defineProperty;
var __getOwnPropDesc22222222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22222222222222 = Object.getOwnPropertyNames;
var __getProtoOf22222222222222 = Object.getPrototypeOf;
var __hasOwnProp22222222222222 = Object.prototype.hasOwnProperty;
var __commonJS22222222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames22222222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export22222222222222 = (target, all) => {
for (var name in all)
__defProp22222222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps22222222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames22222222222222(from))
if (!__hasOwnProp22222222222222.call(to, key) && key !== except)
__defProp22222222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc22222222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM22222222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create22222222222222(__getProtoOf22222222222222(mod)) : {}, __copyProps22222222222222(
// 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 ? __defProp22222222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS2222222222222 = (mod) => __copyProps22222222222222(__defProp22222222222222({}, "__esModule", { value: true }), mod);
var require_dist22222222222222 = __commonJS22222222222222({
"dist/index.js"(exports22222222222222, module22222222222222) {
var __create222222222222222 = Object.create;
var __defProp222222222222222 = Object.defineProperty;
var __getOwnPropDesc222222222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames222222222222222 = Object.getOwnPropertyNames;
var __getProtoOf222222222222222 = Object.getPrototypeOf;
var __hasOwnProp222222222222222 = Object.prototype.hasOwnProperty;
var __commonJS222222222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames222222222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export222222222222222 = (target, all) => {
for (var name in all)
__defProp222222222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps222222222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames222222222222222(from))
if (!__hasOwnProp222222222222222.call(to, key) && key !== except)
__defProp222222222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc222222222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM222222222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create222222222222222(__getProtoOf222222222222222(mod)) : {}, __copyProps222222222222222(
// 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 ? __defProp222222222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS22222222222222 = (mod) => __copyProps222222222222222(__defProp222222222222222({}, "__esModule", { value: true }), mod);
var require_dist222222222222222 = __commonJS222222222222222({
"dist/index.js"(exports222222222222222, module222222222222222) {
var __create2222222222222222 = Object.create;
var __defProp2222222222222222 = Object.defineProperty;
var __getOwnPropDesc2222222222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames2222222222222222 = Object.getOwnPropertyNames;
var __getProtoOf2222222222222222 = Object.getPrototypeOf;
var __hasOwnProp2222222222222222 = Object.prototype.hasOwnProperty;
var __commonJS2222222222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames2222222222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2222222222222222 = (target, all) => {
for (var name in all)
__defProp2222222222222222(target, name, { get: all[name], enumerable: true });
};
var __copyProps2222222222222222 = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames2222222222222222(from))
if (!__hasOwnProp2222222222222222.call(to, key) && key !== except)
__defProp2222222222222222(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2222222222222222(from, key)) || desc.enumerable });
}
return to;
};
var __toESM2222222222222222 = (mod, isNodeMode, target) => (target = mod != null ? __create2222222222222222(__getProtoOf2222222222222222(mod)) : {}, __copyProps2222222222222222(
// 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 ? __defProp2222222222222222(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS222222222222222 = (mod) => __copyProps2222222222222222(__defProp2222222222222222({}, "__esModule", { value: true }), mod);
var require_dist2222222222222222 = __commonJS2222222222222222({
"dist/index.js"(exports2222222222222222, module2222222222222222) {
var __create22222222222222222 = Object.create;
var __defProp22222222222222222 = Object.defineProperty;
var __getOwnPropDesc22222222222222222 = Object.getOwnPropertyDescriptor;
var __getOwnPropNames22222222222222222 = Object.getOwnPropertyNames;
var __getProtoOf22222222222222222 = Object.getPrototypeOf;
var __hasOwnProp22222222222222222 = Object.prototype.hasOwnProperty;
var __commonJS22222222222222222 = (cb, mod) => function __require2() {
return mod || (0, cb[__getOwnPropNames22222222222222222(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export2222222222222