@wecode-ai/weibo-openclaw-plugin 1.0.0 → 1.0.2

package/node_modules/@sinclair/typebox/build/cjs/errors/function.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultErrorFunction = DefaultErrorFunction;
+exports.SetErrorFunction = SetErrorFunction;
+exports.GetErrorFunction = GetErrorFunction;
+const index_1 = require("../type/symbols/index");
+const errors_1 = require("./errors");
+/** Creates an error message using en-US as the default locale */
+function DefaultErrorFunction(error) {
+    switch (error.errorType) {
+        case errors_1.ValueErrorType.ArrayContains:
+            return 'Expected array to contain at least one matching value';
+        case errors_1.ValueErrorType.ArrayMaxContains:
+            return `Expected array to contain no more than ${error.schema.maxContains} matching values`;
+        case errors_1.ValueErrorType.ArrayMinContains:
+            return `Expected array to contain at least ${error.schema.minContains} matching values`;
+        case errors_1.ValueErrorType.ArrayMaxItems:
+            return `Expected array length to be less or equal to ${error.schema.maxItems}`;
+        case errors_1.ValueErrorType.ArrayMinItems:
+            return `Expected array length to be greater or equal to ${error.schema.minItems}`;
+        case errors_1.ValueErrorType.ArrayUniqueItems:
+            return 'Expected array elements to be unique';
+        case errors_1.ValueErrorType.Array:
+            return 'Expected array';
+        case errors_1.ValueErrorType.AsyncIterator:
+            return 'Expected AsyncIterator';
+        case errors_1.ValueErrorType.BigIntExclusiveMaximum:
+            return `Expected bigint to be less than ${error.schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.BigIntExclusiveMinimum:
+            return `Expected bigint to be greater than ${error.schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.BigIntMaximum:
+            return `Expected bigint to be less or equal to ${error.schema.maximum}`;
+        case errors_1.ValueErrorType.BigIntMinimum:
+            return `Expected bigint to be greater or equal to ${error.schema.minimum}`;
+        case errors_1.ValueErrorType.BigIntMultipleOf:
+            return `Expected bigint to be a multiple of ${error.schema.multipleOf}`;
+        case errors_1.ValueErrorType.BigInt:
+            return 'Expected bigint';
+        case errors_1.ValueErrorType.Boolean:
+            return 'Expected boolean';
+        case errors_1.ValueErrorType.DateExclusiveMinimumTimestamp:
+            return `Expected Date timestamp to be greater than ${error.schema.exclusiveMinimumTimestamp}`;
+        case errors_1.ValueErrorType.DateExclusiveMaximumTimestamp:
+            return `Expected Date timestamp to be less than ${error.schema.exclusiveMaximumTimestamp}`;
+        case errors_1.ValueErrorType.DateMinimumTimestamp:
+            return `Expected Date timestamp to be greater or equal to ${error.schema.minimumTimestamp}`;
+        case errors_1.ValueErrorType.DateMaximumTimestamp:
+            return `Expected Date timestamp to be less or equal to ${error.schema.maximumTimestamp}`;
+        case errors_1.ValueErrorType.DateMultipleOfTimestamp:
+            return `Expected Date timestamp to be a multiple of ${error.schema.multipleOfTimestamp}`;
+        case errors_1.ValueErrorType.Date:
+            return 'Expected Date';
+        case errors_1.ValueErrorType.Function:
+            return 'Expected function';
+        case errors_1.ValueErrorType.IntegerExclusiveMaximum:
+            return `Expected integer to be less than ${error.schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.IntegerExclusiveMinimum:
+            return `Expected integer to be greater than ${error.schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.IntegerMaximum:
+            return `Expected integer to be less or equal to ${error.schema.maximum}`;
+        case errors_1.ValueErrorType.IntegerMinimum:
+            return `Expected integer to be greater or equal to ${error.schema.minimum}`;
+        case errors_1.ValueErrorType.IntegerMultipleOf:
+            return `Expected integer to be a multiple of ${error.schema.multipleOf}`;
+        case errors_1.ValueErrorType.Integer:
+            return 'Expected integer';
+        case errors_1.ValueErrorType.IntersectUnevaluatedProperties:
+            return 'Unexpected property';
+        case errors_1.ValueErrorType.Intersect:
+            return 'Expected all values to match';
+        case errors_1.ValueErrorType.Iterator:
+            return 'Expected Iterator';
+        case errors_1.ValueErrorType.Literal:
+            return `Expected ${typeof error.schema.const === 'string' ? `'${error.schema.const}'` : error.schema.const}`;
+        case errors_1.ValueErrorType.Never:
+            return 'Never';
+        case errors_1.ValueErrorType.Not:
+            return 'Value should not match';
+        case errors_1.ValueErrorType.Null:
+            return 'Expected null';
+        case errors_1.ValueErrorType.NumberExclusiveMaximum:
+            return `Expected number to be less than ${error.schema.exclusiveMaximum}`;
+        case errors_1.ValueErrorType.NumberExclusiveMinimum:
+            return `Expected number to be greater than ${error.schema.exclusiveMinimum}`;
+        case errors_1.ValueErrorType.NumberMaximum:
+            return `Expected number to be less or equal to ${error.schema.maximum}`;
+        case errors_1.ValueErrorType.NumberMinimum:
+            return `Expected number to be greater or equal to ${error.schema.minimum}`;
+        case errors_1.ValueErrorType.NumberMultipleOf:
+            return `Expected number to be a multiple of ${error.schema.multipleOf}`;
+        case errors_1.ValueErrorType.Number:
+            return 'Expected number';
+        case errors_1.ValueErrorType.Object:
+            return 'Expected object';
+        case errors_1.ValueErrorType.ObjectAdditionalProperties:
+            return 'Unexpected property';
+        case errors_1.ValueErrorType.ObjectMaxProperties:
+            return `Expected object to have no more than ${error.schema.maxProperties} properties`;
+        case errors_1.ValueErrorType.ObjectMinProperties:
+            return `Expected object to have at least ${error.schema.minProperties} properties`;
+        case errors_1.ValueErrorType.ObjectRequiredProperty:
+            return 'Expected required property';
+        case errors_1.ValueErrorType.Promise:
+            return 'Expected Promise';
+        case errors_1.ValueErrorType.RegExp:
+            return 'Expected string to match regular expression';
+        case errors_1.ValueErrorType.StringFormatUnknown:
+            return `Unknown format '${error.schema.format}'`;
+        case errors_1.ValueErrorType.StringFormat:
+            return `Expected string to match '${error.schema.format}' format`;
+        case errors_1.ValueErrorType.StringMaxLength:
+            return `Expected string length less or equal to ${error.schema.maxLength}`;
+        case errors_1.ValueErrorType.StringMinLength:
+            return `Expected string length greater or equal to ${error.schema.minLength}`;
+        case errors_1.ValueErrorType.StringPattern:
+            return `Expected string to match '${error.schema.pattern}'`;
+        case errors_1.ValueErrorType.String:
+            return 'Expected string';
+        case errors_1.ValueErrorType.Symbol:
+            return 'Expected symbol';
+        case errors_1.ValueErrorType.TupleLength:
+            return `Expected tuple to have ${error.schema.maxItems || 0} elements`;
+        case errors_1.ValueErrorType.Tuple:
+            return 'Expected tuple';
+        case errors_1.ValueErrorType.Uint8ArrayMaxByteLength:
+            return `Expected byte length less or equal to ${error.schema.maxByteLength}`;
+        case errors_1.ValueErrorType.Uint8ArrayMinByteLength:
+            return `Expected byte length greater or equal to ${error.schema.minByteLength}`;
+        case errors_1.ValueErrorType.Uint8Array:
+            return 'Expected Uint8Array';
+        case errors_1.ValueErrorType.Undefined:
+            return 'Expected undefined';
+        case errors_1.ValueErrorType.Union:
+            return 'Expected union value';
+        case errors_1.ValueErrorType.Void:
+            return 'Expected void';
+        case errors_1.ValueErrorType.Kind:
+            return `Expected kind '${error.schema[index_1.Kind]}'`;
+        default:
+            return 'Unknown error type';
+    }
+}
+/** Manages error message providers */
+let errorFunction = DefaultErrorFunction;
+/** Sets the error function used to generate error messages. */
+function SetErrorFunction(callback) {
+    errorFunction = callback;
+}
+/** Gets the error function used to generate error messages */
+function GetErrorFunction() {
+    return errorFunction;
+}

package/node_modules/@sinclair/typebox/build/cjs/errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './errors';
+export * from './function';

package/node_modules/@sinclair/typebox/build/cjs/errors/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./errors"), exports);
+__exportStar(require("./function"), exports);

package/node_modules/@sinclair/typebox/build/cjs/index.d.ts

@@ -0,0 +1,71 @@
+export * from './type/clone/index';
+export * from './type/create/index';
+export * from './type/error/index';
+export * from './type/guard/index';
+export * from './type/helpers/index';
+export * from './type/patterns/index';
+export * from './type/registry/index';
+export * from './type/sets/index';
+export * from './type/symbols/index';
+export * from './type/any/index';
+export * from './type/array/index';
+export * from './type/argument/index';
+export * from './type/async-iterator/index';
+export * from './type/awaited/index';
+export * from './type/bigint/index';
+export * from './type/boolean/index';
+export * from './type/composite/index';
+export * from './type/const/index';
+export * from './type/constructor/index';
+export * from './type/constructor-parameters/index';
+export * from './type/date/index';
+export * from './type/enum/index';
+export * from './type/exclude/index';
+export * from './type/extends/index';
+export * from './type/extract/index';
+export * from './type/function/index';
+export * from './type/indexed/index';
+export * from './type/instance-type/index';
+export * from './type/instantiate/index';
+export * from './type/integer/index';
+export * from './type/intersect/index';
+export * from './type/iterator/index';
+export * from './type/intrinsic/index';
+export * from './type/keyof/index';
+export * from './type/literal/index';
+export * from './type/module/index';
+export * from './type/mapped/index';
+export * from './type/never/index';
+export * from './type/not/index';
+export * from './type/null/index';
+export * from './type/number/index';
+export * from './type/object/index';
+export * from './type/omit/index';
+export * from './type/optional/index';
+export * from './type/parameters/index';
+export * from './type/partial/index';
+export * from './type/pick/index';
+export * from './type/promise/index';
+export * from './type/readonly/index';
+export * from './type/readonly-optional/index';
+export * from './type/record/index';
+export * from './type/recursive/index';
+export * from './type/ref/index';
+export * from './type/regexp/index';
+export * from './type/required/index';
+export * from './type/rest/index';
+export * from './type/return-type/index';
+export * from './type/schema/index';
+export * from './type/static/index';
+export * from './type/string/index';
+export * from './type/symbol/index';
+export * from './type/template-literal/index';
+export * from './type/transform/index';
+export * from './type/tuple/index';
+export * from './type/uint8array/index';
+export * from './type/undefined/index';
+export * from './type/union/index';
+export * from './type/unknown/index';
+export * from './type/unsafe/index';
+export * from './type/void/index';
+export * from './type/type/index';

package/node_modules/@sinclair/typebox/build/cjs/index.js

@@ -0,0 +1,97 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// ------------------------------------------------------------------
+// Infrastructure
+// ------------------------------------------------------------------
+__exportStar(require("./type/clone/index"), exports);
+__exportStar(require("./type/create/index"), exports);
+__exportStar(require("./type/error/index"), exports);
+__exportStar(require("./type/guard/index"), exports);
+__exportStar(require("./type/helpers/index"), exports);
+__exportStar(require("./type/patterns/index"), exports);
+__exportStar(require("./type/registry/index"), exports);
+__exportStar(require("./type/sets/index"), exports);
+__exportStar(require("./type/symbols/index"), exports);
+// ------------------------------------------------------------------
+// Types
+// ------------------------------------------------------------------
+__exportStar(require("./type/any/index"), exports);
+__exportStar(require("./type/array/index"), exports);
+__exportStar(require("./type/argument/index"), exports);
+__exportStar(require("./type/async-iterator/index"), exports);
+__exportStar(require("./type/awaited/index"), exports);
+__exportStar(require("./type/bigint/index"), exports);
+__exportStar(require("./type/boolean/index"), exports);
+__exportStar(require("./type/composite/index"), exports);
+__exportStar(require("./type/const/index"), exports);
+__exportStar(require("./type/constructor/index"), exports);
+__exportStar(require("./type/constructor-parameters/index"), exports);
+__exportStar(require("./type/date/index"), exports);
+__exportStar(require("./type/enum/index"), exports);
+__exportStar(require("./type/exclude/index"), exports);
+__exportStar(require("./type/extends/index"), exports);
+__exportStar(require("./type/extract/index"), exports);
+__exportStar(require("./type/function/index"), exports);
+__exportStar(require("./type/indexed/index"), exports);
+__exportStar(require("./type/instance-type/index"), exports);
+__exportStar(require("./type/instantiate/index"), exports);
+__exportStar(require("./type/integer/index"), exports);
+__exportStar(require("./type/intersect/index"), exports);
+__exportStar(require("./type/iterator/index"), exports);
+__exportStar(require("./type/intrinsic/index"), exports);
+__exportStar(require("./type/keyof/index"), exports);
+__exportStar(require("./type/literal/index"), exports);
+__exportStar(require("./type/module/index"), exports);
+__exportStar(require("./type/mapped/index"), exports);
+__exportStar(require("./type/never/index"), exports);
+__exportStar(require("./type/not/index"), exports);
+__exportStar(require("./type/null/index"), exports);
+__exportStar(require("./type/number/index"), exports);
+__exportStar(require("./type/object/index"), exports);
+__exportStar(require("./type/omit/index"), exports);
+__exportStar(require("./type/optional/index"), exports);
+__exportStar(require("./type/parameters/index"), exports);
+__exportStar(require("./type/partial/index"), exports);
+__exportStar(require("./type/pick/index"), exports);
+__exportStar(require("./type/promise/index"), exports);
+__exportStar(require("./type/readonly/index"), exports);
+__exportStar(require("./type/readonly-optional/index"), exports);
+__exportStar(require("./type/record/index"), exports);
+__exportStar(require("./type/recursive/index"), exports);
+__exportStar(require("./type/ref/index"), exports);
+__exportStar(require("./type/regexp/index"), exports);
+__exportStar(require("./type/required/index"), exports);
+__exportStar(require("./type/rest/index"), exports);
+__exportStar(require("./type/return-type/index"), exports);
+__exportStar(require("./type/schema/index"), exports);
+__exportStar(require("./type/static/index"), exports);
+__exportStar(require("./type/string/index"), exports);
+__exportStar(require("./type/symbol/index"), exports);
+__exportStar(require("./type/template-literal/index"), exports);
+__exportStar(require("./type/transform/index"), exports);
+__exportStar(require("./type/tuple/index"), exports);
+__exportStar(require("./type/uint8array/index"), exports);
+__exportStar(require("./type/undefined/index"), exports);
+__exportStar(require("./type/union/index"), exports);
+__exportStar(require("./type/unknown/index"), exports);
+__exportStar(require("./type/unsafe/index"), exports);
+__exportStar(require("./type/void/index"), exports);
+// ------------------------------------------------------------------
+// Type.*
+// ------------------------------------------------------------------
+__exportStar(require("./type/type/index"), exports);

package/node_modules/@sinclair/typebox/build/cjs/parser/index.d.ts

@@ -0,0 +1,2 @@
+export * as Runtime from './runtime/index';
+export * as Static from './static/index';

package/node_modules/@sinclair/typebox/build/cjs/parser/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Static = exports.Runtime = void 0;
+exports.Runtime = __importStar(require("./runtime/index"));
+exports.Static = __importStar(require("./static/index"));

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/guard.d.ts

@@ -0,0 +1,23 @@
+import { IArray, IConst, IContext, IIdent, INumber, IOptional, IRef, IString, ITuple, IUnion } from './types';
+/** Returns true if the value is a Array Parser */
+export declare function IsArray(value: unknown): value is IArray;
+/** Returns true if the value is a Const Parser */
+export declare function IsConst(value: unknown): value is IConst;
+/** Returns true if the value is a Context Parser */
+export declare function IsContext(value: unknown): value is IContext;
+/** Returns true if the value is a Ident Parser */
+export declare function IsIdent(value: unknown): value is IIdent;
+/** Returns true if the value is a Number Parser */
+export declare function IsNumber(value: unknown): value is INumber;
+/** Returns true if the value is a Optional Parser */
+export declare function IsOptional(value: unknown): value is IOptional;
+/** Returns true if the value is a Ref Parser */
+export declare function IsRef(value: unknown): value is IRef;
+/** Returns true if the value is a String Parser */
+export declare function IsString(value: unknown): value is IString;
+/** Returns true if the value is a Tuple Parser */
+export declare function IsTuple(value: unknown): value is ITuple;
+/** Returns true if the value is a Union Parser */
+export declare function IsUnion(value: unknown): value is IUnion;
+/** Returns true if the value is a Parser */
+export declare function IsParser(value: unknown): value is IContext<unknown> | IUnion<unknown> | IArray<unknown> | IConst<unknown> | IIdent<unknown> | INumber<unknown> | IOptional<unknown> | IRef<unknown> | IString<unknown> | ITuple<unknown>;

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/guard.js

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsArray = IsArray;
+exports.IsConst = IsConst;
+exports.IsContext = IsContext;
+exports.IsIdent = IsIdent;
+exports.IsNumber = IsNumber;
+exports.IsOptional = IsOptional;
+exports.IsRef = IsRef;
+exports.IsString = IsString;
+exports.IsTuple = IsTuple;
+exports.IsUnion = IsUnion;
+exports.IsParser = IsParser;
+// ------------------------------------------------------------------
+// Value Guard
+// ------------------------------------------------------------------
+// prettier-ignore
+function HasPropertyKey(value, key) {
+    return key in value;
+}
+// prettier-ignore
+function IsObjectValue(value) {
+    return typeof value === 'object' && value !== null;
+}
+// prettier-ignore
+function IsArrayValue(value) {
+    return globalThis.Array.isArray(value);
+}
+// ------------------------------------------------------------------
+// Parser Guard
+// ------------------------------------------------------------------
+/** Returns true if the value is a Array Parser */
+function IsArray(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Array' && HasPropertyKey(value, 'parser') && IsObjectValue(value.parser);
+}
+/** Returns true if the value is a Const Parser */
+function IsConst(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Const' && HasPropertyKey(value, 'value') && typeof value.value === 'string';
+}
+/** Returns true if the value is a Context Parser */
+function IsContext(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Context' && HasPropertyKey(value, 'left') && IsParser(value.left) && HasPropertyKey(value, 'right') && IsParser(value.right);
+}
+/** Returns true if the value is a Ident Parser */
+function IsIdent(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ident';
+}
+/** Returns true if the value is a Number Parser */
+function IsNumber(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Number';
+}
+/** Returns true if the value is a Optional Parser */
+function IsOptional(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Optional' && HasPropertyKey(value, 'parser') && IsObjectValue(value.parser);
+}
+/** Returns true if the value is a Ref Parser */
+function IsRef(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Ref' && HasPropertyKey(value, 'ref') && typeof value.ref === 'string';
+}
+/** Returns true if the value is a String Parser */
+function IsString(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'String' && HasPropertyKey(value, 'options') && IsArrayValue(value.options);
+}
+/** Returns true if the value is a Tuple Parser */
+function IsTuple(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Tuple' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+}
+/** Returns true if the value is a Union Parser */
+function IsUnion(value) {
+    return IsObjectValue(value) && HasPropertyKey(value, 'type') && value.type === 'Union' && HasPropertyKey(value, 'parsers') && IsArrayValue(value.parsers);
+}
+/** Returns true if the value is a Parser */
+function IsParser(value) {
+    // prettier-ignore
+    return (IsArray(value) ||
+        IsConst(value) ||
+        IsContext(value) ||
+        IsIdent(value) ||
+        IsNumber(value) ||
+        IsOptional(value) ||
+        IsRef(value) ||
+        IsString(value) ||
+        IsTuple(value) ||
+        IsUnion(value));
+}

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export * as Guard from './guard';
+export * as Token from './token';
+export * from './types';
+export * from './module';
+export * from './parse';

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = exports.Guard = void 0;
+exports.Guard = __importStar(require("./guard"));
+exports.Token = __importStar(require("./token"));
+__exportStar(require("./types"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./parse"), exports);

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/module.d.ts

@@ -0,0 +1,9 @@
+import * as Types from './types';
+export declare class Module<Properties extends Types.IModuleProperties = Types.IModuleProperties> {
+    private readonly properties;
+    constructor(properties: Properties);
+    /** Parses using one of the parsers defined on this instance */
+    Parse<Key extends keyof Properties>(key: Key, content: string, context: unknown): [] | [Types.StaticParser<Properties[Key]>, string];
+    /** Parses using one of the parsers defined on this instance */
+    Parse<Key extends keyof Properties>(key: Key, content: string): [] | [Types.StaticParser<Properties[Key]>, string];
+}

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/module.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Module = void 0;
+const parse_1 = require("./parse");
+// ------------------------------------------------------------------
+// Module
+// ------------------------------------------------------------------
+class Module {
+    constructor(properties) {
+        this.properties = properties;
+    }
+    /** Parses using one of the parsers defined on this instance */
+    Parse(...args) {
+        // prettier-ignore
+        const [key, content, context] = (args.length === 3 ? [args[0], args[1], args[2]] :
+            args.length === 2 ? [args[0], args[1], undefined] :
+                (() => { throw Error('Invalid parse arguments'); })());
+        return (0, parse_1.Parse)(this.properties, this.properties[key], content, context);
+    }
+}
+exports.Module = Module;

package/node_modules/@sinclair/typebox/build/cjs/parser/runtime/parse.d.ts

@@ -0,0 +1,9 @@
+import * as Types from './types';
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(moduleProperties: Types.IModuleProperties, parser: Parser, code: string): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, content: string, context: unknown): [] | [Types.StaticParser<Parser>, string];
+/** Parses content using the given Parser */
+export declare function Parse<Parser extends Types.IParser>(parser: Parser, content: string): [] | [Types.StaticParser<Parser>, string];