npm - @workclaw/openclaw-workclaw - Versions diffs - 1.0.202 → 1.0.331 - Mend

@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (534) hide show

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/sets/set.js ADDED Viewed

@@ -0,0 +1,30 @@
+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 SetIntersectManyResolve(T, Init) {
+  return T.reduce((Acc, L) => {
+    return SetIntersect(Acc, L);
+  }, Init);
+}
+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;
+}
+export {
+  SetDistinct,
+  SetIncludes,
+  SetIntersect,
+  SetIntersectMany,
+  SetUnionMany
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/string/string.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function String(options) {
+  return CreateType({ [Kind]: "String", type: "string" }, options);
+}
+export {
+  String
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/symbol/symbol.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Symbol$1(options) {
+  return CreateType({ [Kind]: "Symbol", type: "symbol" }, options);
+}
+export {
+  Symbol$1 as Symbol
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/symbols/symbols.js ADDED Viewed

@@ -0,0 +1,12 @@
+const TransformKind = Symbol.for("TypeBox.Transform");
+const ReadonlyKind = Symbol.for("TypeBox.Readonly");
+const OptionalKind = Symbol.for("TypeBox.Optional");
+const Hint = Symbol.for("TypeBox.Hint");
+const Kind = Symbol.for("TypeBox.Kind");
+export {
+  Hint,
+  Kind,
+  OptionalKind,
+  ReadonlyKind,
+  TransformKind
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/template-literal/finite.js ADDED Viewed

@@ -0,0 +1,27 @@
+import { TemplateLiteralParseExact } from "./parse.js";
+import { TypeBoxError } from "../error/error.js";
+class TemplateLiteralFiniteError extends TypeBoxError {
+}
+function IsNumberExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "0" && expression.expr[1].type === "const" && expression.expr[1].const === "[1-9][0-9]*";
+}
+function IsBooleanExpression(expression) {
+  return expression.type === "or" && expression.expr.length === 2 && expression.expr[0].type === "const" && expression.expr[0].const === "true" && expression.expr[1].type === "const" && expression.expr[1].const === "false";
+}
+function IsStringExpression(expression) {
+  return expression.type === "const" && expression.const === ".*";
+}
+function IsTemplateLiteralExpressionFinite(expression) {
+  return IsNumberExpression(expression) || IsStringExpression(expression) ? false : IsBooleanExpression(expression) ? true : expression.type === "and" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "or" ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) : expression.type === "const" ? true : (() => {
+    throw new TemplateLiteralFiniteError(`Unknown expression type`);
+  })();
+}
+function IsTemplateLiteralFinite(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression);
+}
+export {
+  IsTemplateLiteralExpressionFinite,
+  IsTemplateLiteralFinite,
+  TemplateLiteralFiniteError
+};

@@ -0,0 +1,38 @@
+import { IsTemplateLiteralExpressionFinite } from "./finite.js";
+import { TemplateLiteralParseExact } from "./parse.js";
+import { TypeBoxError } from "../error/error.js";
+class TemplateLiteralGenerateError extends TypeBoxError {
+}
+function* GenerateReduce(buffer) {
+  if (buffer.length === 1)
+    return yield* buffer[0];
+  for (const left of buffer[0]) {
+    for (const right of GenerateReduce(buffer.slice(1))) {
+      yield `${left}${right}`;
+    }
+  }
+}
+function* GenerateAnd(expression) {
+  return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
+}
+function* GenerateOr(expression) {
+  for (const expr of expression.expr)
+    yield* TemplateLiteralExpressionGenerate(expr);
+}
+function* GenerateConst(expression) {
+  return yield expression.const;
+}
+function* TemplateLiteralExpressionGenerate(expression) {
+  return expression.type === "and" ? yield* GenerateAnd(expression) : expression.type === "or" ? yield* GenerateOr(expression) : expression.type === "const" ? yield* GenerateConst(expression) : (() => {
+    throw new TemplateLiteralGenerateError("Unknown expression");
+  })();
+}
+function TemplateLiteralGenerate(schema) {
+  const expression = TemplateLiteralParseExact(schema.pattern);
+  return IsTemplateLiteralExpressionFinite(expression) ? [...TemplateLiteralExpressionGenerate(expression)] : [];
+}
+export {
+  TemplateLiteralExpressionGenerate,
+  TemplateLiteralGenerate,
+  TemplateLiteralGenerateError
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/template-literal/parse.js ADDED Viewed

@@ -0,0 +1,128 @@
+import { TypeBoxError } from "../error/error.js";
+class TemplateLiteralParserError extends TypeBoxError {
+}
+function Unescape(pattern) {
+  return pattern.replace(/\\\$/g, "$").replace(/\\\*/g, "*").replace(/\\\^/g, "^").replace(/\\\|/g, "|").replace(/\\\(/g, "(").replace(/\\\)/g, ")");
+}
+function IsNonEscaped(pattern, index, char) {
+  return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
+}
+function IsOpenParen(pattern, index) {
+  return IsNonEscaped(pattern, index, "(");
+}
+function IsCloseParen(pattern, index) {
+  return IsNonEscaped(pattern, index, ")");
+}
+function IsSeparator(pattern, index) {
+  return IsNonEscaped(pattern, index, "|");
+}
+function IsGroup(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;
+}
+function InGroup(pattern) {
+  return pattern.slice(1, pattern.length - 1);
+}
+function IsPrecedenceOr(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;
+}
+function IsPrecedenceAnd(pattern) {
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index))
+      return true;
+  }
+  return false;
+}
+function Or(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)
+    return expressions[0];
+  return { type: "or", expr: expressions };
+}
+function And(pattern) {
+  function Group(value, index) {
+    if (!IsOpenParen(value, index))
+      throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
+    let count = 0;
+    for (let scan = index; scan < value.length; scan++) {
+      if (IsOpenParen(value, scan))
+        count += 1;
+      if (IsCloseParen(value, scan))
+        count -= 1;
+      if (count === 0)
+        return [index, scan];
+    }
+    throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
+  }
+  function Range(pattern2, index) {
+    for (let scan = index; scan < pattern2.length; scan++) {
+      if (IsOpenParen(pattern2, scan))
+        return [index, scan];
+    }
+    return [index, pattern2.length];
+  }
+  const expressions = [];
+  for (let index = 0; index < pattern.length; index++) {
+    if (IsOpenParen(pattern, index)) {
+      const [start, end] = Group(pattern, index);
+      const range = pattern.slice(start, end + 1);
+      expressions.push(TemplateLiteralParse(range));
+      index = end;
+    } else {
+      const [start, end] = Range(pattern, index);
+      const range = pattern.slice(start, end);
+      if (range.length > 0)
+        expressions.push(TemplateLiteralParse(range));
+      index = end - 1;
+    }
+  }
+  return expressions.length === 0 ? { type: "const", const: "" } : expressions.length === 1 ? expressions[0] : { type: "and", expr: expressions };
+}
+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));
+}
+export {
+  TemplateLiteralParse,
+  TemplateLiteralParseExact,
+  TemplateLiteralParserError
+};

@@ -0,0 +1,21 @@
+import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from "../guard/kind.js";
+import { PatternNumber, PatternString, PatternBoolean } from "../patterns/patterns.js";
+import { Kind } from "../symbols/symbols.js";
+import { TypeBoxError } from "../error/error.js";
+class TemplateLiteralPatternError extends TypeBoxError {
+}
+function Escape(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function Visit(schema, acc) {
+  return IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) : IsUnion(schema) ? `(${schema.anyOf.map((schema2) => Visit(schema2, acc)).join("|")})` : IsNumber(schema) ? `${acc}${PatternNumber}` : IsInteger(schema) ? `${acc}${PatternNumber}` : IsBigInt(schema) ? `${acc}${PatternNumber}` : IsString(schema) ? `${acc}${PatternString}` : IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` : IsBoolean(schema) ? `${acc}${PatternBoolean}` : (() => {
+    throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`);
+  })();
+}
+function TemplateLiteralPattern(kinds) {
+  return `^${kinds.map((schema) => Visit(schema, "")).join("")}$`;
+}
+export {
+  TemplateLiteralPattern,
+  TemplateLiteralPatternError
+};

@@ -0,0 +1,45 @@
+import { Literal } from "../literal/literal.js";
+import { Boolean } from "../boolean/boolean.js";
+import { Number } from "../number/number.js";
+import { BigInt } from "../bigint/bigint.js";
+import { String } from "../string/string.js";
+import { Never } from "../never/never.js";
+import { UnionEvaluated } from "../union/union-evaluated.js";
+function* FromUnion(syntax) {
+  const trim = syntax.trim().replace(/"|'/g, "");
+  return trim === "boolean" ? yield Boolean() : trim === "number" ? yield Number() : trim === "bigint" ? yield BigInt() : trim === "string" ? yield String() : yield (() => {
+    const literals = trim.split("|").map((literal) => Literal(literal.trim()));
+    return literals.length === 0 ? Never() : literals.length === 1 ? literals[0] : UnionEvaluated(literals);
+  })();
+}
+function* FromTerminal(syntax) {
+  if (syntax[1] !== "{") {
+    const L = Literal("$");
+    const R = FromSyntax(syntax.slice(1));
+    return yield* [L, ...R];
+  }
+  for (let i = 2; i < syntax.length; i++) {
+    if (syntax[i] === "}") {
+      const L = FromUnion(syntax.slice(2, i));
+      const R = FromSyntax(syntax.slice(i + 1));
+      return yield* [...L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function* FromSyntax(syntax) {
+  for (let i = 0; i < syntax.length; i++) {
+    if (syntax[i] === "$") {
+      const L = Literal(syntax.slice(0, i));
+      const R = FromTerminal(syntax.slice(i));
+      return yield* [L, ...R];
+    }
+  }
+  yield Literal(syntax);
+}
+function TemplateLiteralSyntax(syntax) {
+  return [...FromSyntax(syntax)];
+}
+export {
+  TemplateLiteralSyntax
+};

@@ -0,0 +1,12 @@
+import { CreateType } from "../create/type.js";
+import { TemplateLiteralSyntax } from "./syntax.js";
+import { TemplateLiteralPattern } from "./pattern.js";
+import { IsString } from "../guard/value.js";
+import { Kind } from "../symbols/symbols.js";
+function TemplateLiteral(unresolved, options) {
+  const pattern = IsString(unresolved) ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved)) : TemplateLiteralPattern(unresolved);
+  return CreateType({ [Kind]: "TemplateLiteral", type: "string", pattern }, options);
+}
+export {
+  TemplateLiteral
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/template-literal/union.js ADDED Viewed

@@ -0,0 +1,11 @@
+import { TemplateLiteralGenerate } from "./generate.js";
+import { Literal } from "../literal/literal.js";
+import { UnionEvaluated } from "../union/union-evaluated.js";
+function TemplateLiteralToUnion(schema) {
+  const R = TemplateLiteralGenerate(schema);
+  const L = R.map((S) => Literal(S));
+  return UnionEvaluated(L);
+}
+export {
+  TemplateLiteralToUnion
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/transform/transform.js ADDED Viewed

@@ -0,0 +1,37 @@
+import { IsTransform } from "../guard/kind.js";
+import { TransformKind } from "../symbols/symbols.js";
+class TransformDecodeBuilder {
+  constructor(schema) {
+    this.schema = schema;
+  }
+  Decode(decode) {
+    return new TransformEncodeBuilder(this.schema, decode);
+  }
+}
+class TransformEncodeBuilder {
+  constructor(schema, decode) {
+    this.schema = schema;
+    this.decode = decode;
+  }
+  EncodeTransform(encode, schema) {
+    const Encode = (value) => schema[TransformKind].Encode(encode(value));
+    const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
+    const Codec = { Encode, Decode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  EncodeSchema(encode, schema) {
+    const Codec = { Decode: this.decode, Encode: encode };
+    return { ...schema, [TransformKind]: Codec };
+  }
+  Encode(encode) {
+    return IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema);
+  }
+}
+function Transform(schema) {
+  return new TransformDecodeBuilder(schema);
+}
+export {
+  Transform,
+  TransformDecodeBuilder,
+  TransformEncodeBuilder
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/tuple/tuple.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Tuple(types, options) {
+  return CreateType(types.length > 0 ? { [Kind]: "Tuple", type: "array", items: types, additionalItems: false, minItems: types.length, maxItems: types.length } : { [Kind]: "Tuple", type: "array", minItems: types.length, maxItems: types.length }, options);
+}
+export {
+  Tuple
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/type/index.js ADDED Viewed

@@ -0,0 +1,5 @@
+import * as type from "./type.js";
+const Type = type;
+export {
+  Type
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/type/type.js ADDED Viewed

@@ -0,0 +1,126 @@
+import { Object as Object$1 } from "../object/object.js";
+import { Any } from "../any/any.js";
+import { Argument } from "../argument/argument.js";
+import { Array } from "../array/array.js";
+import { AsyncIterator } from "../async-iterator/async-iterator.js";
+import { Awaited } from "../awaited/awaited.js";
+import { BigInt } from "../bigint/bigint.js";
+import { Boolean } from "../boolean/boolean.js";
+import { Capitalize } from "../intrinsic/capitalize.js";
+import { Composite } from "../composite/composite.js";
+import { Const } from "../const/const.js";
+import { Constructor } from "../constructor/constructor.js";
+import { ConstructorParameters } from "../constructor-parameters/constructor-parameters.js";
+import { Date } from "../date/date.js";
+import { Enum } from "../enum/enum.js";
+import { Exclude } from "../exclude/exclude.js";
+import { Extends } from "../extends/extends.js";
+import { Extract } from "../extract/extract.js";
+import { Function } from "../function/function.js";
+import { Index } from "../indexed/indexed.js";
+import { InstanceType } from "../instance-type/instance-type.js";
+import { Instantiate } from "../instantiate/instantiate.js";
+import { Integer } from "../integer/integer.js";
+import { Intersect } from "../intersect/intersect.js";
+import { Iterator } from "../iterator/iterator.js";
+import { KeyOf } from "../keyof/keyof.js";
+import { Literal } from "../literal/literal.js";
+import { Lowercase } from "../intrinsic/lowercase.js";
+import { Mapped } from "../mapped/mapped.js";
+import { Module } from "../module/module.js";
+import { Never } from "../never/never.js";
+import { Not } from "../not/not.js";
+import { Null } from "../null/null.js";
+import { Number } from "../number/number.js";
+import { Omit } from "../omit/omit.js";
+import { Optional } from "../optional/optional.js";
+import { Parameters } from "../parameters/parameters.js";
+import { Partial } from "../partial/partial.js";
+import { Pick } from "../pick/pick.js";
+import { Promise as Promise2 } from "../promise/promise.js";
+import { Readonly } from "../readonly/readonly.js";
+import { ReadonlyOptional } from "../readonly-optional/readonly-optional.js";
+import { Record } from "../record/record.js";
+import { Recursive } from "../recursive/recursive.js";
+import { Ref } from "../ref/ref.js";
+import { RegExp } from "../regexp/regexp.js";
+import { Required } from "../required/required.js";
+import { Rest } from "../rest/rest.js";
+import { ReturnType } from "../return-type/return-type.js";
+import { String } from "../string/string.js";
+import { Symbol } from "../symbol/symbol.js";
+import { TemplateLiteral } from "../template-literal/template-literal.js";
+import { Transform } from "../transform/transform.js";
+import { Tuple } from "../tuple/tuple.js";
+import { Uint8Array } from "../uint8array/uint8array.js";
+import { Uncapitalize } from "../intrinsic/uncapitalize.js";
+import { Undefined } from "../undefined/undefined.js";
+import { Union } from "../union/union.js";
+import { Unknown } from "../unknown/unknown.js";
+import { Unsafe } from "../unsafe/unsafe.js";
+import { Uppercase } from "../intrinsic/uppercase.js";
+import { Void } from "../void/void.js";
+export {
+  Any,
+  Argument,
+  Array,
+  AsyncIterator,
+  Awaited,
+  BigInt,
+  Boolean,
+  Capitalize,
+  Composite,
+  Const,
+  Constructor,
+  ConstructorParameters,
+  Date,
+  Enum,
+  Exclude,
+  Extends,
+  Extract,
+  Function,
+  Index,
+  InstanceType,
+  Instantiate,
+  Integer,
+  Intersect,
+  Iterator,
+  KeyOf,
+  Literal,
+  Lowercase,
+  Mapped,
+  Module,
+  Never,
+  Not,
+  Null,
+  Number,
+  Object$1 as Object,
+  Omit,
+  Optional,
+  Parameters,
+  Partial,
+  Pick,
+  Promise2 as Promise,
+  Readonly,
+  ReadonlyOptional,
+  Record,
+  Recursive,
+  Ref,
+  RegExp,
+  Required,
+  Rest,
+  ReturnType,
+  String,
+  Symbol,
+  TemplateLiteral,
+  Transform,
+  Tuple,
+  Uint8Array,
+  Uncapitalize,
+  Undefined,
+  Union,
+  Unknown,
+  Unsafe,
+  Uppercase,
+  Void
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/uint8array/uint8array.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Uint8Array(options) {
+  return CreateType({ [Kind]: "Uint8Array", type: "Uint8Array" }, options);
+}
+export {
+  Uint8Array
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/undefined/undefined.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Undefined(options) {
+  return CreateType({ [Kind]: "Undefined", type: "undefined" }, options);
+}
+export {
+  Undefined
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/union/union-create.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function UnionCreate(T, options) {
+  return CreateType({ [Kind]: "Union", anyOf: T }, options);
+}
+export {
+  UnionCreate
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/union/union-evaluated.js ADDED Viewed

@@ -0,0 +1,26 @@
+import { CreateType } from "../create/type.js";
+import { UnionCreate } from "./union-create.js";
+import { IsOptional } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import { Optional } from "../optional/optional.js";
+import { Discard } from "../discard/discard.js";
+import { OptionalKind } from "../symbols/symbols.js";
+function IsUnionOptional(types) {
+  return types.some((type) => IsOptional(type));
+}
+function RemoveOptionalFromRest(types) {
+  return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+}
+function RemoveOptionalFromType(T) {
+  return Discard(T, [OptionalKind]);
+}
+function ResolveUnion(types, options) {
+  const isOptional = IsUnionOptional(types);
+  return isOptional ? Optional(UnionCreate(RemoveOptionalFromRest(types), options)) : UnionCreate(RemoveOptionalFromRest(types), options);
+}
+function UnionEvaluated(T, options) {
+  return T.length === 1 ? CreateType(T[0], options) : T.length === 0 ? Never(options) : ResolveUnion(T, options);
+}
+export {
+  UnionEvaluated
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/union/union.js ADDED Viewed

@@ -0,0 +1,9 @@
+import { CreateType } from "../create/type.js";
+import { UnionCreate } from "./union-create.js";
+import { Never } from "../never/never.js";
+function Union(types, options) {
+  return types.length === 0 ? Never(options) : types.length === 1 ? CreateType(types[0], options) : UnionCreate(types, options);
+}
+export {
+  Union
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/unknown/unknown.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Unknown(options) {
+  return CreateType({ [Kind]: "Unknown" }, options);
+}
+export {
+  Unknown
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/unsafe/unsafe.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Unsafe(options = {}) {
+  return CreateType({ [Kind]: options[Kind] ?? "Unsafe" }, options);
+}
+export {
+  Unsafe
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/type/void/void.js ADDED Viewed

@@ -0,0 +1,8 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+function Void(options) {
+  return CreateType({ [Kind]: "Void", type: "void" }, options);
+}
+export {
+  Void
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@sinclair/typebox/build/esm/value/guard/guard.js ADDED Viewed

@@ -0,0 +1,18 @@
+function IsObject(value) {
+  return value !== null && typeof value === "object";
+}
+function IsArray(value) {
+  return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
+}
+function IsUndefined(value) {
+  return value === void 0;
+}
+function IsNumber(value) {
+  return typeof value === "number";
+}
+export {
+  IsArray,
+  IsNumber,
+  IsObject,
+  IsUndefined
+};