@openclaw/google-meet 2026.9.3 → 2026.9.5

package/node_modules/typebox/build/schema/intern/intern.mjs

@@ -0,0 +1,293 @@
+import { Arguments } from '../../system/arguments/index.mjs';
+import { Hashing, Memory } from '../../system/index.mjs';
+import * as Schema from '../types/index.mjs';
+import * as Stack from '../engine/_stack.mjs';
+import { Guard } from '../../guard/index.mjs';
+import { Resolve } from '../resolve/index.mjs';
+// ----------------------------------------------------------------
+// UnresolvableRef
+// ----------------------------------------------------------------
+function UnresolvableRef(ref) {
+    throw Error(`UnresolvableRef '${ref}'`);
+}
+// ----------------------------------------------------------------
+// HashKey
+// ----------------------------------------------------------------
+function HashKey(schema) {
+    return `x-${Hashing.Hash(schema)}`;
+}
+// ----------------------------------------------------------------
+// AdditionalItems
+// ----------------------------------------------------------------
+function FromAdditionalItems(context, schema) {
+    return FromSchema(context, schema.additionalItems);
+}
+// ----------------------------------------------------------------
+// AdditionalProperties
+// ----------------------------------------------------------------
+function FromAdditionalProperties(context, schema) {
+    return FromSchema(context, schema.additionalProperties);
+}
+// ----------------------------------------------------------------
+// AllOf
+// ----------------------------------------------------------------
+function FromAllOf(context, schema) {
+    return schema.allOf.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// AnyOf
+// ----------------------------------------------------------------
+function FromAnyOf(context, schema) {
+    return schema.anyOf.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// Contains
+// ----------------------------------------------------------------
+function FromContains(context, schema) {
+    return FromSchema(context, schema.contains);
+}
+// ----------------------------------------------------------------
+// DependentSchemas
+// ----------------------------------------------------------------
+function FromDependentSchemas(context, schema) {
+    return Guard.Keys(schema.dependentSchemas).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.dependentSchemas[key]) }), {});
+}
+// ----------------------------------------------------------------
+// Else
+// ----------------------------------------------------------------
+function FromElse(context, schema) {
+    return FromSchema(context, schema.else);
+}
+// ----------------------------------------------------------------
+// If
+// ----------------------------------------------------------------
+function FromIf(context, schema) {
+    return FromSchema(context, schema.if);
+}
+// ----------------------------------------------------------------
+// Items
+// ----------------------------------------------------------------
+function FromItems(context, schema) {
+    return Schema.IsItemsSized(schema) ? FromItemsSized(context, schema) : FromItemsUnsized(context, schema);
+}
+// ----------------------------------------------------------------
+// ItemsSized
+// ----------------------------------------------------------------
+function FromItemsSized(context, schema) {
+    return schema.items.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// ItemsUnsized
+// ----------------------------------------------------------------
+function FromItemsUnsized(context, schema) {
+    return FromSchema(context, schema.items);
+}
+// ----------------------------------------------------------------
+// Not
+// ----------------------------------------------------------------
+function FromNot(context, schema) {
+    return FromSchema(context, schema.not);
+}
+// ----------------------------------------------------------------
+// OneOf
+// ----------------------------------------------------------------
+function FromOneOf(context, schema) {
+    return schema.oneOf.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// PatternProperties
+// ----------------------------------------------------------------
+function FromPatternProperties(context, schema) {
+    return Guard.Keys(schema.patternProperties).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.patternProperties[key]) }), {});
+}
+// ----------------------------------------------------------------
+// PrefixItems
+// ----------------------------------------------------------------
+function FromPrefixItems(context, schema) {
+    return schema.prefixItems.map((inner) => FromSchema(context, inner));
+}
+// ----------------------------------------------------------------
+// Properties
+// ----------------------------------------------------------------
+function FromProperties(context, schema) {
+    return Guard.Keys(schema.properties).reduce((result, key) => ({ ...result, [key]: FromSchema(context, schema.properties[key]) }), {});
+}
+// ----------------------------------------------------------------
+// PropertyNames
+// ----------------------------------------------------------------
+function FromPropertyNames(context, schema) {
+    return FromSchema(context, schema.propertyNames);
+}
+// ----------------------------------------------------------------
+// Ref
+// ----------------------------------------------------------------
+function ResolveRef(stack, ref) {
+    const result = Resolve.Ref(stack, { $ref: ref });
+    return { schema: result.schema ?? UnresolvableRef(ref), stack: result.stack };
+}
+// ----------------------------------------------------------------
+// DynamicRef
+// ----------------------------------------------------------------
+function ResolveDynamicRef(stack, schema) {
+    return Resolve.DynamicRef(stack, schema) ?? UnresolvableRef(schema.$dynamicRef);
+}
+// ----------------------------------------------------------------
+// RecursiveRef
+// ----------------------------------------------------------------
+function ResolveRecursiveRef(stack, schema) {
+    return Resolve.RecursiveRef(stack, schema) ?? UnresolvableRef(schema.$recursiveRef);
+}
+// ----------------------------------------------------------------
+// FromResolvedRef (shared logic for Ref, DynamicRef, RecursiveRef)
+// ----------------------------------------------------------------
+function FromResolvedRef(context, target, nextStack) {
+    const nextContext = { ...context, stack: nextStack };
+    const resolving = context.resolving.get(target);
+    if (Guard.IsUndefined(resolving))
+        return FromSchema(nextContext, target);
+    // Target is mid-intern, so this is a cycle (point at its reserved placeholder)
+    resolving.used = true;
+    return { $ref: `#/$defs/${resolving.key}` };
+}
+// ----------------------------------------------------------------
+// FromRef
+// ----------------------------------------------------------------
+function FromRef(context, schema) {
+    // Resolve target off the current traversal stack, carrying forward any resource crossing
+    const { schema: target, stack } = ResolveRef(context.stack, schema.$ref);
+    return FromResolvedRef(context, target, stack);
+}
+// ----------------------------------------------------------------
+// FromDynamicRef
+// ----------------------------------------------------------------
+function FromDynamicRef(context, schema) {
+    // Resolve target off the current traversal stack (dynamic scope depends on anchors seen so far)
+    const target = ResolveDynamicRef(context.stack, schema);
+    return FromResolvedRef(context, target, { ...context.stack, pendingResource: true });
+}
+// ----------------------------------------------------------------
+// FromRecursiveRef
+// ----------------------------------------------------------------
+function FromRecursiveRef(context, schema) {
+    // Resolve target off the current traversal stack (recursive scope depends on the path taken so far)
+    const target = ResolveRecursiveRef(context.stack, schema);
+    return FromResolvedRef(context, target, { ...context.stack, pendingResource: true });
+}
+// ----------------------------------------------------------------
+// Then
+// ----------------------------------------------------------------
+function FromThen(context, schema) {
+    return FromSchema(context, schema.then);
+}
+// ----------------------------------------------------------------
+// UnevaluatedItems
+// ----------------------------------------------------------------
+function FromUnevaluatedItems(context, schema) {
+    return FromSchema(context, schema.unevaluatedItems);
+}
+// ----------------------------------------------------------------
+// UnevaluatedProperties
+// ----------------------------------------------------------------
+function FromUnevaluatedProperties(context, schema) {
+    return FromSchema(context, schema.unevaluatedProperties);
+}
+// ----------------------------------------------------------------
+// SchemaObject
+// ----------------------------------------------------------------
+function FromSchemaObject(context, schema) {
+    // Reference-style schemas resolve to another node and cannot contain other keywords
+    if (Schema.IsRef(schema))
+        return FromRef(context, schema);
+    if (Schema.IsDynamicRef(schema))
+        return FromDynamicRef(context, schema);
+    if (Schema.IsRecursiveRef(schema))
+        return FromRecursiveRef(context, schema);
+    // Check if the schema has already been resolved
+    const existing = resolved.get(schema);
+    if (!Guard.IsUndefined(existing))
+        return existing;
+    // Reserve a placeholder key in case a nested ref cycles back to this schema
+    const reservation = { key: `x-ref-${context.resolving.size}`, used: false };
+    context.resolving.set(schema, reservation);
+    // Intern each subschema
+    const remapped = {
+        ...(Schema.IsRefine(schema) ? { ['~refine']: schema['~refine'] } : {}),
+        ...(Schema.IsAdditionalItems(schema) ? { additionalItems: FromAdditionalItems(context, schema) } : {}),
+        ...(Schema.IsAdditionalProperties(schema) ? { additionalProperties: FromAdditionalProperties(context, schema) } : {}),
+        ...(Schema.IsAllOf(schema) ? { allOf: FromAllOf(context, schema) } : {}),
+        ...(Schema.IsAnyOf(schema) ? { anyOf: FromAnyOf(context, schema) } : {}),
+        ...(Schema.IsContains(schema) ? { contains: FromContains(context, schema) } : {}),
+        ...(Schema.IsDependentSchemas(schema) ? { dependentSchemas: FromDependentSchemas(context, schema) } : {}),
+        ...(Schema.IsElse(schema) ? { else: FromElse(context, schema) } : {}),
+        ...(Schema.IsIf(schema) ? { if: FromIf(context, schema) } : {}),
+        ...(Schema.IsItems(schema) ? { items: FromItems(context, schema) } : {}),
+        ...(Schema.IsNot(schema) ? { not: FromNot(context, schema) } : {}),
+        ...(Schema.IsOneOf(schema) ? { oneOf: FromOneOf(context, schema) } : {}),
+        ...(Schema.IsPatternProperties(schema) ? { patternProperties: FromPatternProperties(context, schema) } : {}),
+        ...(Schema.IsPrefixItems(schema) ? { prefixItems: FromPrefixItems(context, schema) } : {}),
+        ...(Schema.IsProperties(schema) ? { properties: FromProperties(context, schema) } : {}),
+        ...(Schema.IsPropertyNames(schema) ? { propertyNames: FromPropertyNames(context, schema) } : {}),
+        ...(Schema.IsThen(schema) ? { then: FromThen(context, schema) } : {}),
+        ...(Schema.IsUnevaluatedItems(schema) ? { unevaluatedItems: FromUnevaluatedItems(context, schema) } : {}),
+        ...(Schema.IsUnevaluatedProperties(schema) ? { unevaluatedProperties: FromUnevaluatedProperties(context, schema) } : {})
+    };
+    context.resolving.delete(schema);
+    // Discard resolution keywords and finalize the interned schema
+    const interned = Memory.Discard(Memory.Assign(schema, remapped), ['$id', '$defs', '$anchor', '$dynamicAnchor', '$recursionAnchor']);
+    const key = reservation.used ? reservation.key : HashKey(interned);
+    registry.set(key, interned);
+    // Result
+    const result = { $ref: `#/$defs/${key}` };
+    resolved.set(schema, result);
+    return result;
+}
+// ----------------------------------------------------------------
+// SchemaBoolean
+// ----------------------------------------------------------------
+function FromSchemaBoolean(_context, schema) {
+    // Finalize and register the result
+    const key = HashKey(schema);
+    registry.set(key, schema);
+    // Result
+    const result = { $ref: `#/$defs/${key}` };
+    resolved.set(schema, result);
+    return result;
+}
+// ----------------------------------------------------------------
+// Schema
+// ----------------------------------------------------------------
+function FromSchema(context, schema) {
+    const next = { ...context, stack: Stack.NextStack(context.stack, schema) };
+    return Schema.IsSchemaBoolean(schema) ? FromSchemaBoolean(next, schema) : FromSchemaObject(next, schema);
+}
+// ----------------------------------------------------------------
+// BooleanEntry
+// ----------------------------------------------------------------
+function BooleanEntry(schema) {
+    const key = HashKey(schema);
+    return { $ref: `#/$defs/${key}`, $defs: { [key]: schema } };
+}
+// ----------------------------------------------------------------
+// Module-level accumulator state
+// ----------------------------------------------------------------
+const registry = new Map();
+const resolved = new Map();
+/** (Experimental) This function restructures the schema such that each distinct sub-schema is stored exactly once in a $defs object and keyed by content hash. */
+export function Intern(...args) {
+    const [context, schema] = Arguments.Match(args, {
+        2: (context, schema) => [context, schema],
+        1: (schema) => [{}, schema]
+    });
+    registry.clear();
+    resolved.clear();
+    if (Schema.IsSchemaBoolean(schema))
+        return BooleanEntry(schema);
+    const defs = Schema.IsDefs(schema) ? schema.$defs : {};
+    const rootStack = Stack.Stack({ ...context, ...defs }, schema);
+    const { schema: entry, stack } = Schema.IsRef(schema) ? ResolveRef(Stack.NextStack(rootStack, schema), schema.$ref) : { schema, stack: rootStack };
+    if (Schema.IsSchemaBoolean(entry))
+        return BooleanEntry(entry);
+    const ref_context = { stack, resolving: new Map() };
+    const result = FromSchema(ref_context, entry);
+    return { $ref: result.$ref, $defs: Object.fromEntries(registry) };
+}

package/node_modules/typebox/build/schema/meta/draft_2019_09.d.mts

@@ -0,0 +1,2 @@
+import type { XMetaSchemaObject } from './schema.mjs';
+export declare const Draft_2019_09: XMetaSchemaObject;

package/node_modules/typebox/build/schema/meta/draft_2019_09.mjs

@@ -0,0 +1,288 @@
+export const Draft_2019_09 = {
+    '$schema': 'https://json-schema.org/draft/2019-09/schema',
+    '$id': 'https://json-schema.org/draft/2019-09/schema',
+    '$vocabulary': {
+        'https://json-schema.org/draft/2019-09/vocab/core': true,
+        'https://json-schema.org/draft/2019-09/vocab/applicator': true,
+        'https://json-schema.org/draft/2019-09/vocab/validation': true,
+        'https://json-schema.org/draft/2019-09/vocab/meta-data': true,
+        'https://json-schema.org/draft/2019-09/vocab/format': false,
+        'https://json-schema.org/draft/2019-09/vocab/content': true
+    },
+    '$recursiveAnchor': true,
+    'title': 'Core and Validation specifications meta-schema',
+    'allOf': [
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/core',
+            '$recursiveAnchor': true,
+            'title': 'Core vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                '$id': {
+                    'type': 'string',
+                    'format': 'uri-reference',
+                    '$comment': 'Non-empty fragments not allowed.',
+                    'pattern': '^[^#]*#?$'
+                },
+                '$schema': {
+                    'type': 'string',
+                    'format': 'uri'
+                },
+                '$anchor': {
+                    'type': 'string',
+                    'pattern': '^[A-Za-z][-A-Za-z0-9.:_]*$'
+                },
+                '$ref': {
+                    'type': 'string',
+                    'format': 'uri-reference'
+                },
+                '$recursiveRef': {
+                    'type': 'string',
+                    'format': 'uri-reference'
+                },
+                '$recursiveAnchor': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                '$vocabulary': {
+                    'type': 'object',
+                    'propertyNames': {
+                        'type': 'string',
+                        'format': 'uri'
+                    },
+                    'additionalProperties': {
+                        'type': 'boolean'
+                    }
+                },
+                '$comment': {
+                    'type': 'string'
+                },
+                '$defs': {
+                    'type': 'object',
+                    'additionalProperties': { '$recursiveRef': '#' },
+                    'default': {}
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/applicator',
+            '$recursiveAnchor': true,
+            'title': 'Applicator vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'additionalItems': { '$recursiveRef': '#' },
+                'unevaluatedItems': { '$recursiveRef': '#' },
+                'items': {
+                    'anyOf': [
+                        { '$recursiveRef': '#' },
+                        { '$ref': '#/$defs/schemaArray' }
+                    ]
+                },
+                'contains': { '$recursiveRef': '#' },
+                'additionalProperties': { '$recursiveRef': '#' },
+                'unevaluatedProperties': { '$recursiveRef': '#' },
+                'properties': {
+                    'type': 'object',
+                    'additionalProperties': { '$recursiveRef': '#' },
+                    'default': {}
+                },
+                'patternProperties': {
+                    'type': 'object',
+                    'additionalProperties': { '$recursiveRef': '#' },
+                    'propertyNames': { 'format': 'regex' },
+                    'default': {}
+                },
+                'dependentSchemas': {
+                    'type': 'object',
+                    'additionalProperties': {
+                        '$recursiveRef': '#'
+                    }
+                },
+                'propertyNames': { '$recursiveRef': '#' },
+                'if': { '$recursiveRef': '#' },
+                'then': { '$recursiveRef': '#' },
+                'else': { '$recursiveRef': '#' },
+                'allOf': { '$ref': '#/$defs/schemaArray' },
+                'anyOf': { '$ref': '#/$defs/schemaArray' },
+                'oneOf': { '$ref': '#/$defs/schemaArray' },
+                'not': { '$recursiveRef': '#' }
+            },
+            '$defs': {
+                'schemaArray': {
+                    'type': 'array',
+                    'minItems': 1,
+                    'items': { '$recursiveRef': '#' }
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/validation',
+            '$recursiveAnchor': true,
+            'title': 'Validation vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'multipleOf': {
+                    'type': 'number',
+                    'exclusiveMinimum': 0
+                },
+                'maximum': {
+                    'type': 'number'
+                },
+                'exclusiveMaximum': {
+                    'type': 'number'
+                },
+                'minimum': {
+                    'type': 'number'
+                },
+                'exclusiveMinimum': {
+                    'type': 'number'
+                },
+                'maxLength': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minLength': { '$ref': '#/$defs/nonNegativeIntegerDefault0' },
+                'pattern': {
+                    'type': 'string',
+                    'format': 'regex'
+                },
+                'maxItems': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minItems': { '$ref': '#/$defs/nonNegativeIntegerDefault0' },
+                'uniqueItems': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'maxContains': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minContains': {
+                    '$ref': '#/$defs/nonNegativeInteger',
+                    'default': 1
+                },
+                'maxProperties': { '$ref': '#/$defs/nonNegativeInteger' },
+                'minProperties': { '$ref': '#/$defs/nonNegativeIntegerDefault0' },
+                'required': { '$ref': '#/$defs/stringArray' },
+                'dependentRequired': {
+                    'type': 'object',
+                    'additionalProperties': {
+                        '$ref': '#/$defs/stringArray'
+                    }
+                },
+                'const': true,
+                'enum': {
+                    'type': 'array',
+                    'items': true
+                },
+                'type': {
+                    'anyOf': [
+                        { '$ref': '#/$defs/simpleTypes' },
+                        {
+                            'type': 'array',
+                            'items': { '$ref': '#/$defs/simpleTypes' },
+                            'minItems': 1,
+                            'uniqueItems': true
+                        }
+                    ]
+                }
+            },
+            '$defs': {
+                'nonNegativeInteger': {
+                    'type': 'integer',
+                    'minimum': 0
+                },
+                'nonNegativeIntegerDefault0': {
+                    '$ref': '#/$defs/nonNegativeInteger',
+                    'default': 0
+                },
+                'simpleTypes': {
+                    'enum': [
+                        'array',
+                        'boolean',
+                        'integer',
+                        'null',
+                        'number',
+                        'object',
+                        'string'
+                    ]
+                },
+                'stringArray': {
+                    'type': 'array',
+                    'items': { 'type': 'string' },
+                    'uniqueItems': true,
+                    'default': []
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/meta-data',
+            '$recursiveAnchor': true,
+            'title': 'Meta-data vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'title': {
+                    'type': 'string'
+                },
+                'description': {
+                    'type': 'string'
+                },
+                'default': true,
+                'deprecated': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'readOnly': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'writeOnly': {
+                    'type': 'boolean',
+                    'default': false
+                },
+                'examples': {
+                    'type': 'array',
+                    'items': true
+                }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/format',
+            '$recursiveAnchor': true,
+            'title': 'Format vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'format': { 'type': 'string' }
+            }
+        },
+        {
+            '$schema': 'https://json-schema.org/draft/2019-09/schema',
+            '$id': 'https://json-schema.org/draft/2019-09/meta/content',
+            '$recursiveAnchor': true,
+            'title': 'Content vocabulary meta-schema',
+            'type': ['object', 'boolean'],
+            'properties': {
+                'contentMediaType': { 'type': 'string' },
+                'contentEncoding': { 'type': 'string' },
+                'contentSchema': { '$recursiveRef': '#' }
+            }
+        }
+    ],
+    'type': ['object', 'boolean'],
+    'properties': {
+        'definitions': {
+            '$comment': 'While no longer an official keyword as it is replaced by $defs, this keyword is retained in the meta-schema to prevent incompatible extensions as it remains in common use.',
+            'type': 'object',
+            'additionalProperties': { '$recursiveRef': '#' },
+            'default': {}
+        },
+        'dependencies': {
+            '$comment': '"dependencies" is no longer a keyword, but schema authors should avoid redefining it to facilitate a smooth transition to "dependentSchemas" and "dependentRequired"',
+            'type': 'object',
+            'additionalProperties': {
+                'anyOf': [
+                    { '$recursiveRef': '#' },
+                    { '$ref': 'meta/validation#/$defs/stringArray' }
+                ]
+            }
+        }
+    }
+};

package/node_modules/typebox/build/schema/meta/draft_2020_12.d.mts

@@ -0,0 +1,2 @@
+import type { XMetaSchemaObject } from './schema.mjs';
+export declare const Draft_2020_12: XMetaSchemaObject;