@agixbt/elizascraper
Version:
Awesome Scraper for eliza, scrape docs, tweets, and tokens
1,724 lines (1,671 loc) • 1.39 MB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getProtoOf = Object.getPrototypeOf;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __toESM = (mod, isNodeMode, target) => {
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: () => mod[key],
enumerable: true
});
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __require = (id) => {
return import.meta.require(id);
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: (newValue) => all[name] = () => newValue
});
};
var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
// node_modules/memoirist/dist/index.mjs
var createNode, cloneNode, createParamNode, Memoirist, matchRoute;
var init_dist = __esm(() => {
createNode = (part, inert) => {
const inertMap = inert?.length ? {} : null;
if (inertMap)
for (const child of inert)
inertMap[child.part.charCodeAt(0)] = child;
return {
part,
store: null,
inert: inertMap,
params: null,
wildcardStore: null
};
};
cloneNode = (node, part) => ({
...node,
part
});
createParamNode = (name) => ({
name,
store: null,
inert: null
});
Memoirist = class _Memoirist {
root = {};
history = [];
static regex = {
static: /:.+?(?=\/|$)/,
params: /:.+?(?=\/|$)/g,
optionalParams: /:.+?\?(?=\/|$)/g
};
add(method, path, store, {
ignoreError = false,
ignoreHistory = false
} = {}) {
if (typeof path !== "string")
throw new TypeError("Route path must be a string");
if (path === "")
path = "/";
else if (path[0] !== "/")
path = `/${path}`;
const isWildcard = path[path.length - 1] === "*";
const optionalParams = path.match(_Memoirist.regex.optionalParams);
if (optionalParams) {
const originalPath = path.replaceAll("?", "");
this.add(method, originalPath, store, {
ignoreError
});
for (let i = 0;i < optionalParams.length; i++) {
let newPath = path.replace("/" + optionalParams[i], "");
this.add(method, newPath, store, {
ignoreError: true
});
}
return store;
}
if (optionalParams)
path = path.replaceAll("?", "");
if (this.history.find(([m, p, s]) => m === method && p === path))
return store;
if (isWildcard || optionalParams && path.charCodeAt(path.length - 1) === 63)
path = path.slice(0, -1);
if (!ignoreHistory)
this.history.push([method, path, store]);
const inertParts = path.split(_Memoirist.regex.static);
const paramParts = path.match(_Memoirist.regex.params) || [];
if (inertParts[inertParts.length - 1] === "")
inertParts.pop();
let node;
if (!this.root[method])
node = this.root[method] = createNode("/");
else
node = this.root[method];
let paramPartsIndex = 0;
for (let i = 0;i < inertParts.length; ++i) {
let part = inertParts[i];
if (i > 0) {
const param = paramParts[paramPartsIndex++].slice(1);
if (node.params === null)
node.params = createParamNode(param);
else if (node.params.name !== param) {
if (ignoreError)
return store;
else
throw new Error(`Cannot create route "${path}" with parameter "${param}" because a route already exists with a different parameter name ("${node.params.name}") in the same location`);
}
const params = node.params;
if (params.inert === null) {
node = params.inert = createNode(part);
continue;
}
node = params.inert;
}
for (let j = 0;; ) {
if (j === part.length) {
if (j < node.part.length) {
const childNode = cloneNode(node, node.part.slice(j));
Object.assign(node, createNode(part, [childNode]));
}
break;
}
if (j === node.part.length) {
if (node.inert === null)
node.inert = {};
const inert = node.inert[part.charCodeAt(j)];
if (inert) {
node = inert;
part = part.slice(j);
j = 0;
continue;
}
const childNode = createNode(part.slice(j));
node.inert[part.charCodeAt(j)] = childNode;
node = childNode;
break;
}
if (part[j] !== node.part[j]) {
const existingChild = cloneNode(node, node.part.slice(j));
const newChild = createNode(part.slice(j));
Object.assign(node, createNode(node.part.slice(0, j), [
existingChild,
newChild
]));
node = newChild;
break;
}
++j;
}
}
if (paramPartsIndex < paramParts.length) {
const param = paramParts[paramPartsIndex];
const name = param.slice(1);
if (node.params === null)
node.params = createParamNode(name);
else if (node.params.name !== name) {
if (ignoreError)
return store;
else
throw new Error(`Cannot create route "${path}" with parameter "${name}" because a route already exists with a different parameter name ("${node.params.name}") in the same location`);
}
if (node.params.store === null)
node.params.store = store;
return node.params.store;
}
if (isWildcard) {
if (node.wildcardStore === null)
node.wildcardStore = store;
return node.wildcardStore;
}
if (node.store === null)
node.store = store;
return node.store;
}
find(method, url) {
const root = this.root[method];
if (!root)
return null;
return matchRoute(url, url.length, root, 0);
}
};
matchRoute = (url, urlLength, node, startIndex) => {
const part = node.part;
const length = part.length;
const endIndex = startIndex + length;
if (length > 1) {
if (endIndex > urlLength)
return null;
if (length < 15) {
for (let i = 1, j = startIndex + 1;i < length; ++i, ++j)
if (part.charCodeAt(i) !== url.charCodeAt(j))
return null;
} else if (url.slice(startIndex, endIndex) !== part)
return null;
}
if (endIndex === urlLength) {
if (node.store !== null)
return {
store: node.store,
params: {}
};
if (node.wildcardStore !== null)
return {
store: node.wildcardStore,
params: { "*": "" }
};
return null;
}
if (node.inert !== null) {
const inert = node.inert[url.charCodeAt(endIndex)];
if (inert !== undefined) {
const route = matchRoute(url, urlLength, inert, endIndex);
if (route !== null)
return route;
}
}
if (node.params !== null) {
const { store, name, inert } = node.params;
const slashIndex = url.indexOf("/", endIndex);
if (slashIndex !== endIndex) {
if (slashIndex === -1 || slashIndex >= urlLength) {
if (store !== null) {
const params = {};
params[name] = url.substring(endIndex, urlLength);
return {
store,
params
};
}
} else if (inert !== null) {
const route = matchRoute(url, urlLength, inert, slashIndex);
if (route !== null) {
route.params[name] = url.substring(endIndex, slashIndex);
return route;
}
}
}
}
if (node.wildcardStore !== null)
return {
store: node.wildcardStore,
params: {
"*": url.substring(endIndex, urlLength)
}
};
return null;
};
});
// node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
var exports_value = {};
__export(exports_value, {
IsUndefined: () => {
{
return IsUndefined;
}
},
IsUint8Array: () => {
{
return IsUint8Array;
}
},
IsSymbol: () => {
{
return IsSymbol;
}
},
IsString: () => {
{
return IsString;
}
},
IsRegExp: () => {
{
return IsRegExp;
}
},
IsObject: () => {
{
return IsObject;
}
},
IsNumber: () => {
{
return IsNumber;
}
},
IsNull: () => {
{
return IsNull;
}
},
IsIterator: () => {
{
return IsIterator;
}
},
IsFunction: () => {
{
return IsFunction;
}
},
IsDate: () => {
{
return IsDate;
}
},
IsBoolean: () => {
{
return IsBoolean;
}
},
IsBigInt: () => {
{
return IsBigInt;
}
},
IsAsyncIterator: () => {
{
return IsAsyncIterator;
}
},
IsArray: () => {
{
return IsArray;
}
},
HasPropertyKey: () => {
{
return HasPropertyKey;
}
}
});
function HasPropertyKey(value, key) {
return key in value;
}
function IsAsyncIterator(value) {
return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
}
function IsArray(value) {
return Array.isArray(value);
}
function IsBigInt(value) {
return typeof value === "bigint";
}
function IsBoolean(value) {
return typeof value === "boolean";
}
function IsDate(value) {
return value instanceof globalThis.Date;
}
function IsFunction(value) {
return typeof value === "function";
}
function IsIterator(value) {
return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
}
function IsNull(value) {
return value === null;
}
function IsNumber(value) {
return typeof value === "number";
}
function IsObject(value) {
return typeof value === "object" && value !== null;
}
function IsRegExp(value) {
return value instanceof globalThis.RegExp;
}
function IsString(value) {
return typeof value === "string";
}
function IsSymbol(value) {
return typeof value === "symbol";
}
function IsUint8Array(value) {
return value instanceof globalThis.Uint8Array;
}
function IsUndefined(value) {
return value === undefined;
}
var init_value = __esm(() => {
});
// node_modules/@sinclair/typebox/build/esm/type/clone/value.mjs
function Clone(value) {
return Visit(value);
}
var ArrayType, DateType, Uint8ArrayType, RegExpType, ObjectType, Visit;
var init_value2 = __esm(() => {
init_value();
ArrayType = function(value) {
return value.map((value2) => Visit(value2));
};
DateType = function(value) {
return new Date(value.getTime());
};
Uint8ArrayType = function(value) {
return new Uint8Array(value);
};
RegExpType = function(value) {
return new RegExp(value.source, value.flags);
};
ObjectType = function(value) {
const result = {};
for (const key of Object.getOwnPropertyNames(value)) {
result[key] = Visit(value[key]);
}
for (const key of Object.getOwnPropertySymbols(value)) {
result[key] = Visit(value[key]);
}
return result;
};
Visit = function(value) {
return IsArray(value) ? ArrayType(value) : IsDate(value) ? DateType(value) : IsUint8Array(value) ? Uint8ArrayType(value) : IsRegExp(value) ? RegExpType(value) : IsObject(value) ? ObjectType(value) : value;
};
});
// node_modules/@sinclair/typebox/build/esm/type/clone/type.mjs
function CloneType(schema, options) {
return options === undefined ? Clone(schema) : Clone({ ...options, ...schema });
}
var init_type = __esm(() => {
init_value2();
});
// node_modules/@sinclair/typebox/build/esm/type/clone/index.mjs
var init_clone = __esm(() => {
init_type();
init_value2();
});
// node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs
function IsAsyncIterator2(value3) {
return IsObject2(value3) && globalThis.Symbol.asyncIterator in value3;
}
function IsIterator2(value3) {
return IsObject2(value3) && globalThis.Symbol.iterator in value3;
}
function IsStandardObject(value3) {
return IsObject2(value3) && (globalThis.Object.getPrototypeOf(value3) === Object.prototype || globalThis.Object.getPrototypeOf(value3) === null);
}
function IsPromise(value3) {
return value3 instanceof globalThis.Promise;
}
function IsDate2(value3) {
return value3 instanceof Date && globalThis.Number.isFinite(value3.getTime());
}
function IsMap(value3) {
return value3 instanceof globalThis.Map;
}
function IsSet(value3) {
return value3 instanceof globalThis.Set;
}
function IsTypedArray(value3) {
return globalThis.ArrayBuffer.isView(value3);
}
function IsUint8Array2(value3) {
return value3 instanceof globalThis.Uint8Array;
}
function HasPropertyKey2(value3, key) {
return key in value3;
}
function IsObject2(value3) {
return value3 !== null && typeof value3 === "object";
}
function IsArray2(value3) {
return globalThis.Array.isArray(value3) && !globalThis.ArrayBuffer.isView(value3);
}
function IsUndefined2(value3) {
return value3 === undefined;
}
function IsNull2(value3) {
return value3 === null;
}
function IsBoolean2(value3) {
return typeof value3 === "boolean";
}
function IsNumber2(value3) {
return typeof value3 === "number";
}
function IsInteger(value3) {
return globalThis.Number.isInteger(value3);
}
function IsBigInt2(value3) {
return typeof value3 === "bigint";
}
function IsString2(value3) {
return typeof value3 === "string";
}
function IsFunction2(value3) {
return typeof value3 === "function";
}
function IsSymbol2(value3) {
return typeof value3 === "symbol";
}
function IsValueType(value3) {
return IsBigInt2(value3) || IsBoolean2(value3) || IsNull2(value3) || IsNumber2(value3) || IsString2(value3) || IsSymbol2(value3) || IsUndefined2(value3);
}
var init_guard = __esm(() => {
});
// node_modules/@sinclair/typebox/build/esm/value/guard/index.mjs
var init_guard2 = __esm(() => {
init_guard();
});
// node_modules/@sinclair/typebox/build/esm/system/policy.mjs
var TypeSystemPolicy;
var init_policy = __esm(() => {
init_guard2();
(function(TypeSystemPolicy2) {
TypeSystemPolicy2.InstanceMode = "default";
TypeSystemPolicy2.ExactOptionalPropertyTypes = false;
TypeSystemPolicy2.AllowArrayObject = false;
TypeSystemPolicy2.AllowNaN = false;
TypeSystemPolicy2.AllowNullVoid = false;
function IsExactOptionalProperty(value3, key) {
return TypeSystemPolicy2.ExactOptionalPropertyTypes ? key in value3 : value3[key] !== undefined;
}
TypeSystemPolicy2.IsExactOptionalProperty = IsExactOptionalProperty;
function IsObjectLike(value3) {
const isObject = IsObject2(value3);
return TypeSystemPolicy2.AllowArrayObject ? isObject : isObject && !IsArray2(value3);
}
TypeSystemPolicy2.IsObjectLike = IsObjectLike;
function IsRecordLike(value3) {
return IsObjectLike(value3) && !(value3 instanceof Date) && !(value3 instanceof Uint8Array);
}
TypeSystemPolicy2.IsRecordLike = IsRecordLike;
function IsNumberLike(value3) {
return TypeSystemPolicy2.AllowNaN ? IsNumber2(value3) : Number.isFinite(value3);
}
TypeSystemPolicy2.IsNumberLike = IsNumberLike;
function IsVoidLike(value3) {
const isUndefined = IsUndefined2(value3);
return TypeSystemPolicy2.AllowNullVoid ? isUndefined || value3 === null : isUndefined;
}
TypeSystemPolicy2.IsVoidLike = IsVoidLike;
})(TypeSystemPolicy || (TypeSystemPolicy = {}));
});
// node_modules/@sinclair/typebox/build/esm/type/create/immutable.mjs
function Immutable(value3) {
return IsArray(value3) ? ImmutableArray(value3) : IsDate(value3) ? ImmutableDate(value3) : IsUint8Array(value3) ? ImmutableUint8Array(value3) : IsRegExp(value3) ? ImmutableRegExp(value3) : IsObject(value3) ? ImmutableObject(value3) : value3;
}
var ImmutableArray, ImmutableDate, ImmutableUint8Array, ImmutableRegExp, ImmutableObject;
var init_immutable = __esm(() => {
init_value();
ImmutableArray = function(value3) {
return globalThis.Object.freeze(value3).map((value4) => Immutable(value4));
};
ImmutableDate = function(value3) {
return value3;
};
ImmutableUint8Array = function(value3) {
return value3;
};
ImmutableRegExp = function(value3) {
return value3;
};
ImmutableObject = function(value3) {
const result = {};
for (const key of Object.getOwnPropertyNames(value3)) {
result[key] = Immutable(value3[key]);
}
for (const key of Object.getOwnPropertySymbols(value3)) {
result[key] = Immutable(value3[key]);
}
return globalThis.Object.freeze(result);
};
});
// node_modules/@sinclair/typebox/build/esm/type/create/type.mjs
function CreateType(schema, options) {
const result = options !== undefined ? { ...options, ...schema } : schema;
switch (TypeSystemPolicy.InstanceMode) {
case "freeze":
return Immutable(result);
case "clone":
return Clone(result);
default:
return result;
}
}
var init_type2 = __esm(() => {
init_policy();
init_immutable();
init_value2();
});
// node_modules/@sinclair/typebox/build/esm/type/create/index.mjs
var init_create = __esm(() => {
init_type2();
});
// node_modules/@sinclair/typebox/build/esm/type/error/error.mjs
class TypeBoxError extends Error {
constructor(message) {
super(message);
}
}
var init_error = __esm(() => {
});
// node_modules/@sinclair/typebox/build/esm/type/error/index.mjs
var init_error2 = __esm(() => {
init_error();
});
// node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.mjs
var TransformKind, ReadonlyKind, OptionalKind, Hint, Kind;
var init_symbols = __esm(() => {
TransformKind = Symbol.for("TypeBox.Transform");
ReadonlyKind = Symbol.for("TypeBox.Readonly");
OptionalKind = Symbol.for("TypeBox.Optional");
Hint = Symbol.for("TypeBox.Hint");
Kind = Symbol.for("TypeBox.Kind");
});
// node_modules/@sinclair/typebox/build/esm/type/symbols/index.mjs
var init_symbols2 = __esm(() => {
init_symbols();
});
// node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs
function IsReadonly(value4) {
return IsObject(value4) && value4[ReadonlyKind] === "Readonly";
}
function IsOptional(value4) {
return IsObject(value4) && value4[OptionalKind] === "Optional";
}
function IsAny(value4) {
return IsKindOf(value4, "Any");
}
function IsArray3(value4) {
return IsKindOf(value4, "Array");
}
function IsAsyncIterator3(value4) {
return IsKindOf(value4, "AsyncIterator");
}
function IsBigInt3(value4) {
return IsKindOf(value4, "BigInt");
}
function IsBoolean3(value4) {
return IsKindOf(value4, "Boolean");
}
function IsComputed(value4) {
return IsKindOf(value4, "Computed");
}
function IsConstructor(value4) {
return IsKindOf(value4, "Constructor");
}
function IsDate3(value4) {
return IsKindOf(value4, "Date");
}
function IsFunction3(value4) {
return IsKindOf(value4, "Function");
}
function IsInteger2(value4) {
return IsKindOf(value4, "Integer");
}
function IsIntersect(value4) {
return IsKindOf(value4, "Intersect");
}
function IsIterator3(value4) {
return IsKindOf(value4, "Iterator");
}
function IsKindOf(value4, kind) {
return IsObject(value4) && Kind in value4 && value4[Kind] === kind;
}
function IsLiteralValue(value4) {
return IsBoolean(value4) || IsNumber(value4) || IsString(value4);
}
function IsLiteral(value4) {
return IsKindOf(value4, "Literal");
}
function IsMappedKey(value4) {
return IsKindOf(value4, "MappedKey");
}
function IsMappedResult(value4) {
return IsKindOf(value4, "MappedResult");
}
function IsNever(value4) {
return IsKindOf(value4, "Never");
}
function IsNot(value4) {
return IsKindOf(value4, "Not");
}
function IsNull3(value4) {
return IsKindOf(value4, "Null");
}
function IsNumber3(value4) {
return IsKindOf(value4, "Number");
}
function IsObject3(value4) {
return IsKindOf(value4, "Object");
}
function IsPromise2(value4) {
return IsKindOf(value4, "Promise");
}
function IsRecord(value4) {
return IsKindOf(value4, "Record");
}
function IsRef(value4) {
return IsKindOf(value4, "Ref");
}
function IsRegExp2(value4) {
return IsKindOf(value4, "RegExp");
}
function IsString3(value4) {
return IsKindOf(value4, "String");
}
function IsSymbol3(value4) {
return IsKindOf(value4, "Symbol");
}
function IsTemplateLiteral(value4) {
return IsKindOf(value4, "TemplateLiteral");
}
function IsThis(value4) {
return IsKindOf(value4, "This");
}
function IsTransform(value4) {
return IsObject(value4) && TransformKind in value4;
}
function IsTuple(value4) {
return IsKindOf(value4, "Tuple");
}
function IsUndefined3(value4) {
return IsKindOf(value4, "Undefined");
}
function IsUnion(value4) {
return IsKindOf(value4, "Union");
}
function IsUint8Array3(value4) {
return IsKindOf(value4, "Uint8Array");
}
function IsUnknown(value4) {
return IsKindOf(value4, "Unknown");
}
function IsUnsafe(value4) {
return IsKindOf(value4, "Unsafe");
}
function IsVoid(value4) {
return IsKindOf(value4, "Void");
}
function IsKind(value4) {
return IsObject(value4) && Kind in value4 && IsString(value4[Kind]);
}
function IsSchema(value4) {
return IsAny(value4) || IsArray3(value4) || IsBoolean3(value4) || IsBigInt3(value4) || IsAsyncIterator3(value4) || IsComputed(value4) || IsConstructor(value4) || IsDate3(value4) || IsFunction3(value4) || IsInteger2(value4) || IsIntersect(value4) || IsIterator3(value4) || IsLiteral(value4) || IsMappedKey(value4) || IsMappedResult(value4) || IsNever(value4) || IsNot(value4) || IsNull3(value4) || IsNumber3(value4) || IsObject3(value4) || IsPromise2(value4) || IsRecord(value4) || IsRef(value4) || IsRegExp2(value4) || IsString3(value4) || IsSymbol3(value4) || IsTemplateLiteral(value4) || IsThis(value4) || IsTuple(value4) || IsUndefined3(value4) || IsUnion(value4) || IsUint8Array3(value4) || IsUnknown(value4) || IsUnsafe(value4) || IsVoid(value4) || IsKind(value4);
}
var init_kind = __esm(() => {
init_value();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/guard/type.mjs
var exports_type = {};
__export(exports_type, {
TypeGuardUnknownTypeError: () => {
{
return TypeGuardUnknownTypeError;
}
},
IsVoid: () => {
{
return IsVoid2;
}
},
IsUnsafe: () => {
{
return IsUnsafe2;
}
},
IsUnknown: () => {
{
return IsUnknown2;
}
},
IsUnionLiteral: () => {
{
return IsUnionLiteral;
}
},
IsUnion: () => {
{
return IsUnion2;
}
},
IsUndefined: () => {
{
return IsUndefined4;
}
},
IsUint8Array: () => {
{
return IsUint8Array4;
}
},
IsTuple: () => {
{
return IsTuple2;
}
},
IsTransform: () => {
{
return IsTransform2;
}
},
IsThis: () => {
{
return IsThis2;
}
},
IsTemplateLiteral: () => {
{
return IsTemplateLiteral2;
}
},
IsSymbol: () => {
{
return IsSymbol4;
}
},
IsString: () => {
{
return IsString4;
}
},
IsSchema: () => {
{
return IsSchema2;
}
},
IsRegExp: () => {
{
return IsRegExp3;
}
},
IsRef: () => {
{
return IsRef2;
}
},
IsRecursive: () => {
{
return IsRecursive;
}
},
IsRecord: () => {
{
return IsRecord2;
}
},
IsReadonly: () => {
{
return IsReadonly2;
}
},
IsProperties: () => {
{
return IsProperties;
}
},
IsPromise: () => {
{
return IsPromise3;
}
},
IsOptional: () => {
{
return IsOptional2;
}
},
IsObject: () => {
{
return IsObject4;
}
},
IsNumber: () => {
{
return IsNumber4;
}
},
IsNull: () => {
{
return IsNull4;
}
},
IsNot: () => {
{
return IsNot2;
}
},
IsNever: () => {
{
return IsNever2;
}
},
IsMappedResult: () => {
{
return IsMappedResult2;
}
},
IsMappedKey: () => {
{
return IsMappedKey2;
}
},
IsLiteralValue: () => {
{
return IsLiteralValue2;
}
},
IsLiteralString: () => {
{
return IsLiteralString;
}
},
IsLiteralNumber: () => {
{
return IsLiteralNumber;
}
},
IsLiteralBoolean: () => {
{
return IsLiteralBoolean;
}
},
IsLiteral: () => {
{
return IsLiteral2;
}
},
IsKindOf: () => {
{
return IsKindOf2;
}
},
IsKind: () => {
{
return IsKind2;
}
},
IsIterator: () => {
{
return IsIterator4;
}
},
IsIntersect: () => {
{
return IsIntersect2;
}
},
IsInteger: () => {
{
return IsInteger3;
}
},
IsImport: () => {
{
return IsImport;
}
},
IsFunction: () => {
{
return IsFunction4;
}
},
IsDate: () => {
{
return IsDate4;
}
},
IsConstructor: () => {
{
return IsConstructor2;
}
},
IsComputed: () => {
{
return IsComputed2;
}
},
IsBoolean: () => {
{
return IsBoolean4;
}
},
IsBigInt: () => {
{
return IsBigInt4;
}
},
IsAsyncIterator: () => {
{
return IsAsyncIterator4;
}
},
IsArray: () => {
{
return IsArray4;
}
},
IsAny: () => {
{
return IsAny2;
}
}
});
function IsReadonly2(value4) {
return IsObject(value4) && value4[ReadonlyKind] === "Readonly";
}
function IsOptional2(value4) {
return IsObject(value4) && value4[OptionalKind] === "Optional";
}
function IsAny2(value4) {
return IsKindOf2(value4, "Any") && IsOptionalString(value4.$id);
}
function IsArray4(value4) {
return IsKindOf2(value4, "Array") && value4.type === "array" && IsOptionalString(value4.$id) && IsSchema2(value4.items) && IsOptionalNumber(value4.minItems) && IsOptionalNumber(value4.maxItems) && IsOptionalBoolean(value4.uniqueItems) && IsOptionalSchema(value4.contains) && IsOptionalNumber(value4.minContains) && IsOptionalNumber(value4.maxContains);
}
function IsAsyncIterator4(value4) {
return IsKindOf2(value4, "AsyncIterator") && value4.type === "AsyncIterator" && IsOptionalString(value4.$id) && IsSchema2(value4.items);
}
function IsBigInt4(value4) {
return IsKindOf2(value4, "BigInt") && value4.type === "bigint" && IsOptionalString(value4.$id) && IsOptionalBigInt(value4.exclusiveMaximum) && IsOptionalBigInt(value4.exclusiveMinimum) && IsOptionalBigInt(value4.maximum) && IsOptionalBigInt(value4.minimum) && IsOptionalBigInt(value4.multipleOf);
}
function IsBoolean4(value4) {
return IsKindOf2(value4, "Boolean") && value4.type === "boolean" && IsOptionalString(value4.$id);
}
function IsComputed2(value4) {
return IsKindOf2(value4, "Computed") && IsString(value4.target) && IsArray(value4.parameters) && value4.parameters.every((schema) => IsSchema2(schema));
}
function IsConstructor2(value4) {
return IsKindOf2(value4, "Constructor") && value4.type === "Constructor" && IsOptionalString(value4.$id) && IsArray(value4.parameters) && value4.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value4.returns);
}
function IsDate4(value4) {
return IsKindOf2(value4, "Date") && value4.type === "Date" && IsOptionalString(value4.$id) && IsOptionalNumber(value4.exclusiveMaximumTimestamp) && IsOptionalNumber(value4.exclusiveMinimumTimestamp) && IsOptionalNumber(value4.maximumTimestamp) && IsOptionalNumber(value4.minimumTimestamp) && IsOptionalNumber(value4.multipleOfTimestamp);
}
function IsFunction4(value4) {
return IsKindOf2(value4, "Function") && value4.type === "Function" && IsOptionalString(value4.$id) && IsArray(value4.parameters) && value4.parameters.every((schema) => IsSchema2(schema)) && IsSchema2(value4.returns);
}
function IsImport(value4) {
return IsKindOf2(value4, "Import") && HasPropertyKey(value4, "$defs") && IsObject(value4.$defs) && IsProperties(value4.$defs) && HasPropertyKey(value4, "$ref") && IsString(value4.$ref) && value4.$ref in value4.$defs;
}
function IsInteger3(value4) {
return IsKindOf2(value4, "Integer") && value4.type === "integer" && IsOptionalString(value4.$id) && IsOptionalNumber(value4.exclusiveMaximum) && IsOptionalNumber(value4.exclusiveMinimum) && IsOptionalNumber(value4.maximum) && IsOptionalNumber(value4.minimum) && IsOptionalNumber(value4.multipleOf);
}
function IsProperties(value4) {
return IsObject(value4) && Object.entries(value4).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema2(schema));
}
function IsIntersect2(value4) {
return IsKindOf2(value4, "Intersect") && (IsString(value4.type) && value4.type !== "object" ? false : true) && IsArray(value4.allOf) && value4.allOf.every((schema) => IsSchema2(schema) && !IsTransform2(schema)) && IsOptionalString(value4.type) && (IsOptionalBoolean(value4.unevaluatedProperties) || IsOptionalSchema(value4.unevaluatedProperties)) && IsOptionalString(value4.$id);
}
function IsIterator4(value4) {
return IsKindOf2(value4, "Iterator") && value4.type === "Iterator" && IsOptionalString(value4.$id) && IsSchema2(value4.items);
}
function IsKindOf2(value4, kind) {
return IsObject(value4) && Kind in value4 && value4[Kind] === kind;
}
function IsLiteralString(value4) {
return IsLiteral2(value4) && IsString(value4.const);
}
function IsLiteralNumber(value4) {
return IsLiteral2(value4) && IsNumber(value4.const);
}
function IsLiteralBoolean(value4) {
return IsLiteral2(value4) && IsBoolean(value4.const);
}
function IsLiteral2(value4) {
return IsKindOf2(value4, "Literal") && IsOptionalString(value4.$id) && IsLiteralValue2(value4.const);
}
function IsLiteralValue2(value4) {
return IsBoolean(value4) || IsNumber(value4) || IsString(value4);
}
function IsMappedKey2(value4) {
return IsKindOf2(value4, "MappedKey") && IsArray(value4.keys) && value4.keys.every((key) => IsNumber(key) || IsString(key));
}
function IsMappedResult2(value4) {
return IsKindOf2(value4, "MappedResult") && IsProperties(value4.properties);
}
function IsNever2(value4) {
return IsKindOf2(value4, "Never") && IsObject(value4.not) && Object.getOwnPropertyNames(value4.not).length === 0;
}
function IsNot2(value4) {
return IsKindOf2(value4, "Not") && IsSchema2(value4.not);
}
function IsNull4(value4) {
return IsKindOf2(value4, "Null") && value4.type === "null" && IsOptionalString(value4.$id);
}
function IsNumber4(value4) {
return IsKindOf2(value4, "Number") && value4.type === "number" && IsOptionalString(value4.$id) && IsOptionalNumber(value4.exclusiveMaximum) && IsOptionalNumber(value4.exclusiveMinimum) && IsOptionalNumber(value4.maximum) && IsOptionalNumber(value4.minimum) && IsOptionalNumber(value4.multipleOf);
}
function IsObject4(value4) {
return IsKindOf2(value4, "Object") && value4.type === "object" && IsOptionalString(value4.$id) && IsProperties(value4.properties) && IsAdditionalProperties(value4.additionalProperties) && IsOptionalNumber(value4.minProperties) && IsOptionalNumber(value4.maxProperties);
}
function IsPromise3(value4) {
return IsKindOf2(value4, "Promise") && value4.type === "Promise" && IsOptionalString(value4.$id) && IsSchema2(value4.item);
}
function IsRecord2(value4) {
return IsKindOf2(value4, "Record") && value4.type === "object" && IsOptionalString(value4.$id) && IsAdditionalProperties(value4.additionalProperties) && IsObject(value4.patternProperties) && ((schema) => {
const keys = Object.getOwnPropertyNames(schema.patternProperties);
return keys.length === 1 && IsPattern(keys[0]) && IsObject(schema.patternProperties) && IsSchema2(schema.patternProperties[keys[0]]);
})(value4);
}
function IsRecursive(value4) {
return IsObject(value4) && Hint in value4 && value4[Hint] === "Recursive";
}
function IsRef2(value4) {
return IsKindOf2(value4, "Ref") && IsOptionalString(value4.$id) && IsString(value4.$ref);
}
function IsRegExp3(value4) {
return IsKindOf2(value4, "RegExp") && IsOptionalString(value4.$id) && IsString(value4.source) && IsString(value4.flags) && IsOptionalNumber(value4.maxLength) && IsOptionalNumber(value4.minLength);
}
function IsString4(value4) {
return IsKindOf2(value4, "String") && value4.type === "string" && IsOptionalString(value4.$id) && IsOptionalNumber(value4.minLength) && IsOptionalNumber(value4.maxLength) && IsOptionalPattern(value4.pattern) && IsOptionalFormat(value4.format);
}
function IsSymbol4(value4) {
return IsKindOf2(value4, "Symbol") && value4.type === "symbol" && IsOptionalString(value4.$id);
}
function IsTemplateLiteral2(value4) {
return IsKindOf2(value4, "TemplateLiteral") && value4.type === "string" && IsString(value4.pattern) && value4.pattern[0] === "^" && value4.pattern[value4.pattern.length - 1] === "$";
}
function IsThis2(value4) {
return IsKindOf2(value4, "This") && IsOptionalString(value4.$id) && IsString(value4.$ref);
}
function IsTransform2(value4) {
return IsObject(value4) && TransformKind in value4;
}
function IsTuple2(value4) {
return IsKindOf2(value4, "Tuple") && value4.type === "array" && IsOptionalString(value4.$id) && IsNumber(value4.minItems) && IsNumber(value4.maxItems) && value4.minItems === value4.maxItems && (IsUndefined(value4.items) && IsUndefined(value4.additionalItems) && value4.minItems === 0 || IsArray(value4.items) && value4.items.every((schema) => IsSchema2(schema)));
}
function IsUndefined4(value4) {
return IsKindOf2(value4, "Undefined") && value4.type === "undefined" && IsOptionalString(value4.$id);
}
function IsUnionLiteral(value4) {
return IsUnion2(value4) && value4.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
}
function IsUnion2(value4) {
return IsKindOf2(value4, "Union") && IsOptionalString(value4.$id) && IsObject(value4) && IsArray(value4.anyOf) && value4.anyOf.every((schema) => IsSchema2(schema));
}
function IsUint8Array4(value4) {
return IsKindOf2(value4, "Uint8Array") && value4.type === "Uint8Array" && IsOptionalString(value4.$id) && IsOptionalNumber(value4.minByteLength) && IsOptionalNumber(value4.maxByteLength);
}
function IsUnknown2(value4) {
return IsKindOf2(value4, "Unknown") && IsOptionalString(value4.$id);
}
function IsUnsafe2(value4) {
return IsKindOf2(value4, "Unsafe");
}
function IsVoid2(value4) {
return IsKindOf2(value4, "Void") && value4.type === "void" && IsOptionalString(value4.$id);
}
function IsKind2(value4) {
return IsObject(value4) && Kind in value4 && IsString(value4[Kind]) && !KnownTypes.includes(value4[Kind]);
}
function IsSchema2(value4) {
return IsObject(value4) && (IsAny2(value4) || IsArray4(value4) || IsBoolean4(value4) || IsBigInt4(value4) || IsAsyncIterator4(value4) || IsComputed2(value4) || IsConstructor2(value4) || IsDate4(value4) || IsFunction4(value4) || IsInteger3(value4) || IsIntersect2(value4) || IsIterator4(value4) || IsLiteral2(value4) || IsMappedKey2(value4) || IsMappedResult2(value4) || IsNever2(value4) || IsNot2(value4) || IsNull4(value4) || IsNumber4(value4) || IsObject4(value4) || IsPromise3(value4) || IsRecord2(value4) || IsRef2(value4) || IsRegExp3(value4) || IsString4(value4) || IsSymbol4(value4) || IsTemplateLiteral2(value4) || IsThis2(value4) || IsTuple2(value4) || IsUndefined4(value4) || IsUnion2(value4) || IsUint8Array4(value4) || IsUnknown2(value4) || IsUnsafe2(value4) || IsVoid2(value4) || IsKind2(value4));
}
class TypeGuardUnknownTypeError extends TypeBoxError {
}
var IsPattern, IsControlCharacterFree, IsAdditionalProperties, IsOptionalBigInt, IsOptionalNumber, IsOptionalBoolean, IsOptionalString, IsOptionalPattern, IsOptionalFormat, IsOptionalSchema, KnownTypes;
var init_type3 = __esm(() => {
init_value();
init_symbols2();
init_error2();
IsPattern = function(value4) {
try {
new RegExp(value4);
return true;
} catch {
return false;
}
};
IsControlCharacterFree = function(value4) {
if (!IsString(value4))
return false;
for (let i = 0;i < value4.length; i++) {
const code = value4.charCodeAt(i);
if (code >= 7 && code <= 13 || code === 27 || code === 127) {
return false;
}
}
return true;
};
IsAdditionalProperties = function(value4) {
return IsOptionalBoolean(value4) || IsSchema2(value4);
};
IsOptionalBigInt = function(value4) {
return IsUndefined(value4) || IsBigInt(value4);
};
IsOptionalNumber = function(value4) {
return IsUndefined(value4) || IsNumber(value4);
};
IsOptionalBoolean = function(value4) {
return IsUndefined(value4) || IsBoolean(value4);
};
IsOptionalString = function(value4) {
return IsUndefined(value4) || IsString(value4);
};
IsOptionalPattern = function(value4) {
return IsUndefined(value4) || IsString(value4) && IsControlCharacterFree(value4) && IsPattern(value4);
};
IsOptionalFormat = function(value4) {
return IsUndefined(value4) || IsString(value4) && IsControlCharacterFree(value4);
};
IsOptionalSchema = function(value4) {
return IsUndefined(value4) || IsSchema2(value4);
};
KnownTypes = [
"Any",
"Array",
"AsyncIterator",
"BigInt",
"Boolean",
"Computed",
"Constructor",
"Date",
"Enum",
"Function",
"Integer",
"Intersect",
"Iterator",
"Literal",
"MappedKey",
"MappedResult",
"Not",
"Null",
"Number",
"Object",
"Promise",
"Record",
"Ref",
"RegExp",
"String",
"Symbol",
"TemplateLiteral",
"This",
"Tuple",
"Undefined",
"Union",
"Uint8Array",
"Unknown",
"Void"
];
});
// node_modules/@sinclair/typebox/build/esm/type/guard/index.mjs
var init_guard3 = __esm(() => {
init_kind();
init_type3();
init_value();
});
// node_modules/@sinclair/typebox/build/esm/type/helpers/helpers.mjs
var init_helpers = __esm(() => {
});
// node_modules/@sinclair/typebox/build/esm/type/helpers/index.mjs
var init_helpers2 = __esm(() => {
init_helpers();
});
// node_modules/@sinclair/typebox/build/esm/type/patterns/patterns.mjs
var PatternBoolean, PatternNumber, PatternString, PatternNever, PatternBooleanExact, PatternNumberExact, PatternStringExact, PatternNeverExact;
var init_patterns = __esm(() => {
PatternBoolean = "(true|false)";
PatternNumber = "(0|[1-9][0-9]*)";
PatternString = "(.*)";
PatternNever = "(?!.*)";
PatternBooleanExact = `^${PatternBoolean}\$`;
PatternNumberExact = `^${PatternNumber}\$`;
PatternStringExact = `^${PatternString}\$`;
PatternNeverExact = `^${PatternNever}\$`;
});
// node_modules/@sinclair/typebox/build/esm/type/patterns/index.mjs
var init_patterns2 = __esm(() => {
init_patterns();
});
// node_modules/@sinclair/typebox/build/esm/type/registry/format.mjs
var exports_format = {};
__export(exports_format, {
Set: () => {
{
return Set2;
}
},
Has: () => {
{
return Has;
}
},
Get: () => {
{
return Get;
}
},
Entries: () => {
{
return Entries;
}
},
Delete: () => {
{
return Delete;
}
},
Clear: () => {
{
return Clear;
}
}
});
function Entries() {
return new Map(map);
}
function Clear() {
return map.clear();
}
function Delete(format) {
return map.delete(format);
}
function Has(format) {
return map.has(format);
}
function Set2(format, func) {
map.set(format, func);
}
function Get(format) {
return map.get(format);
}
var map;
var init_format = __esm(() => {
map = new Map;
});
// node_modules/@sinclair/typebox/build/esm/type/registry/type.mjs
var exports_type2 = {};
__export(exports_type2, {
Set: () => {
{
return Set3;
}
},
Has: () => {
{
return Has2;
}
},
Get: () => {
{
return Get2;
}
},
Entries: () => {
{
return Entries2;
}
},
Delete: () => {
{
return Delete2;
}
},
Clear: () => {
{
return Clear2;
}
}
});
function Entries2() {
return new Map(map2);
}
function Clear2() {
return map2.clear();
}
function Delete2(kind) {
return map2.delete(kind);
}
function Has2(kind) {
return map2.has(kind);
}
function Set3(kind, func) {
map2.set(kind, func);
}
function Get2(kind) {
return map2.get(kind);
}
var map2;
var init_type4 = __esm(() => {
map2 = new Map;
});
// node_modules/@sinclair/typebox/build/esm/type/registry/index.mjs
var init_registry = __esm(() => {
init_format();
init_type4();
});
// node_modules/@sinclair/typebox/build/esm/type/sets/set.mjs
function SetIncludes(T, S) {
return T.includes(S);
}
function SetDistinct(T) {
return [...new Set(T)];
}
function SetIntersect(T, S) {
return T.filter((L) => S.includes(L));
}
function SetIntersectMany(T) {
return T.length === 1 ? T[0] : T.length > 1 ? SetIntersectManyResolve(T.slice(1), T[0]) : [];
}
function SetUnionMany(T) {
const Acc = [];
for (const L of T)
Acc.push(...L);
return Acc;
}
var SetIntersectManyResolve;
var init_set = __esm(() => {
SetIntersectManyResolve = function(T, Init) {
return T.reduce((Acc, L) => {
return SetIntersect(Acc, L);
}, Init);
};
});
// node_modules/@sinclair/typebox/build/esm/type/sets/index.mjs
var init_sets = __esm(() => {
init_set();
});
// node_modules/@sinclair/typebox/build/esm/type/any/any.mjs
function Any(options) {
return CreateType({ [Kind]: "Any" }, options);
}
var init_any = __esm(() => {
init_create();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/any/index.mjs
var init_any2 = __esm(() => {
init_any();
});
// node_modules/@sinclair/typebox/build/esm/type/array/array.mjs
function Array2(items, options) {
return CreateType({ [Kind]: "Array", type: "array", items }, options);
}
var init_array = __esm(() => {
init_type2();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/array/index.mjs
var init_array2 = __esm(() => {
init_array();
});
// node_modules/@sinclair/typebox/build/esm/type/async-iterator/async-iterator.mjs
function AsyncIterator(items, options) {
return CreateType({ [Kind]: "AsyncIterator", type: "AsyncIterator", items }, options);
}
var init_async_iterator = __esm(() => {
init_symbols2();
init_type2();
});
// node_modules/@sinclair/typebox/build/esm/type/async-iterator/index.mjs
var init_async_iterator2 = __esm(() => {
init_async_iterator();
});
// node_modules/@sinclair/typebox/build/esm/type/computed/computed.mjs
function Computed(target, parameters, options) {
return CreateType({ [Kind]: "Computed", target, parameters }, options);
}
var init_computed = __esm(() => {
init_create();
init_symbols();
});
// node_modules/@sinclair/typebox/build/esm/type/computed/index.mjs
var init_computed2 = __esm(() => {
init_computed();
});
// node_modules/@sinclair/typebox/build/esm/type/discard/discard.mjs
function Discard(value4, keys) {
return keys.reduce((acc, key) => DiscardKey(acc, key), value4);
}
var DiscardKey;
var init_discard = __esm(() => {
DiscardKey = function(value4, key) {
const { [key]: _, ...rest } = value4;
return rest;
};
});
// node_modules/@sinclair/typebox/build/esm/type/discard/index.mjs
var init_discard2 = __esm(() => {
init_discard();
});
// node_modules/@sinclair/typebox/build/esm/type/never/never.mjs
function Never(options) {
return CreateType({ [Kind]: "Never", not: {} }, options);
}
var init_never = __esm(() => {
init_type2();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/never/index.mjs
var init_never2 = __esm(() => {
init_never();
});
// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-key.mjs
var init_mapped_key = __esm(() => {
});
// node_modules/@sinclair/typebox/build/esm/type/mapped/mapped-result.mjs
function MappedResult(properties) {
return CreateType({
[Kind]: "MappedResult",
properties
});
}
var init_mapped_result = __esm(() => {
init_type2();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/constructor/constructor.mjs
function Constructor(parameters, returns, options) {
return CreateType({ [Kind]: "Constructor", type: "Constructor", parameters, returns }, options);
}
var init_constructor = __esm(() => {
init_type2();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/constructor/index.mjs
var init_constructor2 = __esm(() => {
init_constructor();
});
// node_modules/@sinclair/typebox/build/esm/type/function/function.mjs
function Function2(parameters, returns, options) {
return CreateType({ [Kind]: "Function", type: "Function", parameters, returns }, options);
}
var init_function = __esm(() => {
init_type2();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/function/index.mjs
var init_function2 = __esm(() => {
init_function();
});
// node_modules/@sinclair/typebox/build/esm/type/union/union-create.mjs
function UnionCreate(T, options) {
return CreateType({ [Kind]: "Union", anyOf: T }, options);
}
var init_union_create = __esm(() => {
init_type2();
init_symbols2();
});
// node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.mjs
function UnionEvaluated(T, options) {
return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
}
var IsUnionOptional, RemoveOptionalFromRest, RemoveOptionalFromType, ResolveUnion;
var init_union_evaluated = __esm(() => {
init_type2();
init_symbols2();
init_discard2();
init_never2();
init_optional2();
init_union_create();
init_kind();
IsUnionOptional = function(types) {
return types.some((type11) => IsOptional(type11));
};
RemoveOptionalFromRest = function(types) {
return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
};
RemoveOptionalFromType = function(T) {
return Discard(T, [OptionalKind]);
};
ResolveUnion = function(types, options) {
const isOptional = IsUnionOptional(types);
return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
};
});
// node_modules/@sinclair/typebox/build/esm/type/union/union-type.mjs
var init_union_type = __esm(() => {
});
// node_modules/@sinclair/typebox/build/esm/type/union/union.mjs
function Union(types, options) {
return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
}
var init_union = __esm(() => {
init_never2();
init_type2();
init_union_create();
});
// node_modules/@sinclair/typebox/build/esm/type/union/index.mjs
var init_union2 = __esm(() => {
init_union_evaluated();
init_union_type();
init_union();
});
// node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.mjs
function TemplateLiteralParse(pattern) {
return IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) : IsPrecedenceOr(pattern) ? Or(pattern) : IsPrecedenceAnd(pattern) ? And(pattern) : { type: "const", const: Unescape(pattern) };
}
function TemplateLiteralParseExact(pattern) {
return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
}
class TemplateLiteralParserError extends TypeBoxError {
}
var Unescape, IsNonEscaped, IsOpenParen, IsCloseParen, IsSeparator, IsGroup, InGroup, IsPrecedenceOr, IsPrecedenceAnd, Or, And;
var init_parse = __esm(() => {
init_error2();
Unescape = function(pattern) {
return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
};
IsNonEscaped = function(pattern, index, char) {
return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
};
IsOpenParen = function(pattern, index) {
return IsNonEscaped(pattern, index, "(");
};
IsCloseParen = function(pattern, index) {
return IsNonEscaped(pattern, index, ")");
};
IsSeparator = function(pattern, index) {
return IsNonEscaped(pattern, index, "|");
};
IsGroup = function(pattern) {
if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
return false;
let count = 0;
for (let index = 0;index < pattern.length; index++) {
if (IsOpenParen(pattern, index))
count += 1;
if (IsCloseParen(pattern, index))
count -= 1;
if (count === 0 && index !== pattern.length - 1)
return false;
}
return true;
};
InGroup = function(pattern) {
return pattern.slice(1, pattern.length - 1);
};
IsPrecedenceOr = function(pattern) {
let count = 0;
for (let index = 0;index < pattern.length; index++) {
if (IsOpenParen(pattern, index))
count += 1;
if (IsCloseParen(pattern, index))
count -= 1;
if (IsSeparator(pattern, index) && count === 0)
return true;
}
return false;
};
IsPrecedenceAnd = function(pattern) {
for (let index = 0;index < pattern.length; index++) {
if (IsOpenParen(pattern, index))
return true;
}
return false;
};
Or = function(pattern) {
let [count, start] = [0, 0];
const expressions = [];
for (let index = 0;index < pattern.length; index++) {
if (IsOpenParen(pattern, index))
count += 1;
if (IsCloseParen(pattern, index))
count -= 1;
if (IsSeparator(pattern, index) && count === 0) {
const range2 = pattern.slice(start, index);
if (range2.length > 0)
expressions.push(TemplateLiteralParse(range2));
start = index + 1;
}
}
const range = pattern.slice(start);
if (range.length > 0)
expressions.push(TemplateLiteralParse(range));
if (expressions.length === 0)
return { type: "const", const: "" };
if (expressions.length === 1)
ret