@synotech/print
Version:
A collection of print templates for synotech applications
1,406 lines (1,394 loc) • 3.6 MB
JavaScript
import * as React8 from 'react';
import React8__default, { Component, useMemo, useCallback } from 'react';
import 'react/jsx-runtime';
import { parseDocument } from 'htmlparser2';
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 __name = (target, value2) => __defProp(target, "name", { value: value2, configurable: true });
var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
get: (a3, b2) => (typeof require !== "undefined" ? require : a3)[b2]
}) : 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, from4, except, desc) => {
if (from4 && typeof from4 === "object" || typeof from4 === "function") {
for (let key of __getOwnPropNames(from4))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from4[key], enumerable: !(desc = __getOwnPropDesc(from4, 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
));
// node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS({
"node_modules/inherits/inherits_browser.js"(exports, module) {
if (typeof Object.create === "function") {
module.exports = /* @__PURE__ */ __name(function inherits3(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
}, "inherits");
} else {
module.exports = /* @__PURE__ */ __name(function inherits3(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = /* @__PURE__ */ __name(function() {
}, "TempCtor");
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
}, "inherits");
}
}
});
// node_modules/events/events.js
var require_events = __commonJS({
"node_modules/events/events.js"(exports, module) {
var R = typeof Reflect === "object" ? Reflect : null;
var ReflectApply = R && typeof R.apply === "function" ? R.apply : /* @__PURE__ */ __name(function ReflectApply2(target, receiver, args) {
return Function.prototype.apply.call(target, receiver, args);
}, "ReflectApply");
var ReflectOwnKeys;
if (R && typeof R.ownKeys === "function") {
ReflectOwnKeys = R.ownKeys;
} else if (Object.getOwnPropertySymbols) {
ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
return Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target));
}, "ReflectOwnKeys");
} else {
ReflectOwnKeys = /* @__PURE__ */ __name(function ReflectOwnKeys2(target) {
return Object.getOwnPropertyNames(target);
}, "ReflectOwnKeys");
}
function ProcessEmitWarning(warning) {
if (console && console.warn) console.warn(warning);
}
__name(ProcessEmitWarning, "ProcessEmitWarning");
var NumberIsNaN = Number.isNaN || /* @__PURE__ */ __name(function NumberIsNaN2(value2) {
return value2 !== value2;
}, "NumberIsNaN");
function EventEmitter3() {
EventEmitter3.init.call(this);
}
__name(EventEmitter3, "EventEmitter");
module.exports = EventEmitter3;
module.exports.once = once5;
EventEmitter3.EventEmitter = EventEmitter3;
EventEmitter3.prototype._events = void 0;
EventEmitter3.prototype._eventsCount = 0;
EventEmitter3.prototype._maxListeners = void 0;
var defaultMaxListeners = 10;
function checkListener(listener) {
if (typeof listener !== "function") {
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
}
}
__name(checkListener, "checkListener");
Object.defineProperty(EventEmitter3, "defaultMaxListeners", {
enumerable: true,
get: /* @__PURE__ */ __name(function() {
return defaultMaxListeners;
}, "get"),
set: /* @__PURE__ */ __name(function(arg) {
if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
}
defaultMaxListeners = arg;
}, "set")
});
EventEmitter3.init = function() {
if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
}
this._maxListeners = this._maxListeners || void 0;
};
EventEmitter3.prototype.setMaxListeners = /* @__PURE__ */ __name(function setMaxListeners3(n4) {
if (typeof n4 !== "number" || n4 < 0 || NumberIsNaN(n4)) {
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n4 + ".");
}
this._maxListeners = n4;
return this;
}, "setMaxListeners");
function _getMaxListeners(that) {
if (that._maxListeners === void 0)
return EventEmitter3.defaultMaxListeners;
return that._maxListeners;
}
__name(_getMaxListeners, "_getMaxListeners");
EventEmitter3.prototype.getMaxListeners = /* @__PURE__ */ __name(function getMaxListeners3() {
return _getMaxListeners(this);
}, "getMaxListeners");
EventEmitter3.prototype.emit = /* @__PURE__ */ __name(function emit5(type) {
var args = [];
for (var i3 = 1; i3 < arguments.length; i3++) args.push(arguments[i3]);
var doError = type === "error";
var events2 = this._events;
if (events2 !== void 0)
doError = doError && events2.error === void 0;
else if (!doError)
return false;
if (doError) {
var er;
if (args.length > 0)
er = args[0];
if (er instanceof Error) {
throw er;
}
var err2 = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
err2.context = er;
throw err2;
}
var handler = events2[type];
if (handler === void 0)
return false;
if (typeof handler === "function") {
ReflectApply(handler, this, args);
} else {
var len = handler.length;
var listeners3 = arrayClone3(handler, len);
for (var i3 = 0; i3 < len; ++i3)
ReflectApply(listeners3[i3], this, args);
}
return true;
}, "emit");
function _addListener3(target, type, listener, prepend) {
var m;
var events2;
var existing;
checkListener(listener);
events2 = target._events;
if (events2 === void 0) {
events2 = target._events = /* @__PURE__ */ Object.create(null);
target._eventsCount = 0;
} else {
if (events2.newListener !== void 0) {
target.emit(
"newListener",
type,
listener.listener ? listener.listener : listener
);
events2 = target._events;
}
existing = events2[type];
}
if (existing === void 0) {
existing = events2[type] = listener;
++target._eventsCount;
} else {
if (typeof existing === "function") {
existing = events2[type] = prepend ? [listener, existing] : [existing, listener];
} else if (prepend) {
existing.unshift(listener);
} else {
existing.push(listener);
}
m = _getMaxListeners(target);
if (m > 0 && existing.length > m && !existing.warned) {
existing.warned = true;
var w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
w.name = "MaxListenersExceededWarning";
w.emitter = target;
w.type = type;
w.count = existing.length;
ProcessEmitWarning(w);
}
}
return target;
}
__name(_addListener3, "_addListener");
EventEmitter3.prototype.addListener = /* @__PURE__ */ __name(function addListener5(type, listener) {
return _addListener3(this, type, listener, false);
}, "addListener");
EventEmitter3.prototype.on = EventEmitter3.prototype.addListener;
EventEmitter3.prototype.prependListener = /* @__PURE__ */ __name(function prependListener5(type, listener) {
return _addListener3(this, type, listener, true);
}, "prependListener");
function onceWrapper() {
if (!this.fired) {
this.target.removeListener(this.type, this.wrapFn);
this.fired = true;
if (arguments.length === 0)
return this.listener.call(this.target);
return this.listener.apply(this.target, arguments);
}
}
__name(onceWrapper, "onceWrapper");
function _onceWrap3(target, type, listener) {
var state2 = { fired: false, wrapFn: void 0, target, type, listener };
var wrapped = onceWrapper.bind(state2);
wrapped.listener = listener;
state2.wrapFn = wrapped;
return wrapped;
}
__name(_onceWrap3, "_onceWrap");
EventEmitter3.prototype.once = /* @__PURE__ */ __name(function once6(type, listener) {
checkListener(listener);
this.on(type, _onceWrap3(this, type, listener));
return this;
}, "once");
EventEmitter3.prototype.prependOnceListener = /* @__PURE__ */ __name(function prependOnceListener3(type, listener) {
checkListener(listener);
this.prependListener(type, _onceWrap3(this, type, listener));
return this;
}, "prependOnceListener");
EventEmitter3.prototype.removeListener = /* @__PURE__ */ __name(function removeListener5(type, listener) {
var list, events2, position, i3, originalListener;
checkListener(listener);
events2 = this._events;
if (events2 === void 0)
return this;
list = events2[type];
if (list === void 0)
return this;
if (list === listener || list.listener === listener) {
if (--this._eventsCount === 0)
this._events = /* @__PURE__ */ Object.create(null);
else {
delete events2[type];
if (events2.removeListener)
this.emit("removeListener", type, list.listener || listener);
}
} else if (typeof list !== "function") {
position = -1;
for (i3 = list.length - 1; i3 >= 0; i3--) {
if (list[i3] === listener || list[i3].listener === listener) {
originalListener = list[i3].listener;
position = i3;
break;
}
}
if (position < 0)
return this;
if (position === 0)
list.shift();
else {
spliceOne3(list, position);
}
if (list.length === 1)
events2[type] = list[0];
if (events2.removeListener !== void 0)
this.emit("removeListener", type, originalListener || listener);
}
return this;
}, "removeListener");
EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
EventEmitter3.prototype.removeAllListeners = /* @__PURE__ */ __name(function removeAllListeners5(type) {
var listeners3, events2, i3;
events2 = this._events;
if (events2 === void 0)
return this;
if (events2.removeListener === void 0) {
if (arguments.length === 0) {
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
} else if (events2[type] !== void 0) {
if (--this._eventsCount === 0)
this._events = /* @__PURE__ */ Object.create(null);
else
delete events2[type];
}
return this;
}
if (arguments.length === 0) {
var keys2 = Object.keys(events2);
var key;
for (i3 = 0; i3 < keys2.length; ++i3) {
key = keys2[i3];
if (key === "removeListener") continue;
this.removeAllListeners(key);
}
this.removeAllListeners("removeListener");
this._events = /* @__PURE__ */ Object.create(null);
this._eventsCount = 0;
return this;
}
listeners3 = events2[type];
if (typeof listeners3 === "function") {
this.removeListener(type, listeners3);
} else if (listeners3 !== void 0) {
for (i3 = listeners3.length - 1; i3 >= 0; i3--) {
this.removeListener(type, listeners3[i3]);
}
}
return this;
}, "removeAllListeners");
function _listeners(target, type, unwrap) {
var events2 = target._events;
if (events2 === void 0)
return [];
var evlistener = events2[type];
if (evlistener === void 0)
return [];
if (typeof evlistener === "function")
return unwrap ? [evlistener.listener || evlistener] : [evlistener];
return unwrap ? unwrapListeners3(evlistener) : arrayClone3(evlistener, evlistener.length);
}
__name(_listeners, "_listeners");
EventEmitter3.prototype.listeners = /* @__PURE__ */ __name(function listeners3(type) {
return _listeners(this, type, true);
}, "listeners");
EventEmitter3.prototype.rawListeners = /* @__PURE__ */ __name(function rawListeners(type) {
return _listeners(this, type, false);
}, "rawListeners");
EventEmitter3.listenerCount = function(emitter, type) {
if (typeof emitter.listenerCount === "function") {
return emitter.listenerCount(type);
} else {
return listenerCount3.call(emitter, type);
}
};
EventEmitter3.prototype.listenerCount = listenerCount3;
function listenerCount3(type) {
var events2 = this._events;
if (events2 !== void 0) {
var evlistener = events2[type];
if (typeof evlistener === "function") {
return 1;
} else if (evlistener !== void 0) {
return evlistener.length;
}
}
return 0;
}
__name(listenerCount3, "listenerCount");
EventEmitter3.prototype.eventNames = /* @__PURE__ */ __name(function eventNames3() {
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
}, "eventNames");
function arrayClone3(arr, n4) {
var copy5 = new Array(n4);
for (var i3 = 0; i3 < n4; ++i3)
copy5[i3] = arr[i3];
return copy5;
}
__name(arrayClone3, "arrayClone");
function spliceOne3(list, index3) {
for (; index3 + 1 < list.length; index3++)
list[index3] = list[index3 + 1];
list.pop();
}
__name(spliceOne3, "spliceOne");
function unwrapListeners3(arr) {
var ret = new Array(arr.length);
for (var i3 = 0; i3 < ret.length; ++i3) {
ret[i3] = arr[i3].listener || arr[i3];
}
return ret;
}
__name(unwrapListeners3, "unwrapListeners");
function once5(emitter, name) {
return new Promise(function(resolve3, reject) {
function errorListener(err2) {
emitter.removeListener(name, resolver);
reject(err2);
}
__name(errorListener, "errorListener");
function resolver() {
if (typeof emitter.removeListener === "function") {
emitter.removeListener("error", errorListener);
}
resolve3([].slice.call(arguments));
}
__name(resolver, "resolver");
eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
if (name !== "error") {
addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
}
});
}
__name(once5, "once");
function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
if (typeof emitter.on === "function") {
eventTargetAgnosticAddListener(emitter, "error", handler, flags);
}
}
__name(addErrorHandlerIfEventEmitter, "addErrorHandlerIfEventEmitter");
function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
if (typeof emitter.on === "function") {
if (flags.once) {
emitter.once(name, listener);
} else {
emitter.on(name, listener);
}
} else if (typeof emitter.addEventListener === "function") {
emitter.addEventListener(name, /* @__PURE__ */ __name(function wrapListener(arg) {
if (flags.once) {
emitter.removeEventListener(name, wrapListener);
}
listener(arg);
}, "wrapListener"));
} else {
throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
}
}
__name(eventTargetAgnosticAddListener, "eventTargetAgnosticAddListener");
}
});
// node_modules/queue/index.js
var require_queue = __commonJS({
"node_modules/queue/index.js"(exports, module) {
var inherits3 = require_inherits_browser();
var EventEmitter3 = require_events().EventEmitter;
module.exports = Queue;
module.exports.default = Queue;
function Queue(options) {
if (!(this instanceof Queue)) {
return new Queue(options);
}
EventEmitter3.call(this);
options = options || {};
this.concurrency = options.concurrency || Infinity;
this.timeout = options.timeout || 0;
this.autostart = options.autostart || false;
this.results = options.results || null;
this.pending = 0;
this.session = 0;
this.running = false;
this.jobs = [];
this.timers = {};
}
__name(Queue, "Queue");
inherits3(Queue, EventEmitter3);
var arrayMethods = [
"pop",
"shift",
"indexOf",
"lastIndexOf"
];
arrayMethods.forEach(function(method) {
Queue.prototype[method] = function() {
return Array.prototype[method].apply(this.jobs, arguments);
};
});
Queue.prototype.slice = function(begin, end2) {
this.jobs = this.jobs.slice(begin, end2);
return this;
};
Queue.prototype.reverse = function() {
this.jobs.reverse();
return this;
};
var arrayAddMethods = [
"push",
"unshift",
"splice"
];
arrayAddMethods.forEach(function(method) {
Queue.prototype[method] = function() {
var methodResult = Array.prototype[method].apply(this.jobs, arguments);
if (this.autostart) {
this.start();
}
return methodResult;
};
});
Object.defineProperty(Queue.prototype, "length", {
get: /* @__PURE__ */ __name(function() {
return this.pending + this.jobs.length;
}, "get")
});
Queue.prototype.start = function(cb) {
if (cb) {
callOnErrorOrEnd.call(this, cb);
}
this.running = true;
if (this.pending >= this.concurrency) {
return;
}
if (this.jobs.length === 0) {
if (this.pending === 0) {
done3.call(this);
}
return;
}
var self2 = this;
var job = this.jobs.shift();
var once5 = true;
var session = this.session;
var timeoutId = null;
var didTimeout = false;
var resultIndex = null;
var timeout = job.hasOwnProperty("timeout") ? job.timeout : this.timeout;
function next(err2, result) {
if (once5 && self2.session === session) {
once5 = false;
self2.pending--;
if (timeoutId !== null) {
delete self2.timers[timeoutId];
clearTimeout(timeoutId);
}
if (err2) {
self2.emit("error", err2, job);
} else if (didTimeout === false) {
if (resultIndex !== null) {
self2.results[resultIndex] = Array.prototype.slice.call(arguments, 1);
}
self2.emit("success", result, job);
}
if (self2.session === session) {
if (self2.pending === 0 && self2.jobs.length === 0) {
done3.call(self2);
} else if (self2.running) {
self2.start();
}
}
}
}
__name(next, "next");
if (timeout) {
timeoutId = setTimeout(function() {
didTimeout = true;
if (self2.listeners("timeout").length > 0) {
self2.emit("timeout", next, job);
} else {
next();
}
}, timeout);
this.timers[timeoutId] = timeoutId;
}
if (this.results) {
resultIndex = this.results.length;
this.results[resultIndex] = null;
}
this.pending++;
self2.emit("start", job);
var promise = job(next);
if (promise && promise.then && typeof promise.then === "function") {
promise.then(function(result) {
return next(null, result);
}).catch(function(err2) {
return next(err2 || true);
});
}
if (this.running && this.jobs.length > 0) {
this.start();
}
};
Queue.prototype.stop = function() {
this.running = false;
};
Queue.prototype.end = function(err2) {
clearTimers.call(this);
this.jobs.length = 0;
this.pending = 0;
done3.call(this, err2);
};
function clearTimers() {
for (var key in this.timers) {
var timeoutId = this.timers[key];
delete this.timers[key];
clearTimeout(timeoutId);
}
}
__name(clearTimers, "clearTimers");
function callOnErrorOrEnd(cb) {
var self2 = this;
this.on("error", onerror);
this.on("end", onend3);
function onerror(err2) {
self2.end(err2);
}
__name(onerror, "onerror");
function onend3(err2) {
self2.removeListener("error", onerror);
self2.removeListener("end", onend3);
cb(err2, this.results);
}
__name(onend3, "onend");
}
__name(callOnErrorOrEnd, "callOnErrorOrEnd");
function done3(err2) {
this.session++;
this.running = false;
this.emit("end", err2);
}
__name(done3, "done");
}
});
// node_modules/is-url/index.js
var require_is_url = __commonJS({
"node_modules/is-url/index.js"(exports, module) {
module.exports = isUrl;
var protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
var localhostDomainRE = /^localhost[\:?\d]*(?:[^\:?\d]\S*)?$/;
var nonLocalhostDomainRE = /^[^\s\.]+\.\S{2,}$/;
function isUrl(string) {
if (typeof string !== "string") {
return false;
}
var match = string.match(protocolAndDomainRE);
if (!match) {
return false;
}
var everythingAfterProtocol = match[1];
if (!everythingAfterProtocol) {
return false;
}
if (localhostDomainRE.test(everythingAfterProtocol) || nonLocalhostDomainRE.test(everythingAfterProtocol)) {
return true;
}
return false;
}
__name(isUrl, "isUrl");
}
});
// node_modules/fast-deep-equal/index.js
var require_fast_deep_equal = __commonJS({
"node_modules/fast-deep-equal/index.js"(exports, module) {
module.exports = /* @__PURE__ */ __name(function equal3(a3, b2) {
if (a3 === b2) return true;
if (a3 && b2 && typeof a3 == "object" && typeof b2 == "object") {
if (a3.constructor !== b2.constructor) return false;
var length2, i3, keys2;
if (Array.isArray(a3)) {
length2 = a3.length;
if (length2 != b2.length) return false;
for (i3 = length2; i3-- !== 0; )
if (!equal3(a3[i3], b2[i3])) return false;
return true;
}
if (a3.constructor === RegExp) return a3.source === b2.source && a3.flags === b2.flags;
if (a3.valueOf !== Object.prototype.valueOf) return a3.valueOf() === b2.valueOf();
if (a3.toString !== Object.prototype.toString) return a3.toString() === b2.toString();
keys2 = Object.keys(a3);
length2 = keys2.length;
if (length2 !== Object.keys(b2).length) return false;
for (i3 = length2; i3-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b2, keys2[i3])) return false;
for (i3 = length2; i3-- !== 0; ) {
var key = keys2[i3];
if (!equal3(a3[key], b2[key])) return false;
}
return true;
}
return a3 !== a3 && b2 !== b2;
}, "equal");
}
});
// node_modules/base64-js/index.js
var require_base64_js = __commonJS({
"node_modules/base64-js/index.js"(exports) {
exports.byteLength = byteLength5;
exports.toByteArray = toByteArray4;
exports.fromByteArray = fromByteArray4;
var lookup4 = [];
var revLookup4 = [];
var Arr4 = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
for (i3 = 0, len = code.length; i3 < len; ++i3) {
lookup4[i3] = code[i3];
revLookup4[code.charCodeAt(i3)] = i3;
}
var i3;
var len;
revLookup4["-".charCodeAt(0)] = 62;
revLookup4["_".charCodeAt(0)] = 63;
function getLens(b64) {
var len2 = b64.length;
if (len2 % 4 > 0) {
throw new Error("Invalid string. Length must be a multiple of 4");
}
var validLen = b64.indexOf("=");
if (validLen === -1) validLen = len2;
var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
return [validLen, placeHoldersLen];
}
__name(getLens, "getLens");
function byteLength5(b64) {
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
__name(byteLength5, "byteLength");
function _byteLength(b64, validLen, placeHoldersLen) {
return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
}
__name(_byteLength, "_byteLength");
function toByteArray4(b64) {
var tmp;
var lens = getLens(b64);
var validLen = lens[0];
var placeHoldersLen = lens[1];
var arr = new Arr4(_byteLength(b64, validLen, placeHoldersLen));
var curByte = 0;
var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
var i4;
for (i4 = 0; i4 < len2; i4 += 4) {
tmp = revLookup4[b64.charCodeAt(i4)] << 18 | revLookup4[b64.charCodeAt(i4 + 1)] << 12 | revLookup4[b64.charCodeAt(i4 + 2)] << 6 | revLookup4[b64.charCodeAt(i4 + 3)];
arr[curByte++] = tmp >> 16 & 255;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 2) {
tmp = revLookup4[b64.charCodeAt(i4)] << 2 | revLookup4[b64.charCodeAt(i4 + 1)] >> 4;
arr[curByte++] = tmp & 255;
}
if (placeHoldersLen === 1) {
tmp = revLookup4[b64.charCodeAt(i4)] << 10 | revLookup4[b64.charCodeAt(i4 + 1)] << 4 | revLookup4[b64.charCodeAt(i4 + 2)] >> 2;
arr[curByte++] = tmp >> 8 & 255;
arr[curByte++] = tmp & 255;
}
return arr;
}
__name(toByteArray4, "toByteArray");
function tripletToBase644(num) {
return lookup4[num >> 18 & 63] + lookup4[num >> 12 & 63] + lookup4[num >> 6 & 63] + lookup4[num & 63];
}
__name(tripletToBase644, "tripletToBase64");
function encodeChunk4(uint82, start2, end2) {
var tmp;
var output = [];
for (var i4 = start2; i4 < end2; i4 += 3) {
tmp = (uint82[i4] << 16 & 16711680) + (uint82[i4 + 1] << 8 & 65280) + (uint82[i4 + 2] & 255);
output.push(tripletToBase644(tmp));
}
return output.join("");
}
__name(encodeChunk4, "encodeChunk");
function fromByteArray4(uint82) {
var tmp;
var len2 = uint82.length;
var extraBytes = len2 % 3;
var parts = [];
var maxChunkLength = 16383;
for (var i4 = 0, len22 = len2 - extraBytes; i4 < len22; i4 += maxChunkLength) {
parts.push(encodeChunk4(uint82, i4, i4 + maxChunkLength > len22 ? len22 : i4 + maxChunkLength));
}
if (extraBytes === 1) {
tmp = uint82[len2 - 1];
parts.push(
lookup4[tmp >> 2] + lookup4[tmp << 4 & 63] + "=="
);
} else if (extraBytes === 2) {
tmp = (uint82[len2 - 2] << 8) + uint82[len2 - 1];
parts.push(
lookup4[tmp >> 10] + lookup4[tmp >> 4 & 63] + lookup4[tmp << 2 & 63] + "="
);
}
return parts.join("");
}
__name(fromByteArray4, "fromByteArray");
}
});
// node_modules/tiny-inflate/index.js
var require_tiny_inflate = __commonJS({
"node_modules/tiny-inflate/index.js"(exports, module) {
var TINF_OK = 0;
var TINF_DATA_ERROR = -3;
function Tree() {
this.table = new Uint16Array(16);
this.trans = new Uint16Array(288);
}
__name(Tree, "Tree");
function Data(source, dest) {
this.source = source;
this.sourceIndex = 0;
this.tag = 0;
this.bitcount = 0;
this.dest = dest;
this.destLen = 0;
this.ltree = new Tree();
this.dtree = new Tree();
}
__name(Data, "Data");
var sltree = new Tree();
var sdtree = new Tree();
var length_bits = new Uint8Array(30);
var length_base = new Uint16Array(30);
var dist_bits = new Uint8Array(30);
var dist_base = new Uint16Array(30);
var clcidx = new Uint8Array([
16,
17,
18,
0,
8,
7,
9,
6,
10,
5,
11,
4,
12,
3,
13,
2,
14,
1,
15
]);
var code_tree = new Tree();
var lengths = new Uint8Array(288 + 32);
function tinf_build_bits_base(bits, base, delta, first) {
var i3, sum;
for (i3 = 0; i3 < delta; ++i3) bits[i3] = 0;
for (i3 = 0; i3 < 30 - delta; ++i3) bits[i3 + delta] = i3 / delta | 0;
for (sum = first, i3 = 0; i3 < 30; ++i3) {
base[i3] = sum;
sum += 1 << bits[i3];
}
}
__name(tinf_build_bits_base, "tinf_build_bits_base");
function tinf_build_fixed_trees(lt, dt) {
var i3;
for (i3 = 0; i3 < 7; ++i3) lt.table[i3] = 0;
lt.table[7] = 24;
lt.table[8] = 152;
lt.table[9] = 112;
for (i3 = 0; i3 < 24; ++i3) lt.trans[i3] = 256 + i3;
for (i3 = 0; i3 < 144; ++i3) lt.trans[24 + i3] = i3;
for (i3 = 0; i3 < 8; ++i3) lt.trans[24 + 144 + i3] = 280 + i3;
for (i3 = 0; i3 < 112; ++i3) lt.trans[24 + 144 + 8 + i3] = 144 + i3;
for (i3 = 0; i3 < 5; ++i3) dt.table[i3] = 0;
dt.table[5] = 32;
for (i3 = 0; i3 < 32; ++i3) dt.trans[i3] = i3;
}
__name(tinf_build_fixed_trees, "tinf_build_fixed_trees");
var offs = new Uint16Array(16);
function tinf_build_tree(t3, lengths2, off3, num) {
var i3, sum;
for (i3 = 0; i3 < 16; ++i3) t3.table[i3] = 0;
for (i3 = 0; i3 < num; ++i3) t3.table[lengths2[off3 + i3]]++;
t3.table[0] = 0;
for (sum = 0, i3 = 0; i3 < 16; ++i3) {
offs[i3] = sum;
sum += t3.table[i3];
}
for (i3 = 0; i3 < num; ++i3) {
if (lengths2[off3 + i3]) t3.trans[offs[lengths2[off3 + i3]]++] = i3;
}
}
__name(tinf_build_tree, "tinf_build_tree");
function tinf_getbit(d2) {
if (!d2.bitcount--) {
d2.tag = d2.source[d2.sourceIndex++];
d2.bitcount = 7;
}
var bit = d2.tag & 1;
d2.tag >>>= 1;
return bit;
}
__name(tinf_getbit, "tinf_getbit");
function tinf_read_bits(d2, num, base) {
if (!num)
return base;
while (d2.bitcount < 24) {
d2.tag |= d2.source[d2.sourceIndex++] << d2.bitcount;
d2.bitcount += 8;
}
var val = d2.tag & 65535 >>> 16 - num;
d2.tag >>>= num;
d2.bitcount -= num;
return val + base;
}
__name(tinf_read_bits, "tinf_read_bits");
function tinf_decode_symbol(d2, t3) {
while (d2.bitcount < 24) {
d2.tag |= d2.source[d2.sourceIndex++] << d2.bitcount;
d2.bitcount += 8;
}
var sum = 0, cur = 0, len = 0;
var tag = d2.tag;
do {
cur = 2 * cur + (tag & 1);
tag >>>= 1;
++len;
sum += t3.table[len];
cur -= t3.table[len];
} while (cur >= 0);
d2.tag = tag;
d2.bitcount -= len;
return t3.trans[sum + cur];
}
__name(tinf_decode_symbol, "tinf_decode_symbol");
function tinf_decode_trees(d2, lt, dt) {
var hlit, hdist, hclen;
var i3, num, length2;
hlit = tinf_read_bits(d2, 5, 257);
hdist = tinf_read_bits(d2, 5, 1);
hclen = tinf_read_bits(d2, 4, 4);
for (i3 = 0; i3 < 19; ++i3) lengths[i3] = 0;
for (i3 = 0; i3 < hclen; ++i3) {
var clen = tinf_read_bits(d2, 3, 0);
lengths[clcidx[i3]] = clen;
}
tinf_build_tree(code_tree, lengths, 0, 19);
for (num = 0; num < hlit + hdist; ) {
var sym = tinf_decode_symbol(d2, code_tree);
switch (sym) {
case 16:
var prev = lengths[num - 1];
for (length2 = tinf_read_bits(d2, 2, 3); length2; --length2) {
lengths[num++] = prev;
}
break;
case 17:
for (length2 = tinf_read_bits(d2, 3, 3); length2; --length2) {
lengths[num++] = 0;
}
break;
case 18:
for (length2 = tinf_read_bits(d2, 7, 11); length2; --length2) {
lengths[num++] = 0;
}
break;
default:
lengths[num++] = sym;
break;
}
}
tinf_build_tree(lt, lengths, 0, hlit);
tinf_build_tree(dt, lengths, hlit, hdist);
}
__name(tinf_decode_trees, "tinf_decode_trees");
function tinf_inflate_block_data(d2, lt, dt) {
while (1) {
var sym = tinf_decode_symbol(d2, lt);
if (sym === 256) {
return TINF_OK;
}
if (sym < 256) {
d2.dest[d2.destLen++] = sym;
} else {
var length2, dist, offs2;
var i3;
sym -= 257;
length2 = tinf_read_bits(d2, length_bits[sym], length_base[sym]);
dist = tinf_decode_symbol(d2, dt);
offs2 = d2.destLen - tinf_read_bits(d2, dist_bits[dist], dist_base[dist]);
for (i3 = offs2; i3 < offs2 + length2; ++i3) {
d2.dest[d2.destLen++] = d2.dest[i3];
}
}
}
}
__name(tinf_inflate_block_data, "tinf_inflate_block_data");
function tinf_inflate_uncompressed_block(d2) {
var length2, invlength;
var i3;
while (d2.bitcount > 8) {
d2.sourceIndex--;
d2.bitcount -= 8;
}
length2 = d2.source[d2.sourceIndex + 1];
length2 = 256 * length2 + d2.source[d2.sourceIndex];
invlength = d2.source[d2.sourceIndex + 3];
invlength = 256 * invlength + d2.source[d2.sourceIndex + 2];
if (length2 !== (~invlength & 65535))
return TINF_DATA_ERROR;
d2.sourceIndex += 4;
for (i3 = length2; i3; --i3)
d2.dest[d2.destLen++] = d2.source[d2.sourceIndex++];
d2.bitcount = 0;
return TINF_OK;
}
__name(tinf_inflate_uncompressed_block, "tinf_inflate_uncompressed_block");
function tinf_uncompress(source, dest) {
var d2 = new Data(source, dest);
var bfinal, btype, res;
do {
bfinal = tinf_getbit(d2);
btype = tinf_read_bits(d2, 2, 0);
switch (btype) {
case 0:
res = tinf_inflate_uncompressed_block(d2);
break;
case 1:
res = tinf_inflate_block_data(d2, sltree, sdtree);
break;
case 2:
tinf_decode_trees(d2, d2.ltree, d2.dtree);
res = tinf_inflate_block_data(d2, d2.ltree, d2.dtree);
break;
default:
res = TINF_DATA_ERROR;
}
if (res !== TINF_OK)
throw new Error("Data error");
} while (!bfinal);
if (d2.destLen < d2.dest.length) {
if (typeof d2.dest.slice === "function")
return d2.dest.slice(0, d2.destLen);
else
return d2.dest.subarray(0, d2.destLen);
}
return d2.dest;
}
__name(tinf_uncompress, "tinf_uncompress");
tinf_build_fixed_trees(sltree, sdtree);
tinf_build_bits_base(length_bits, length_base, 4, 3);
tinf_build_bits_base(dist_bits, dist_base, 2, 1);
length_bits[28] = 0;
length_base[28] = 258;
module.exports = tinf_uncompress;
}
});
// node_modules/unicode-trie/swap.js
var require_swap = __commonJS({
"node_modules/unicode-trie/swap.js"(exports, module) {
var isBigEndian2 = new Uint8Array(new Uint32Array([305419896]).buffer)[0] === 18;
var swap4 = /* @__PURE__ */ __name((b2, n4, m) => {
let i3 = b2[n4];
b2[n4] = b2[m];
b2[m] = i3;
}, "swap");
var swap324 = /* @__PURE__ */ __name((array) => {
const len = array.length;
for (let i3 = 0; i3 < len; i3 += 4) {
swap4(array, i3, i3 + 3);
swap4(array, i3 + 1, i3 + 2);
}
}, "swap32");
var swap32LE = /* @__PURE__ */ __name((array) => {
if (isBigEndian2) {
swap324(array);
}
}, "swap32LE");
module.exports = {
swap32LE
};
}
});
// node_modules/unicode-trie/index.js
var require_unicode_trie = __commonJS({
"node_modules/unicode-trie/index.js"(exports, module) {
var inflate2 = require_tiny_inflate();
var { swap32LE } = require_swap();
var SHIFT_1 = 6 + 5;
var SHIFT_2 = 5;
var SHIFT_1_2 = SHIFT_1 - SHIFT_2;
var OMITTED_BMP_INDEX_1_LENGTH = 65536 >> SHIFT_1;
var INDEX_2_BLOCK_LENGTH = 1 << SHIFT_1_2;
var INDEX_2_MASK = INDEX_2_BLOCK_LENGTH - 1;
var INDEX_SHIFT = 2;
var DATA_BLOCK_LENGTH = 1 << SHIFT_2;
var DATA_MASK = DATA_BLOCK_LENGTH - 1;
var LSCP_INDEX_2_OFFSET = 65536 >> SHIFT_2;
var LSCP_INDEX_2_LENGTH = 1024 >> SHIFT_2;
var INDEX_2_BMP_LENGTH = LSCP_INDEX_2_OFFSET + LSCP_INDEX_2_LENGTH;
var UTF8_2B_INDEX_2_OFFSET = INDEX_2_BMP_LENGTH;
var UTF8_2B_INDEX_2_LENGTH = 2048 >> 6;
var INDEX_1_OFFSET = UTF8_2B_INDEX_2_OFFSET + UTF8_2B_INDEX_2_LENGTH;
var DATA_GRANULARITY = 1 << INDEX_SHIFT;
var UnicodeTrie = class {
static {
__name(this, "UnicodeTrie");
}
constructor(data2) {
const isBuffer4 = typeof data2.readUInt32BE === "function" && typeof data2.slice === "function";
if (isBuffer4 || data2 instanceof Uint8Array) {
let uncompressedLength;
if (isBuffer4) {
this.highStart = data2.readUInt32LE(0);
this.errorValue = data2.readUInt32LE(4);
uncompressedLength = data2.readUInt32LE(8);
data2 = data2.slice(12);
} else {
const view = new DataView(data2.buffer);
this.highStart = view.getUint32(0, true);
this.errorValue = view.getUint32(4, true);
uncompressedLength = view.getUint32(8, true);
data2 = data2.subarray(12);
}
data2 = inflate2(data2, new Uint8Array(uncompressedLength));
data2 = inflate2(data2, new Uint8Array(uncompressedLength));
swap32LE(data2);
this.data = new Uint32Array(data2.buffer);
} else {
({ data: this.data, highStart: this.highStart, errorValue: this.errorValue } = data2);
}
}
get(codePoint) {
let index3;
if (codePoint < 0 || codePoint > 1114111) {
return this.errorValue;
}
if (codePoint < 55296 || codePoint > 56319 && codePoint <= 65535) {
index3 = (this.data[codePoint >> SHIFT_2] << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index3];
}
if (codePoint <= 65535) {
index3 = (this.data[LSCP_INDEX_2_OFFSET + (codePoint - 55296 >> SHIFT_2)] << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index3];
}
if (codePoint < this.highStart) {
index3 = this.data[INDEX_1_OFFSET - OMITTED_BMP_INDEX_1_LENGTH + (codePoint >> SHIFT_1)];
index3 = this.data[index3 + (codePoint >> SHIFT_2 & INDEX_2_MASK)];
index3 = (index3 << INDEX_SHIFT) + (codePoint & DATA_MASK);
return this.data[index3];
}
return this.data[this.data.length - DATA_GRANULARITY];
}
};
module.exports = UnicodeTrie;
}
});
// node_modules/dfa/index.js
var require_dfa = __commonJS({
"node_modules/dfa/index.js"(exports, module) {
var INITIAL_STATE = 1;
var FAIL_STATE = 0;
var StateMachine = class {
static {
__name(this, "StateMachine");
}
constructor(dfa) {
this.stateTable = dfa.stateTable;
this.accepting = dfa.accepting;
this.tags = dfa.tags;
}
/**
* Returns an iterable object that yields pattern matches over the input sequence.
* Matches are of the form [startIndex, endIndex, tags].
*/
match(str) {
var self2 = this;
return {
*[Symbol.iterator]() {
var state2 = INITIAL_STATE;
var startRun = null;
var lastAccepting = null;
var lastState = null;
for (var p2 = 0; p2 < str.length; p2++) {
var c3 = str[p2];
lastState = state2;
state2 = self2.stateTable[state2][c3];
if (state2 === FAIL_STATE) {
if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
yield [startRun, lastAccepting, self2.tags[lastState]];
}
state2 = self2.stateTable[INITIAL_STATE][c3];
startRun = null;
}
if (state2 !== FAIL_STATE && startRun == null) {
startRun = p2;
}
if (self2.accepting[state2]) {
lastAccepting = p2;
}
if (state2 === FAIL_STATE) {
state2 = INITIAL_STATE;
}
}
if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
yield [startRun, lastAccepting, self2.tags[state2]];
}
}
};
}
/**
* For each match over the input sequence, action functions matching
* the tag definitions in the input pattern are called with the startIndex,
* endIndex, and sub-match sequence.
*/
apply(str, actions) {
for (var [start2, end2, tags2] of this.match(str)) {
for (var tag of tags2) {
if (typeof actions[tag] === "function") {
actions[tag](start2, end2, str.slice(start2, end2 + 1));
}
}
}
}
};
module.exports = StateMachine;
}
});
// node_modules/clone/clone.js
var require_clone = __commonJS({
"node_modules/clone/clone.js"(exports, module) {
var clone = function() {
function _instanceof(obj, type) {
return type != null && obj instanceof type;
}
__name(_instanceof, "_instanceof");
var nativeMap;
try {
nativeMap = Map;
} catch (_) {
nativeMap = /* @__PURE__ */ __name(function() {
}, "nativeMap");
}
var nativeSet;
try {
nativeSet = Set;
} catch (_) {
nativeSet = /* @__PURE__ */ __name(function() {
}, "nativeSet");
}
var nativePromise;
try {
nativePromise = Promise;
} catch (_) {
nativePromise = /* @__PURE__ */ __name(function() {
}, "nativePromise");
}
function clone2(parent, circular, depth, prototype, includeNonEnumerable) {
if (typeof circular === "object") {
depth = circular.depth;
prototype = circular.prototype;
includeNonEnumerable = circular.includeNonEnumerable;
circular = circular.circular;
}
var allParents = [];
var allChildren = [];
var useBuffer = typeof Buffer != "undefined";
if (typeof circular == "undefined")
circular = true;
if (typeof depth == "undefined")
depth = Infinity;
function _clone(parent2, depth2) {
if (parent2 === null)
return null;
if (depth2 === 0)
return parent2;
var child;
var proto;
if (typeof parent2 != "object") {
return parent2;
}
if (_instanceof(parent2, nativeMap)) {
child = new nativeMap();
} else if (_instanceof(parent2, nativeSet)) {
child = new nativeSet();
} else if (_instanceof(parent2, nativePromise)) {
child = new nativePromise(function(resolve3, reject) {
parent2.then(function(value2) {
resolve3(_clone(value2, depth2 - 1));
}, function(err2) {
reject(_clone(err2, depth2 - 1));
});
});
} else if (clone2.__isArray(parent2)) {
child = [];
} else if (clone2.__isRegExp(parent2)) {
child = new RegExp(parent2.source, __getRegExpFlags(parent2));
if (parent2.lastIndex) child.lastIndex = parent2.lastIndex;
} else if (clone2.__isDate(parent2)) {
child = new Date(parent2.getTime());
} else if (useBuffer && Buffer.isBuffer(parent2)) {
if (Buffer.allocUnsafe) {
child = Buffer.allocUnsafe(parent2.length);
} else {
child = new Buffer(parent2.length);
}
parent2.copy(child);
return child;
} else if (_instanceof(parent2, Error)) {
child = Object.create(parent2);
} else {
if (typeof prototype == "undefined") {
proto = Object.getPrototypeOf(parent2);
child = Object.create(proto);
} else {
child = Object.create(prototype);
proto = prototype;
}
}
if (circular) {
var index3 = allParents.indexOf(parent2);
if (index3 != -1) {
return allChildren[index3];
}
allParents.push(parent2);
allChildren.push(child);
}
if (_instanceof(parent2, nativeMap)) {
parent2.forEach(function(value2, key) {
var keyChild = _clone(key, depth2 - 1);
var valueChild = _clone(value2, depth2 - 1);
child.set(keyChild, valueChild);
});
}
if (_instanceof(parent2, nativeSet)) {
parent2.forEach(function(value2) {
var entryChild = _clone(value2, depth2 - 1);
child.add(entryChild);
});
}
for (var i3 in parent2) {
var attrs;
if (proto) {
attrs = Object.getOwnPropertyDescriptor(proto, i3);
}
if (attrs && attrs.set == null) {
continue;
}
child[i3] = _clone(parent2[i3], depth2 - 1);
}
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(parent2);
for (var i3 = 0; i3 < symbols.length; i3++) {
var symbol = symbols[i3];
var descriptor = Object.getOwnPropertyDescriptor(parent2, symbol);
if (descriptor && !descriptor.enumerable && !includeNonEnumerable) {
continue;
}
child[symbol] = _clone(parent2[symbol], depth2 - 1);
if (!descriptor.enumerable) {
Object.defineProperty(child, symbol, {
enumerable: false
});
}
}
}
if (includeNonEnumerable) {
var allPropertyNames = Object.getOwnPropertyNames(parent2);
for (var i3 = 0; i3 < allPropertyNames.length; i3++) {
var propertyName = allPropertyNames[i3];
var descriptor = Object.getOwnPropertyDescriptor(parent2, propertyName);
if (descriptor && descriptor.enumerable) {
continue;
}
child[propertyName] = _clone(parent2[propertyName], depth2 - 1);
Object.defineProperty(child, propertyName, {
enumerable: false
});
}
}
return child;
}
__name(_clone, "_clone");
return _clone(parent, depth);
}
__name(clone2, "clone");
clone2.clonePrototype = /* @__PURE__ */ __name(function clonePrototype(parent) {
if (parent === null)
return null;
var c3 = /* @__PURE__ */ __name(function() {
}, "c");
c3.prototype = parent;
return new c3();
}, "clonePrototype");
function __objToStr(o2) {
return Object.pro