@directus/api 34.0.1 → 35.0.0

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.js

@@ -0,0 +1,27 @@
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+import { Index } from "./indexed.js";
+import "../mapped/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-key.mjs
+function MappedIndexPropertyKey(type, key, options) {
+	return { [key]: Index(type, [key], Clone(options)) };
+}
+function MappedIndexPropertyKeys(type, propertyKeys, options) {
+	return propertyKeys.reduce((result, left) => {
+		return {
+			...result,
+			...MappedIndexPropertyKey(type, left, options)
+		};
+	}, {});
+}
+function MappedIndexProperties(type, mappedKey, options) {
+	return MappedIndexPropertyKeys(type, mappedKey.keys, options);
+}
+function IndexFromMappedKey(type, mappedKey, options) {
+	const properties = MappedIndexProperties(type, mappedKey, options);
+	return MappedResult(properties);
+}
+
+//#endregion
+export { IndexFromMappedKey };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.js

@@ -0,0 +1,24 @@
+import { MappedResult } from "../mapped/mapped-result.js";
+import { IndexPropertyKeys } from "./indexed-property-keys.js";
+import { Index } from "./indexed.js";
+import "./index.js";
+import "../mapped/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-from-mapped-result.mjs
+function FromProperties(type, properties, options) {
+	const result = {};
+	for (const K2 of Object.getOwnPropertyNames(properties)) {
+		result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
+	}
+	return result;
+}
+function FromMappedResult(type, mappedResult, options) {
+	return FromProperties(type, mappedResult.properties, options);
+}
+function IndexFromMappedResult(type, mappedResult, options) {
+	const properties = FromMappedResult(type, mappedResult, options);
+	return MappedResult(properties);
+}
+
+//#endregion
+export { IndexFromMappedResult };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.js

@@ -0,0 +1,24 @@
+import { IsInteger, IsLiteral, IsNumber, IsTemplateLiteral, IsUnion } from "../guard/kind.js";
+import { TemplateLiteralGenerate } from "../template-literal/generate.js";
+import "../template-literal/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs
+function FromTemplateLiteral(templateLiteral) {
+	const keys = TemplateLiteralGenerate(templateLiteral);
+	return keys.map((key) => key.toString());
+}
+function FromUnion(types) {
+	const result = [];
+	for (const type of types) result.push(...IndexPropertyKeys(type));
+	return result;
+}
+function FromLiteral(literalValue) {
+	return [literalValue.toString()];
+}
+/** Returns a tuple of PropertyKeys derived from the given TSchema */
+function IndexPropertyKeys(type) {
+	return [...new Set(IsTemplateLiteral(type) ? FromTemplateLiteral(type) : IsUnion(type) ? FromUnion(type.anyOf) : IsLiteral(type) ? FromLiteral(type.const) : IsNumber(type) ? ["[number]"] : IsInteger(type) ? ["[number]"] : [])];
+}
+
+//#endregion
+export { IndexPropertyKeys };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.js

@@ -0,0 +1,67 @@
+import { CreateType } from "../create/type.js";
+import { TypeBoxError } from "../error/error.js";
+import "../error/index.js";
+import { IsArray, IsIntersect, IsMappedKey, IsMappedResult, IsNever, IsObject, IsRef, IsSchema, IsTuple, IsUnion } from "../guard/kind.js";
+import { Computed } from "../computed/computed.js";
+import "../computed/index.js";
+import { Never } from "../never/never.js";
+import "../never/index.js";
+import { UnionEvaluated } from "../union/union-evaluated.js";
+import "../union/index.js";
+import { IndexPropertyKeys } from "./indexed-property-keys.js";
+import { IndexFromMappedResult } from "./indexed-from-mapped-result.js";
+import { IndexFromMappedKey } from "./indexed-from-mapped-key.js";
+import { IntersectEvaluated } from "../intersect/intersect-evaluated.js";
+import "../intersect/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed.mjs
+function FromRest(types, key) {
+	return types.map((type) => IndexFromPropertyKey(type, key));
+}
+function FromIntersectRest(types) {
+	return types.filter((type) => !IsNever(type));
+}
+function FromIntersect(types, key) {
+	return IntersectEvaluated(FromIntersectRest(FromRest(types, key)));
+}
+function FromUnionRest(types) {
+	return types.some((L) => IsNever(L)) ? [] : types;
+}
+function FromUnion(types, key) {
+	return UnionEvaluated(FromUnionRest(FromRest(types, key)));
+}
+function FromTuple(types, key) {
+	return key in types ? types[key] : key === "[number]" ? UnionEvaluated(types) : Never();
+}
+function FromArray(type, key) {
+	return key === "[number]" ? type : Never();
+}
+function FromProperty(properties, propertyKey) {
+	return propertyKey in properties ? properties[propertyKey] : Never();
+}
+function IndexFromPropertyKey(type, propertyKey) {
+	return IsIntersect(type) ? FromIntersect(type.allOf, propertyKey) : IsUnion(type) ? FromUnion(type.anyOf, propertyKey) : IsTuple(type) ? FromTuple(type.items ?? [], propertyKey) : IsArray(type) ? FromArray(type.items, propertyKey) : IsObject(type) ? FromProperty(type.properties, propertyKey) : Never();
+}
+function IndexFromPropertyKeys(type, propertyKeys) {
+	return propertyKeys.map((propertyKey) => IndexFromPropertyKey(type, propertyKey));
+}
+function FromSchema(type, propertyKeys) {
+	return UnionEvaluated(IndexFromPropertyKeys(type, propertyKeys));
+}
+function IndexFromComputed(type, key) {
+	return Computed("Index", [type, key]);
+}
+/** `[Json]` Returns an Indexed property type for the given keys */
+function Index(type, key, options) {
+	if (IsRef(type) || IsRef(key)) {
+		const error = `Index types using Ref parameters require both Type and Key to be of TSchema`;
+		if (!IsSchema(type) || !IsSchema(key)) throw new TypeBoxError(error);
+		return Computed("Index", [type, key]);
+	}
+	if (IsMappedResult(key)) return IndexFromMappedResult(type, key, options);
+	if (IsMappedKey(key)) return IndexFromMappedKey(type, key, options);
+	return CreateType(IsSchema(key) ? FromSchema(type, IndexPropertyKeys(key)) : FromSchema(type, key), options);
+}
+
+//#endregion
+export { Index, IndexFromPropertyKey, IndexFromPropertyKeys };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/instance-type/index.js

@@ -0,0 +1,3 @@
+import { InstanceType } from "./instance-type.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.js

@@ -0,0 +1,13 @@
+import { CreateType } from "../create/type.js";
+import { IsConstructor } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import "../never/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/instance-type/instance-type.mjs
+/** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
+function InstanceType(schema, options) {
+	return IsConstructor(schema) ? CreateType(schema.returns, options) : Never(options);
+}
+
+//#endregion
+export { InstanceType };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/instantiate/index.js

@@ -0,0 +1,3 @@
+import { FromTypes, Instantiate } from "./instantiate.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.js

@@ -0,0 +1,102 @@
+import { IsUndefined } from "../guard/value.js";
+import { CloneType } from "../clone/type.js";
+import { IsArgument, IsArray, IsAsyncIterator, IsConstructor, IsFunction, IsIntersect, IsIterator, IsObject, IsOptional, IsPromise, IsReadonly, IsRecord, IsTuple, IsUnion } from "../guard/kind.js";
+import { Object as Object$1 } from "../object/object.js";
+import "../object/index.js";
+import { Readonly } from "../readonly/readonly.js";
+import "../readonly/index.js";
+import { Optional } from "../optional/optional.js";
+import "../optional/index.js";
+import { Unknown } from "../unknown/unknown.js";
+import "../unknown/index.js";
+import { ReadonlyOptional } from "../readonly-optional/readonly-optional.js";
+import "../readonly-optional/index.js";
+import { Record, RecordKey, RecordValue } from "../record/record.js";
+import "../record/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/instantiate/instantiate.mjs
+function FromConstructor(args, type) {
+	type.parameters = FromTypes(args, type.parameters);
+	type.returns = FromType(args, type.returns);
+	return type;
+}
+function FromFunction(args, type) {
+	type.parameters = FromTypes(args, type.parameters);
+	type.returns = FromType(args, type.returns);
+	return type;
+}
+function FromIntersect(args, type) {
+	type.allOf = FromTypes(args, type.allOf);
+	return type;
+}
+function FromUnion(args, type) {
+	type.anyOf = FromTypes(args, type.anyOf);
+	return type;
+}
+function FromTuple(args, type) {
+	if (IsUndefined(type.items)) return type;
+	type.items = FromTypes(args, type.items);
+	return type;
+}
+function FromArray(args, type) {
+	type.items = FromType(args, type.items);
+	return type;
+}
+function FromAsyncIterator(args, type) {
+	type.items = FromType(args, type.items);
+	return type;
+}
+function FromIterator(args, type) {
+	type.items = FromType(args, type.items);
+	return type;
+}
+function FromPromise(args, type) {
+	type.item = FromType(args, type.item);
+	return type;
+}
+function FromObject(args, type) {
+	const mappedProperties = FromProperties(args, type.properties);
+	return {
+		...type,
+		...Object$1(mappedProperties)
+	};
+}
+function FromRecord(args, type) {
+	const mappedKey = FromType(args, RecordKey(type));
+	const mappedValue = FromType(args, RecordValue(type));
+	const result = Record(mappedKey, mappedValue);
+	return {
+		...type,
+		...result
+	};
+}
+function FromArgument(args, argument) {
+	return argument.index in args ? args[argument.index] : Unknown();
+}
+function FromProperty(args, type) {
+	const isReadonly = IsReadonly(type);
+	const isOptional = IsOptional(type);
+	const mapped = FromType(args, type);
+	return isReadonly && isOptional ? ReadonlyOptional(mapped) : isReadonly && !isOptional ? Readonly(mapped) : !isReadonly && isOptional ? Optional(mapped) : mapped;
+}
+function FromProperties(args, properties) {
+	return globalThis.Object.getOwnPropertyNames(properties).reduce((result, key) => {
+		return {
+			...result,
+			[key]: FromProperty(args, properties[key])
+		};
+	}, {});
+}
+function FromTypes(args, types) {
+	return types.map((type) => FromType(args, type));
+}
+function FromType(args, type) {
+	return IsConstructor(type) ? FromConstructor(args, type) : IsFunction(type) ? FromFunction(args, type) : IsIntersect(type) ? FromIntersect(args, type) : IsUnion(type) ? FromUnion(args, type) : IsTuple(type) ? FromTuple(args, type) : IsArray(type) ? FromArray(args, type) : IsAsyncIterator(type) ? FromAsyncIterator(args, type) : IsIterator(type) ? FromIterator(args, type) : IsPromise(type) ? FromPromise(args, type) : IsObject(type) ? FromObject(args, type) : IsRecord(type) ? FromRecord(args, type) : IsArgument(type) ? FromArgument(args, type) : type;
+}
+/** `[JavaScript]` Instantiates a type with the given parameters */
+function Instantiate(type, args) {
+	return FromType(args, CloneType(type));
+}
+
+//#endregion
+export { FromTypes, Instantiate };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/integer/index.js

@@ -0,0 +1,3 @@
+import { Integer } from "./integer.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/integer/integer.js

@@ -0,0 +1,15 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/integer/integer.mjs
+/** `[Json]` Creates an Integer type */
+function Integer(options) {
+	return CreateType({
+		[Kind]: "Integer",
+		type: "integer"
+	}, options);
+}
+
+//#endregion
+export { Integer };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/index.js

@@ -0,0 +1,5 @@
+import { IntersectEvaluated } from "./intersect-evaluated.js";
+import "./intersect-type.js";
+import { Intersect } from "./intersect.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.js

@@ -0,0 +1,23 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+import { IsObject, IsSchema } from "../guard/kind.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-create.mjs
+function IntersectCreate(T, options = {}) {
+	const allObjects = T.every((schema) => IsObject(schema));
+	const clonedUnevaluatedProperties = IsSchema(options.unevaluatedProperties) ? { unevaluatedProperties: options.unevaluatedProperties } : {};
+	return CreateType(options.unevaluatedProperties === false || IsSchema(options.unevaluatedProperties) || allObjects ? {
+		...clonedUnevaluatedProperties,
+		[Kind]: "Intersect",
+		type: "object",
+		allOf: T
+	} : {
+		...clonedUnevaluatedProperties,
+		[Kind]: "Intersect",
+		allOf: T
+	}, options);
+}
+
+//#endregion
+export { IntersectCreate };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.js

@@ -0,0 +1,35 @@
+import { CreateType } from "../create/type.js";
+import { OptionalKind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+import { IsOptional, IsTransform } from "../guard/kind.js";
+import { Discard } from "../discard/discard.js";
+import "../discard/index.js";
+import { Never } from "../never/never.js";
+import "../never/index.js";
+import { Optional } from "../optional/optional.js";
+import "../optional/index.js";
+import { IntersectCreate } from "./intersect-create.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-evaluated.mjs
+function IsIntersectOptional(types) {
+	return types.every((left) => IsOptional(left));
+}
+function RemoveOptionalFromType(type) {
+	return Discard(type, [OptionalKind]);
+}
+function RemoveOptionalFromRest(types) {
+	return types.map((left) => IsOptional(left) ? RemoveOptionalFromType(left) : left);
+}
+function ResolveIntersect(types, options) {
+	return IsIntersectOptional(types) ? Optional(IntersectCreate(RemoveOptionalFromRest(types), options)) : IntersectCreate(RemoveOptionalFromRest(types), options);
+}
+/** `[Json]` Creates an evaluated Intersect type */
+function IntersectEvaluated(types, options = {}) {
+	if (types.length === 1) return CreateType(types[0], options);
+	if (types.length === 0) return Never(options);
+	if (types.some((schema) => IsTransform(schema))) throw new Error("Cannot intersect transform types");
+	return ResolveIntersect(types, options);
+}
+
+//#endregion
+export { IntersectEvaluated };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect-type.js

@@ -0,0 +1,3 @@
+import "../symbols/index.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.js

@@ -0,0 +1,17 @@
+import { CreateType } from "../create/type.js";
+import { IsTransform } from "../guard/kind.js";
+import { Never } from "../never/never.js";
+import "../never/index.js";
+import { IntersectCreate } from "./intersect-create.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intersect/intersect.mjs
+/** `[Json]` Creates an evaluated Intersect type */
+function Intersect(types, options) {
+	if (types.length === 1) return CreateType(types[0], options);
+	if (types.length === 0) return Never(options);
+	if (types.some((schema) => IsTransform(schema))) throw new Error("Cannot intersect transform types");
+	return IntersectCreate(types, options);
+}
+
+//#endregion
+export { Intersect };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.js

@@ -0,0 +1,10 @@
+import { Intrinsic } from "./intrinsic.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/capitalize.mjs
+/** `[Json]` Intrinsic function to Capitalize LiteralString types */
+function Capitalize(T, options = {}) {
+	return Intrinsic(T, "Capitalize", options);
+}
+
+//#endregion
+export { Capitalize };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/index.js

@@ -0,0 +1,8 @@
+import { IntrinsicFromMappedKey } from "./intrinsic-from-mapped-key.js";
+import { Intrinsic } from "./intrinsic.js";
+import { Capitalize } from "./capitalize.js";
+import { Lowercase } from "./lowercase.js";
+import { Uncapitalize } from "./uncapitalize.js";
+import { Uppercase } from "./uppercase.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.js

@@ -0,0 +1,30 @@
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+import { Literal } from "../literal/literal.js";
+import "../literal/index.js";
+import "../mapped/index.js";
+import { Intrinsic } from "./intrinsic.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic-from-mapped-key.mjs
+function MappedIntrinsicPropertyKey(K, M, options) {
+	return { [K]: Intrinsic(Literal(K), M, Clone(options)) };
+}
+function MappedIntrinsicPropertyKeys(K, M, options) {
+	const result = K.reduce((Acc, L) => {
+		return {
+			...Acc,
+			...MappedIntrinsicPropertyKey(L, M, options)
+		};
+	}, {});
+	return result;
+}
+function MappedIntrinsicProperties(T, M, options) {
+	return MappedIntrinsicPropertyKeys(T["keys"], M, options);
+}
+function IntrinsicFromMappedKey(T, M, options) {
+	const P = MappedIntrinsicProperties(T, M, options);
+	return MappedResult(P);
+}
+
+//#endregion
+export { IntrinsicFromMappedKey };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.js

@@ -0,0 +1,54 @@
+import { CreateType } from "../create/type.js";
+import { IsLiteral, IsMappedKey, IsTemplateLiteral, IsUnion } from "../guard/kind.js";
+import { Union } from "../union/union.js";
+import "../union/index.js";
+import { TemplateLiteralParseExact } from "../template-literal/parse.js";
+import { IsTemplateLiteralExpressionFinite } from "../template-literal/finite.js";
+import { TemplateLiteralExpressionGenerate } from "../template-literal/generate.js";
+import { Literal } from "../literal/literal.js";
+import "../literal/index.js";
+import { TemplateLiteral } from "../template-literal/template-literal.js";
+import "../template-literal/index.js";
+import { IntrinsicFromMappedKey } from "./intrinsic-from-mapped-key.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/intrinsic.mjs
+function ApplyUncapitalize(value) {
+	const [first, rest] = [value.slice(0, 1), value.slice(1)];
+	return [first.toLowerCase(), rest].join("");
+}
+function ApplyCapitalize(value) {
+	const [first, rest] = [value.slice(0, 1), value.slice(1)];
+	return [first.toUpperCase(), rest].join("");
+}
+function ApplyUppercase(value) {
+	return value.toUpperCase();
+}
+function ApplyLowercase(value) {
+	return value.toLowerCase();
+}
+function FromTemplateLiteral(schema, mode, options) {
+	const expression = TemplateLiteralParseExact(schema.pattern);
+	const finite = IsTemplateLiteralExpressionFinite(expression);
+	if (!finite) return {
+		...schema,
+		pattern: FromLiteralValue(schema.pattern, mode)
+	};
+	const strings = [...TemplateLiteralExpressionGenerate(expression)];
+	const literals = strings.map((value) => Literal(value));
+	const mapped = FromRest(literals, mode);
+	const union = Union(mapped);
+	return TemplateLiteral([union], options);
+}
+function FromLiteralValue(value, mode) {
+	return typeof value === "string" ? mode === "Uncapitalize" ? ApplyUncapitalize(value) : mode === "Capitalize" ? ApplyCapitalize(value) : mode === "Uppercase" ? ApplyUppercase(value) : mode === "Lowercase" ? ApplyLowercase(value) : value : value.toString();
+}
+function FromRest(T, M) {
+	return T.map((L) => Intrinsic(L, M));
+}
+/** Applies an intrinsic string manipulation to the given type. */
+function Intrinsic(schema, mode, options = {}) {
+	return IsMappedKey(schema) ? IntrinsicFromMappedKey(schema, mode, options) : IsTemplateLiteral(schema) ? FromTemplateLiteral(schema, mode, options) : IsUnion(schema) ? Union(FromRest(schema.anyOf, mode), options) : IsLiteral(schema) ? Literal(FromLiteralValue(schema.const, mode), options) : CreateType(schema, options);
+}
+
+//#endregion
+export { Intrinsic };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.js

@@ -0,0 +1,10 @@
+import { Intrinsic } from "./intrinsic.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/lowercase.mjs
+/** `[Json]` Intrinsic function to Lowercase LiteralString types */
+function Lowercase(T, options = {}) {
+	return Intrinsic(T, "Lowercase", options);
+}
+
+//#endregion
+export { Lowercase };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.js

@@ -0,0 +1,10 @@
+import { Intrinsic } from "./intrinsic.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/uncapitalize.mjs
+/** `[Json]` Intrinsic function to Uncapitalize LiteralString types */
+function Uncapitalize(T, options = {}) {
+	return Intrinsic(T, "Uncapitalize", options);
+}
+
+//#endregion
+export { Uncapitalize };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.js

@@ -0,0 +1,10 @@
+import { Intrinsic } from "./intrinsic.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/intrinsic/uppercase.mjs
+/** `[Json]` Intrinsic function to Uppercase LiteralString types */
+function Uppercase(T, options = {}) {
+	return Intrinsic(T, "Uppercase", options);
+}
+
+//#endregion
+export { Uppercase };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/iterator/index.js

@@ -0,0 +1,3 @@
+import { Iterator } from "./iterator.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.js

@@ -0,0 +1,16 @@
+import { CreateType } from "../create/type.js";
+import { Kind } from "../symbols/symbols.js";
+import "../symbols/index.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/iterator/iterator.mjs
+/** `[JavaScript]` Creates an Iterator type */
+function Iterator(items, options) {
+	return CreateType({
+		[Kind]: "Iterator",
+		type: "Iterator",
+		items
+	}, options);
+}
+
+//#endregion
+export { Iterator };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/keyof/index.js

@@ -0,0 +1,6 @@
+import { KeyOfPropertyKeys } from "./keyof-property-keys.js";
+import { KeyOf, KeyOfPropertyKeysToRest } from "./keyof.js";
+import { KeyOfFromMappedResult } from "./keyof-from-mapped-result.js";
+import "./keyof-property-entries.js";
+
+export {  };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.js

@@ -0,0 +1,21 @@
+import { Clone } from "../clone/value.js";
+import { MappedResult } from "../mapped/mapped-result.js";
+import "../mapped/index.js";
+import { KeyOf } from "./keyof.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-from-mapped-result.mjs
+function FromProperties(properties, options) {
+	const result = {};
+	for (const K2 of globalThis.Object.getOwnPropertyNames(properties)) result[K2] = KeyOf(properties[K2], Clone(options));
+	return result;
+}
+function FromMappedResult(mappedResult, options) {
+	return FromProperties(mappedResult.properties, options);
+}
+function KeyOfFromMappedResult(mappedResult, options) {
+	const properties = FromMappedResult(mappedResult, options);
+	return MappedResult(properties);
+}
+
+//#endregion
+export { KeyOfFromMappedResult };

package/dist/node_modules/.pnpm/@sinclair_typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-entries.js

@@ -0,0 +1,17 @@
+import { IndexFromPropertyKeys } from "../indexed/indexed.js";
+import { KeyOfPropertyKeys } from "./keyof-property-keys.js";
+
+//#region ../node_modules/.pnpm/@sinclair+typebox@0.34.41/node_modules/@sinclair/typebox/build/esm/type/keyof/keyof-property-entries.mjs
+/**
+* `[Utility]` Resolves an array of keys and schemas from the given schema. This method is faster
+* than obtaining the keys and resolving each individually via indexing. This method was written
+* accellerate Intersect and Union encoding.
+*/
+function KeyOfPropertyEntries(schema) {
+	const keys = KeyOfPropertyKeys(schema);
+	const schemas = IndexFromPropertyKeys(schema, keys);
+	return keys.map((_, index) => [keys[index], schemas[index]]);
+}
+
+//#endregion
+export {  };