karin-plugin-kkk
Version:
Karin 的「抖音」「B 站」视频解析/动态推送插件
1,481 lines (1,479 loc) • 3.58 MB
JavaScript
const __filename = import.meta.url ? new URL(import.meta.url).pathname : "";
const __dirname = import.meta.url ? new URL(".", import.meta.url).pathname : "";
import require$$1$2 from "fs";
import require$$0$5 from "util";
import require$$1$1 from "os";
import require$$1$3 from "path";
import require$$0$6, { fileURLToPath } from "url";
import require$$0$1$1 from "constants";
import stream, { Readable } from "stream";
import require$$5$1 from "assert";
import zlib from "zlib";
import require$$1$3$1 from "net";
import require$$1$4 from "http";
import require$$2$1 from "https";
import crypto$1 from "crypto";
import { EventEmitter } from "events";
import require$$0$4$1 from "buffer";
import require$$1$1$1 from "string_decoder";
import require$$4$1 from "node:zlib";
import require$$1$5 from "node:events";
import path from "node:path";
import fs$1 from "node:fs";
import require$$2$2 from "node:http";
import require$$6$1 from "querystring";
import require$$1$4$1 from "node:net";
var commonjsGlobal$2 = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
var _Reflect = {};
/*! *****************************************************************************
Copyright (C) Microsoft. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
var hasRequired_Reflect;
function require_Reflect() {
if (hasRequired_Reflect) return _Reflect;
hasRequired_Reflect = 1;
var Reflect2;
(function(Reflect3) {
(function(factory2) {
var root = typeof globalThis === "object" ? globalThis : typeof commonjsGlobal$2 === "object" ? commonjsGlobal$2 : typeof self === "object" ? self : typeof this === "object" ? this : sloppyModeThis();
var exporter = makeExporter(Reflect3);
if (typeof root.Reflect !== "undefined") {
exporter = makeExporter(root.Reflect, exporter);
}
factory2(exporter, root);
if (typeof root.Reflect === "undefined") {
root.Reflect = Reflect3;
}
function makeExporter(target, previous) {
return function(key, value) {
Object.defineProperty(target, key, { configurable: true, writable: true, value });
if (previous)
previous(key, value);
};
}
function functionThis() {
try {
return Function("return this;")();
} catch (_) {
}
}
function indirectEvalThis() {
try {
return (void 0, eval)("(function() { return this; })()");
} catch (_) {
}
}
function sloppyModeThis() {
return functionThis() || indirectEvalThis();
}
})(function(exporter, root) {
var hasOwn = Object.prototype.hasOwnProperty;
var supportsSymbol = typeof Symbol === "function";
var toPrimitiveSymbol = supportsSymbol && typeof Symbol.toPrimitive !== "undefined" ? Symbol.toPrimitive : "@@toPrimitive";
var iteratorSymbol = supportsSymbol && typeof Symbol.iterator !== "undefined" ? Symbol.iterator : "@@iterator";
var supportsCreate = typeof Object.create === "function";
var supportsProto = { __proto__: [] } instanceof Array;
var downLevel = !supportsCreate && !supportsProto;
var HashMap = {
// create an object in dictionary mode (a.k.a. "slow" mode in v8)
create: supportsCreate ? function() {
return MakeDictionary(/* @__PURE__ */ Object.create(null));
} : supportsProto ? function() {
return MakeDictionary({ __proto__: null });
} : function() {
return MakeDictionary({});
},
has: downLevel ? function(map, key) {
return hasOwn.call(map, key);
} : function(map, key) {
return key in map;
},
get: downLevel ? function(map, key) {
return hasOwn.call(map, key) ? map[key] : void 0;
} : function(map, key) {
return map[key];
}
};
var functionPrototype = Object.getPrototypeOf(Function);
var _Map = typeof Map === "function" && typeof Map.prototype.entries === "function" ? Map : CreateMapPolyfill();
var _Set = typeof Set === "function" && typeof Set.prototype.entries === "function" ? Set : CreateSetPolyfill();
var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill();
var registrySymbol = supportsSymbol ? Symbol.for("@reflect-metadata:registry") : void 0;
var metadataRegistry = GetOrCreateMetadataRegistry();
var metadataProvider = CreateMetadataProvider(metadataRegistry);
function decorate(decorators, target, propertyKey, attributes) {
if (!IsUndefined(propertyKey)) {
if (!IsArray(decorators))
throw new TypeError();
if (!IsObject(target))
throw new TypeError();
if (!IsObject(attributes) && !IsUndefined(attributes) && !IsNull(attributes))
throw new TypeError();
if (IsNull(attributes))
attributes = void 0;
propertyKey = ToPropertyKey(propertyKey);
return DecorateProperty(decorators, target, propertyKey, attributes);
} else {
if (!IsArray(decorators))
throw new TypeError();
if (!IsConstructor(target))
throw new TypeError();
return DecorateConstructor(decorators, target);
}
}
exporter("decorate", decorate);
function metadata(metadataKey, metadataValue) {
function decorator(target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey) && !IsPropertyKey(propertyKey))
throw new TypeError();
OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
return decorator;
}
exporter("metadata", metadata);
function defineMetadata(metadataKey, metadataValue, target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, propertyKey);
}
exporter("defineMetadata", defineMetadata);
function hasMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryHasMetadata(metadataKey, target, propertyKey);
}
exporter("hasMetadata", hasMetadata);
function hasOwnMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryHasOwnMetadata(metadataKey, target, propertyKey);
}
exporter("hasOwnMetadata", hasOwnMetadata);
function getMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryGetMetadata(metadataKey, target, propertyKey);
}
exporter("getMetadata", getMetadata);
function getOwnMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryGetOwnMetadata(metadataKey, target, propertyKey);
}
exporter("getOwnMetadata", getOwnMetadata);
function getMetadataKeys(target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryMetadataKeys(target, propertyKey);
}
exporter("getMetadataKeys", getMetadataKeys);
function getOwnMetadataKeys(target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
return OrdinaryOwnMetadataKeys(target, propertyKey);
}
exporter("getOwnMetadataKeys", getOwnMetadataKeys);
function deleteMetadata(metadataKey, target, propertyKey) {
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
if (!IsObject(target))
throw new TypeError();
if (!IsUndefined(propertyKey))
propertyKey = ToPropertyKey(propertyKey);
var provider = GetMetadataProvider(
target,
propertyKey,
/*Create*/
false
);
if (IsUndefined(provider))
return false;
return provider.OrdinaryDeleteMetadata(metadataKey, target, propertyKey);
}
exporter("deleteMetadata", deleteMetadata);
function DecorateConstructor(decorators, target) {
for (var i = decorators.length - 1; i >= 0; --i) {
var decorator = decorators[i];
var decorated = decorator(target);
if (!IsUndefined(decorated) && !IsNull(decorated)) {
if (!IsConstructor(decorated))
throw new TypeError();
target = decorated;
}
}
return target;
}
function DecorateProperty(decorators, target, propertyKey, descriptor) {
for (var i = decorators.length - 1; i >= 0; --i) {
var decorator = decorators[i];
var decorated = decorator(target, propertyKey, descriptor);
if (!IsUndefined(decorated) && !IsNull(decorated)) {
if (!IsObject(decorated))
throw new TypeError();
descriptor = decorated;
}
}
return descriptor;
}
function OrdinaryHasMetadata(MetadataKey, O, P) {
var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
if (hasOwn2)
return true;
var parent = OrdinaryGetPrototypeOf(O);
if (!IsNull(parent))
return OrdinaryHasMetadata(MetadataKey, parent, P);
return false;
}
function OrdinaryHasOwnMetadata(MetadataKey, O, P) {
var provider = GetMetadataProvider(
O,
P,
/*Create*/
false
);
if (IsUndefined(provider))
return false;
return ToBoolean(provider.OrdinaryHasOwnMetadata(MetadataKey, O, P));
}
function OrdinaryGetMetadata(MetadataKey, O, P) {
var hasOwn2 = OrdinaryHasOwnMetadata(MetadataKey, O, P);
if (hasOwn2)
return OrdinaryGetOwnMetadata(MetadataKey, O, P);
var parent = OrdinaryGetPrototypeOf(O);
if (!IsNull(parent))
return OrdinaryGetMetadata(MetadataKey, parent, P);
return void 0;
}
function OrdinaryGetOwnMetadata(MetadataKey, O, P) {
var provider = GetMetadataProvider(
O,
P,
/*Create*/
false
);
if (IsUndefined(provider))
return;
return provider.OrdinaryGetOwnMetadata(MetadataKey, O, P);
}
function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) {
var provider = GetMetadataProvider(
O,
P,
/*Create*/
true
);
provider.OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P);
}
function OrdinaryMetadataKeys(O, P) {
var ownKeys = OrdinaryOwnMetadataKeys(O, P);
var parent = OrdinaryGetPrototypeOf(O);
if (parent === null)
return ownKeys;
var parentKeys = OrdinaryMetadataKeys(parent, P);
if (parentKeys.length <= 0)
return ownKeys;
if (ownKeys.length <= 0)
return parentKeys;
var set = new _Set();
var keys = [];
for (var _i = 0, ownKeys_1 = ownKeys; _i < ownKeys_1.length; _i++) {
var key = ownKeys_1[_i];
var hasKey = set.has(key);
if (!hasKey) {
set.add(key);
keys.push(key);
}
}
for (var _a = 0, parentKeys_1 = parentKeys; _a < parentKeys_1.length; _a++) {
var key = parentKeys_1[_a];
var hasKey = set.has(key);
if (!hasKey) {
set.add(key);
keys.push(key);
}
}
return keys;
}
function OrdinaryOwnMetadataKeys(O, P) {
var provider = GetMetadataProvider(
O,
P,
/*create*/
false
);
if (!provider) {
return [];
}
return provider.OrdinaryOwnMetadataKeys(O, P);
}
function Type(x) {
if (x === null)
return 1;
switch (typeof x) {
case "undefined":
return 0;
case "boolean":
return 2;
case "string":
return 3;
case "symbol":
return 4;
case "number":
return 5;
case "object":
return x === null ? 1 : 6;
default:
return 6;
}
}
function IsUndefined(x) {
return x === void 0;
}
function IsNull(x) {
return x === null;
}
function IsSymbol(x) {
return typeof x === "symbol";
}
function IsObject(x) {
return typeof x === "object" ? x !== null : typeof x === "function";
}
function ToPrimitive(input, PreferredType) {
switch (Type(input)) {
case 0:
return input;
case 1:
return input;
case 2:
return input;
case 3:
return input;
case 4:
return input;
case 5:
return input;
}
var hint = "string";
var exoticToPrim = GetMethod(input, toPrimitiveSymbol);
if (exoticToPrim !== void 0) {
var result = exoticToPrim.call(input, hint);
if (IsObject(result))
throw new TypeError();
return result;
}
return OrdinaryToPrimitive(input);
}
function OrdinaryToPrimitive(O, hint) {
var valueOf, result, toString_2;
{
var toString_1 = O.toString;
if (IsCallable(toString_1)) {
var result = toString_1.call(O);
if (!IsObject(result))
return result;
}
var valueOf = O.valueOf;
if (IsCallable(valueOf)) {
var result = valueOf.call(O);
if (!IsObject(result))
return result;
}
}
throw new TypeError();
}
function ToBoolean(argument) {
return !!argument;
}
function ToString(argument) {
return "" + argument;
}
function ToPropertyKey(argument) {
var key = ToPrimitive(argument);
if (IsSymbol(key))
return key;
return ToString(key);
}
function IsArray(argument) {
return Array.isArray ? Array.isArray(argument) : argument instanceof Object ? argument instanceof Array : Object.prototype.toString.call(argument) === "[object Array]";
}
function IsCallable(argument) {
return typeof argument === "function";
}
function IsConstructor(argument) {
return typeof argument === "function";
}
function IsPropertyKey(argument) {
switch (Type(argument)) {
case 3:
return true;
case 4:
return true;
default:
return false;
}
}
function SameValueZero(x, y) {
return x === y || x !== x && y !== y;
}
function GetMethod(V, P) {
var func = V[P];
if (func === void 0 || func === null)
return void 0;
if (!IsCallable(func))
throw new TypeError();
return func;
}
function GetIterator(obj) {
var method = GetMethod(obj, iteratorSymbol);
if (!IsCallable(method))
throw new TypeError();
var iterator2 = method.call(obj);
if (!IsObject(iterator2))
throw new TypeError();
return iterator2;
}
function IteratorValue(iterResult) {
return iterResult.value;
}
function IteratorStep(iterator2) {
var result = iterator2.next();
return result.done ? false : result;
}
function IteratorClose(iterator2) {
var f = iterator2["return"];
if (f)
f.call(iterator2);
}
function OrdinaryGetPrototypeOf(O) {
var proto2 = Object.getPrototypeOf(O);
if (typeof O !== "function" || O === functionPrototype)
return proto2;
if (proto2 !== functionPrototype)
return proto2;
var prototype2 = O.prototype;
var prototypeProto = prototype2 && Object.getPrototypeOf(prototype2);
if (prototypeProto == null || prototypeProto === Object.prototype)
return proto2;
var constructor = prototypeProto.constructor;
if (typeof constructor !== "function")
return proto2;
if (constructor === O)
return proto2;
return constructor;
}
function CreateMetadataRegistry() {
var fallback;
if (!IsUndefined(registrySymbol) && typeof root.Reflect !== "undefined" && !(registrySymbol in root.Reflect) && typeof root.Reflect.defineMetadata === "function") {
fallback = CreateFallbackProvider(root.Reflect);
}
var first;
var second;
var rest;
var targetProviderMap = new _WeakMap();
var registry = {
registerProvider,
getProvider,
setProvider
};
return registry;
function registerProvider(provider) {
if (!Object.isExtensible(registry)) {
throw new Error("Cannot add provider to a frozen registry.");
}
switch (true) {
case fallback === provider:
break;
case IsUndefined(first):
first = provider;
break;
case first === provider:
break;
case IsUndefined(second):
second = provider;
break;
case second === provider:
break;
default:
if (rest === void 0)
rest = new _Set();
rest.add(provider);
break;
}
}
function getProviderNoCache(O, P) {
if (!IsUndefined(first)) {
if (first.isProviderFor(O, P))
return first;
if (!IsUndefined(second)) {
if (second.isProviderFor(O, P))
return first;
if (!IsUndefined(rest)) {
var iterator2 = GetIterator(rest);
while (true) {
var next = IteratorStep(iterator2);
if (!next) {
return void 0;
}
var provider = IteratorValue(next);
if (provider.isProviderFor(O, P)) {
IteratorClose(iterator2);
return provider;
}
}
}
}
}
if (!IsUndefined(fallback) && fallback.isProviderFor(O, P)) {
return fallback;
}
return void 0;
}
function getProvider(O, P) {
var providerMap = targetProviderMap.get(O);
var provider;
if (!IsUndefined(providerMap)) {
provider = providerMap.get(P);
}
if (!IsUndefined(provider)) {
return provider;
}
provider = getProviderNoCache(O, P);
if (!IsUndefined(provider)) {
if (IsUndefined(providerMap)) {
providerMap = new _Map();
targetProviderMap.set(O, providerMap);
}
providerMap.set(P, provider);
}
return provider;
}
function hasProvider(provider) {
if (IsUndefined(provider))
throw new TypeError();
return first === provider || second === provider || !IsUndefined(rest) && rest.has(provider);
}
function setProvider(O, P, provider) {
if (!hasProvider(provider)) {
throw new Error("Metadata provider not registered.");
}
var existingProvider = getProvider(O, P);
if (existingProvider !== provider) {
if (!IsUndefined(existingProvider)) {
return false;
}
var providerMap = targetProviderMap.get(O);
if (IsUndefined(providerMap)) {
providerMap = new _Map();
targetProviderMap.set(O, providerMap);
}
providerMap.set(P, provider);
}
return true;
}
}
function GetOrCreateMetadataRegistry() {
var metadataRegistry2;
if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
metadataRegistry2 = root.Reflect[registrySymbol];
}
if (IsUndefined(metadataRegistry2)) {
metadataRegistry2 = CreateMetadataRegistry();
}
if (!IsUndefined(registrySymbol) && IsObject(root.Reflect) && Object.isExtensible(root.Reflect)) {
Object.defineProperty(root.Reflect, registrySymbol, {
enumerable: false,
configurable: false,
writable: false,
value: metadataRegistry2
});
}
return metadataRegistry2;
}
function CreateMetadataProvider(registry) {
var metadata2 = new _WeakMap();
var provider = {
isProviderFor: function(O, P) {
var targetMetadata = metadata2.get(O);
if (IsUndefined(targetMetadata))
return false;
return targetMetadata.has(P);
},
OrdinaryDefineOwnMetadata: OrdinaryDefineOwnMetadata2,
OrdinaryHasOwnMetadata: OrdinaryHasOwnMetadata2,
OrdinaryGetOwnMetadata: OrdinaryGetOwnMetadata2,
OrdinaryOwnMetadataKeys: OrdinaryOwnMetadataKeys2,
OrdinaryDeleteMetadata
};
metadataRegistry.registerProvider(provider);
return provider;
function GetOrCreateMetadataMap(O, P, Create) {
var targetMetadata = metadata2.get(O);
var createdTargetMetadata = false;
if (IsUndefined(targetMetadata)) {
if (!Create)
return void 0;
targetMetadata = new _Map();
metadata2.set(O, targetMetadata);
createdTargetMetadata = true;
}
var metadataMap = targetMetadata.get(P);
if (IsUndefined(metadataMap)) {
if (!Create)
return void 0;
metadataMap = new _Map();
targetMetadata.set(P, metadataMap);
if (!registry.setProvider(O, P, provider)) {
targetMetadata.delete(P);
if (createdTargetMetadata) {
metadata2.delete(O);
}
throw new Error("Wrong provider for target.");
}
}
return metadataMap;
}
function OrdinaryHasOwnMetadata2(MetadataKey, O, P) {
var metadataMap = GetOrCreateMetadataMap(
O,
P,
/*Create*/
false
);
if (IsUndefined(metadataMap))
return false;
return ToBoolean(metadataMap.has(MetadataKey));
}
function OrdinaryGetOwnMetadata2(MetadataKey, O, P) {
var metadataMap = GetOrCreateMetadataMap(
O,
P,
/*Create*/
false
);
if (IsUndefined(metadataMap))
return void 0;
return metadataMap.get(MetadataKey);
}
function OrdinaryDefineOwnMetadata2(MetadataKey, MetadataValue, O, P) {
var metadataMap = GetOrCreateMetadataMap(
O,
P,
/*Create*/
true
);
metadataMap.set(MetadataKey, MetadataValue);
}
function OrdinaryOwnMetadataKeys2(O, P) {
var keys = [];
var metadataMap = GetOrCreateMetadataMap(
O,
P,
/*Create*/
false
);
if (IsUndefined(metadataMap))
return keys;
var keysObj = metadataMap.keys();
var iterator2 = GetIterator(keysObj);
var k = 0;
while (true) {
var next = IteratorStep(iterator2);
if (!next) {
keys.length = k;
return keys;
}
var nextValue = IteratorValue(next);
try {
keys[k] = nextValue;
} catch (e) {
try {
IteratorClose(iterator2);
} finally {
throw e;
}
}
k++;
}
}
function OrdinaryDeleteMetadata(MetadataKey, O, P) {
var metadataMap = GetOrCreateMetadataMap(
O,
P,
/*Create*/
false
);
if (IsUndefined(metadataMap))
return false;
if (!metadataMap.delete(MetadataKey))
return false;
if (metadataMap.size === 0) {
var targetMetadata = metadata2.get(O);
if (!IsUndefined(targetMetadata)) {
targetMetadata.delete(P);
if (targetMetadata.size === 0) {
metadata2.delete(targetMetadata);
}
}
}
return true;
}
}
function CreateFallbackProvider(reflect) {
var defineMetadata2 = reflect.defineMetadata, hasOwnMetadata2 = reflect.hasOwnMetadata, getOwnMetadata2 = reflect.getOwnMetadata, getOwnMetadataKeys2 = reflect.getOwnMetadataKeys, deleteMetadata2 = reflect.deleteMetadata;
var metadataOwner = new _WeakMap();
var provider = {
isProviderFor: function(O, P) {
var metadataPropertySet = metadataOwner.get(O);
if (!IsUndefined(metadataPropertySet) && metadataPropertySet.has(P)) {
return true;
}
if (getOwnMetadataKeys2(O, P).length) {
if (IsUndefined(metadataPropertySet)) {
metadataPropertySet = new _Set();
metadataOwner.set(O, metadataPropertySet);
}
metadataPropertySet.add(P);
return true;
}
return false;
},
OrdinaryDefineOwnMetadata: defineMetadata2,
OrdinaryHasOwnMetadata: hasOwnMetadata2,
OrdinaryGetOwnMetadata: getOwnMetadata2,
OrdinaryOwnMetadataKeys: getOwnMetadataKeys2,
OrdinaryDeleteMetadata: deleteMetadata2
};
return provider;
}
function GetMetadataProvider(O, P, Create) {
var registeredProvider = metadataRegistry.getProvider(O, P);
if (!IsUndefined(registeredProvider)) {
return registeredProvider;
}
if (Create) {
if (metadataRegistry.setProvider(O, P, metadataProvider)) {
return metadataProvider;
}
throw new Error("Illegal state.");
}
return void 0;
}
function CreateMapPolyfill() {
var cacheSentinel = {};
var arraySentinel = [];
var MapIterator = (
/** @class */
function() {
function MapIterator2(keys, values, selector) {
this._index = 0;
this._keys = keys;
this._values = values;
this._selector = selector;
}
MapIterator2.prototype["@@iterator"] = function() {
return this;
};
MapIterator2.prototype[iteratorSymbol] = function() {
return this;
};
MapIterator2.prototype.next = function() {
var index2 = this._index;
if (index2 >= 0 && index2 < this._keys.length) {
var result = this._selector(this._keys[index2], this._values[index2]);
if (index2 + 1 >= this._keys.length) {
this._index = -1;
this._keys = arraySentinel;
this._values = arraySentinel;
} else {
this._index++;
}
return { value: result, done: false };
}
return { value: void 0, done: true };
};
MapIterator2.prototype.throw = function(error) {
if (this._index >= 0) {
this._index = -1;
this._keys = arraySentinel;
this._values = arraySentinel;
}
throw error;
};
MapIterator2.prototype.return = function(value) {
if (this._index >= 0) {
this._index = -1;
this._keys = arraySentinel;
this._values = arraySentinel;
}
return { value, done: true };
};
return MapIterator2;
}()
);
var Map2 = (
/** @class */
function() {
function Map3() {
this._keys = [];
this._values = [];
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
}
Object.defineProperty(Map3.prototype, "size", {
get: function() {
return this._keys.length;
},
enumerable: true,
configurable: true
});
Map3.prototype.has = function(key) {
return this._find(
key,
/*insert*/
false
) >= 0;
};
Map3.prototype.get = function(key) {
var index2 = this._find(
key,
/*insert*/
false
);
return index2 >= 0 ? this._values[index2] : void 0;
};
Map3.prototype.set = function(key, value) {
var index2 = this._find(
key,
/*insert*/
true
);
this._values[index2] = value;
return this;
};
Map3.prototype.delete = function(key) {
var index2 = this._find(
key,
/*insert*/
false
);
if (index2 >= 0) {
var size = this._keys.length;
for (var i = index2 + 1; i < size; i++) {
this._keys[i - 1] = this._keys[i];
this._values[i - 1] = this._values[i];
}
this._keys.length--;
this._values.length--;
if (SameValueZero(key, this._cacheKey)) {
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
}
return true;
}
return false;
};
Map3.prototype.clear = function() {
this._keys.length = 0;
this._values.length = 0;
this._cacheKey = cacheSentinel;
this._cacheIndex = -2;
};
Map3.prototype.keys = function() {
return new MapIterator(this._keys, this._values, getKey);
};
Map3.prototype.values = function() {
return new MapIterator(this._keys, this._values, getValue);
};
Map3.prototype.entries = function() {
return new MapIterator(this._keys, this._values, getEntry);
};
Map3.prototype["@@iterator"] = function() {
return this.entries();
};
Map3.prototype[iteratorSymbol] = function() {
return this.entries();
};
Map3.prototype._find = function(key, insert) {
if (!SameValueZero(this._cacheKey, key)) {
this._cacheIndex = -1;
for (var i = 0; i < this._keys.length; i++) {
if (SameValueZero(this._keys[i], key)) {
this._cacheIndex = i;
break;
}
}
}
if (this._cacheIndex < 0 && insert) {
this._cacheIndex = this._keys.length;
this._keys.push(key);
this._values.push(void 0);
}
return this._cacheIndex;
};
return Map3;
}()
);
return Map2;
function getKey(key, _) {
return key;
}
function getValue(_, value) {
return value;
}
function getEntry(key, value) {
return [key, value];
}
}
function CreateSetPolyfill() {
var Set2 = (
/** @class */
function() {
function Set3() {
this._map = new _Map();
}
Object.defineProperty(Set3.prototype, "size", {
get: function() {
return this._map.size;
},
enumerable: true,
configurable: true
});
Set3.prototype.has = function(value) {
return this._map.has(value);
};
Set3.prototype.add = function(value) {
return this._map.set(value, value), this;
};
Set3.prototype.delete = function(value) {
return this._map.delete(value);
};
Set3.prototype.clear = function() {
this._map.clear();
};
Set3.prototype.keys = function() {
return this._map.keys();
};
Set3.prototype.values = function() {
return this._map.keys();
};
Set3.prototype.entries = function() {
return this._map.entries();
};
Set3.prototype["@@iterator"] = function() {
return this.keys();
};
Set3.prototype[iteratorSymbol] = function() {
return this.keys();
};
return Set3;
}()
);
return Set2;
}
function CreateWeakMapPolyfill() {
var UUID_SIZE = 16;
var keys = HashMap.create();
var rootKey = CreateUniqueKey();
return (
/** @class */
function() {
function WeakMap2() {
this._key = CreateUniqueKey();
}
WeakMap2.prototype.has = function(target) {
var table = GetOrCreateWeakMapTable(
target,
/*create*/
false
);
return table !== void 0 ? HashMap.has(table, this._key) : false;
};
WeakMap2.prototype.get = function(target) {
var table = GetOrCreateWeakMapTable(
target,
/*create*/
false
);
return table !== void 0 ? HashMap.get(table, this._key) : void 0;
};
WeakMap2.prototype.set = function(target, value) {
var table = GetOrCreateWeakMapTable(
target,
/*create*/
true
);
table[this._key] = value;
return this;
};
WeakMap2.prototype.delete = function(target) {
var table = GetOrCreateWeakMapTable(
target,
/*create*/
false
);
return table !== void 0 ? delete table[this._key] : false;
};
WeakMap2.prototype.clear = function() {
this._key = CreateUniqueKey();
};
return WeakMap2;
}()
);
function CreateUniqueKey() {
var key;
do
key = "@@WeakMap@@" + CreateUUID();
while (HashMap.has(keys, key));
keys[key] = true;
return key;
}
function GetOrCreateWeakMapTable(target, create) {
if (!hasOwn.call(target, rootKey)) {
if (!create)
return void 0;
Object.defineProperty(target, rootKey, { value: HashMap.create() });
}
return target[rootKey];
}
function FillRandomBytes(buffer2, size) {
for (var i = 0; i < size; ++i)
buffer2[i] = Math.random() * 255 | 0;
return buffer2;
}
function GenRandomBytes(size) {
if (typeof Uint8Array === "function") {
var array = new Uint8Array(size);
if (typeof crypto !== "undefined") {
crypto.getRandomValues(array);
} else if (typeof msCrypto !== "undefined") {
msCrypto.getRandomValues(array);
} else {
FillRandomBytes(array, size);
}
return array;
}
return FillRandomBytes(new Array(size), size);
}
function CreateUUID() {
var data2 = GenRandomBytes(UUID_SIZE);
data2[6] = data2[6] & 79 | 64;
data2[8] = data2[8] & 191 | 128;
var result = "";
for (var offset = 0; offset < UUID_SIZE; ++offset) {
var byte = data2[offset];
if (offset === 4 || offset === 6 || offset === 8)
result += "-";
if (byte < 16)
result += "0";
result += byte.toString(16).toLowerCase();
}
return result;
}
}
function MakeDictionary(obj) {
obj.__ = void 0;
delete obj.__;
return obj;
}
});
})(Reflect2 || (Reflect2 = {}));
return _Reflect;
}
require_Reflect();
const ANSI_BACKGROUND_OFFSET = 10;
const wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
const wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
const styles$1 = {
modifier: {
reset: [0, 0],
// 21 isn't widely supported and 22 does the same thing
bold: [1, 22],
dim: [2, 22],
italic: [3, 23],
underline: [4, 24],
overline: [53, 55],
inverse: [7, 27],
hidden: [8, 28],
strikethrough: [9, 29]
},
color: {
black: [30, 39],
red: [31, 39],
green: [32, 39],
yellow: [33, 39],
blue: [34, 39],
magenta: [35, 39],
cyan: [36, 39],
white: [37, 39],
// Bright color
blackBright: [90, 39],
gray: [90, 39],
// Alias of `blackBright`
grey: [90, 39],
// Alias of `blackBright`
redBright: [91, 39],
greenBright: [92, 39],
yellowBright: [93, 39],
blueBright: [94, 39],
magentaBright: [95, 39],
cyanBright: [96, 39],
whiteBright: [97, 39]
},
bgColor: {
bgBlack: [40, 49],
bgRed: [41, 49],
bgGreen: [42, 49],
bgYellow: [43, 49],
bgBlue: [44, 49],
bgMagenta: [45, 49],
bgCyan: [46, 49],
bgWhite: [47, 49],
// Bright color
bgBlackBright: [100, 49],
bgGray: [100, 49],
// Alias of `bgBlackBright`
bgGrey: [100, 49],
// Alias of `bgBlackBright`
bgRedBright: [101, 49],
bgGreenBright: [102, 49],
bgYellowBright: [103, 49],
bgBlueBright: [104, 49],
bgMagentaBright: [105, 49],
bgCyanBright: [106, 49],
bgWhiteBright: [107, 49]
}
};
Object.keys(styles$1.modifier);
const foregroundColorNames = Object.keys(styles$1.color);
const backgroundColorNames = Object.keys(styles$1.bgColor);
[...foregroundColorNames, ...backgroundColorNames];
function assembleStyles() {
const codes = /* @__PURE__ */ new Map();
for (const [groupName, group] of Object.entries(styles$1)) {
for (const [styleName, style] of Object.entries(group)) {
styles$1[styleName] = {
open: `\x1B[${style[0]}m`,
close: `\x1B[${style[1]}m`
};
group[styleName] = styles$1[styleName];
codes.set(style[0], style[1]);
}
Object.defineProperty(styles$1, groupName, {
value: group,
enumerable: false
});
}
Object.defineProperty(styles$1, "codes", {
value: codes,
enumerable: false
});
styles$1.color.close = "\x1B[39m";
styles$1.bgColor.close = "\x1B[49m";
styles$1.color.ansi = wrapAnsi16();
styles$1.color.ansi256 = wrapAnsi256();
styles$1.color.ansi16m = wrapAnsi16m();
styles$1.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
styles$1.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
styles$1.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
Object.defineProperties(styles$1, {
rgbToAnsi256: {
value(red, green, blue) {
if (red === green && green === blue) {
if (red < 8) {
return 16;
}
if (red > 248) {
return 231;
}
return Math.round((red - 8) / 247 * 24) + 232;
}
return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
},
enumerable: false
},
hexToRgb: {
value(hex) {
const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
if (!matches) {
return [0, 0, 0];
}
let [colorString] = matches;
if (colorString.length === 3) {
colorString = [...colorString].map((character) => character + character).join("");
}
const integer = Number.parseInt(colorString, 16);
return [
/* eslint-disable no-bitwise */
integer >> 16 & 255,
integer >> 8 & 255,
integer & 255
/* eslint-enable no-bitwise */
];
},
enumerable: false
},
hexToAnsi256: {
value: (hex) => styles$1.rgbToAnsi256(...styles$1.hexToRgb(hex)),
enumerable: false
},
ansi256ToAnsi: {
value(code) {
if (code < 8) {
return 30 + code;
}
if (code < 16) {
return 90 + (code - 8);
}
let red;
let green;
let blue;
if (code >= 232) {
red = ((code - 232) * 10 + 8) / 255;
green = red;
blue = red;
} else {
code -= 16;
const remainder = code % 36;
red = Math.floor(code / 36) / 5;
green = Math.floor(remainder / 6) / 5;
blue = remainder % 6 / 5;
}
const value = Math.max(red, green, blue) * 2;
if (value === 0) {
return 30;
}
let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
if (value === 2) {
result += 60;
}
return result;
},
enumerable: false
},
rgbToAnsi: {
value: (red, green, blue) => styles$1.ansi256ToAnsi(styles$1.rgbToAnsi256(red, green, blue)),
enumerable: false
},
hexToAnsi: {
value: (hex) => styles$1.ansi256ToAnsi(styles$1.hexToAnsi256(hex)),
enumerable: false
}
});
return styles$1;
}
const ansiStyles = assembleStyles();
const level = (() => {
if (!("navigator" in globalThis)) {
return 0;
}
if (globalThis.navigator.userAgentData) {
const brand = navigator.userAgentData.brands.find(({ brand: brand2 }) => brand2 === "Chromium");
if (brand && brand.version > 93) {
return 3;
}
}
if (/\b(Chrome|Chromium)\//.test(globalThis.navigator.userAgent)) {
return 1;
}
return 0;
})();
const colorSupport = level !== 0 && {
level
};
const supportsColor = {
stdout: colorSupport,
stderr: colorSupport
};
function stringReplaceAll(string, substring, replacer) {
let index2 = string.indexOf(substring);
if (index2 === -1) {
return string;
}
const substringLength = substring.length;
let endIndex = 0;
let returnValue = "";
do {
returnValue += string.slice(endIndex, index2) + substring + replacer;
endIndex = index2 + substringLength;
index2 = string.indexOf(substring, endIndex);
} while (index2 !== -1);
returnValue += string.slice(endIndex);
return returnValue;
}
function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index2) {
let endIndex = 0;
let returnValue = "";
do {
const gotCR = string[index2 - 1] === "\r";
returnValue += string.slice(endIndex, gotCR ? index2 - 1 : index2) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
endIndex = index2 + 1;
index2 = string.indexOf("\n", endIndex);
} while (index2 !== -1);
returnValue += string.slice(endIndex);
return returnValue;
}
const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
const GENERATOR = Symbol("GENERATOR");
const STYLER = Symbol("STYLER");
const IS_EMPTY = Symbol("IS_EMPTY");
const levelMapping = [
"ansi",
"ansi",
"ansi256",
"ansi16m"
];
const styles = /* @__PURE__ */ Object.create(null);
const applyOptions = (object, options = {}) => {
if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
throw new Error("The `level` option should be an integer from 0 to 3");
}
const colorLevel = stdoutColor ? stdoutColor.level : 0;
object.level = options.level === void 0 ? colorLevel : options.level;
};
class Chalk {
constructor(options) {
return chalkFactory(options);
}
}
const chalkFactory = (options) => {
const chalk = (...strings) => strings.join(" ");
applyOptions(chalk, options);
Object.setPrototypeOf(chalk, createChalk.prototype);
return chalk;
};
function createChalk(options) {
return chalkFactory(options);
}
Object.setPrototypeOf(createChalk.prototype, Function.prototype);
for (const [styleName, style] of Object.entries(ansiStyles)) {
styles[styleName] = {
get() {
const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
Object.defineProperty(this, styleName, { value: builder });
return builder;
}
};
}
styles.visible = {
get() {
const builder = createBuilder(this, this[STYLER], true);
Object.defineProperty(this, "visible", { value: builder });
return builder;
}
};
const getModelAnsi = (model, level2, type2, ...arguments_) => {
if (model === "rgb") {
if (level2 === "ansi16m") {
return ansiStyles[type2].ansi16m(...arguments_);
}
if (level2 === "ansi256") {
return ansiStyles[type2].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
}
return ansiStyles[type2].ansi(ansiStyles.rgbToAnsi(...arguments_));
}
if (model === "hex") {
return getModelAnsi("rgb", level2, type2, ...ansiStyles.hexToRgb(...arguments_));
}
return ansiStyles[type2][model](...arguments_);
};
const usedModels = ["rgb", "hex", "ansi256"];
for (const model of usedModels) {
styles[model] = {
get() {
const { level: level2 } = this;
return function(...arguments_) {
const styler = createStyler(getModelAnsi(model, levelMapping[level2], "color", ...arguments_), ansiStyles.color.close, this[STYLER]);
return createBuilder(this, styler, this[IS_EMPTY]);
};
}
};
const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
styles[bgModel] = {
get() {
const { level: level2 } = this;
return function(...arguments_) {
const styler = createStyler(getModelAnsi(model, levelMapping[level2], "bgColor", ...arguments_), ansiStyles.bgColor.close, this[STYLER]);
return createBuilder(this, styler, this[IS_EMPTY]);
};
}
};
}
const proto = Object.defineProperties(() => {
}, {
...styles,
level: {
enumerable: true,
get() {
return this[GENERATOR].level;
},
set(level2) {
this[GENERATOR].level = level2;
}
}
});
const createStyler = (open, close, parent) => {
let openAll;
let closeAll;
if (parent === void 0) {
openAll = open;
closeAll = close;
} else {
openAll = parent.openAll + open;
closeAll = close + parent.closeAll;
}
return {
open,
close,
openAll,
closeAll,
parent
};
};
const createBuilder = (self2, _styler, _isEmpty) => {
const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
Object.setPrototypeOf(builder, proto);
builder[GENERATOR] = self2;
builder[STYLER] = _styler;
builder[IS_EMPTY] = _isEmpty;
return builder;
};
const applyStyle = (self2, string) => {
if (self2.level <= 0 || !string) {
return self2[IS_EMPTY] ? "" : string;
}
let styler = self2[STYLER];
if (styler === void 0) {
return string;
}
const { openAll, closeAll } = styler;
if (string.includes("\x1B")) {
while (styler !== void 0) {
string = stringReplaceAll(string, st