@astrofoundry/pi-astro 0.16.1 → 0.18.1

package/node_modules/typebox/build/schema/types/oneOf.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XOneOf<OneOf extends XSchema[] = XSchema[]> {
-    oneOf: OneOf;
-}
-/**
- * Returns true if the schema contains a valid oneOf property
- * @specification Json Schema 7
- */
-export declare function IsOneOf(schema: XSchemaObject): schema is XOneOf;

package/node_modules/typebox/build/schema/types/oneOf.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid oneOf property
- * @specification Json Schema 7
- */
-export function IsOneOf(schema) {
-    return Guard.HasPropertyKey(schema, 'oneOf')
-        && Guard.IsArray(schema.oneOf)
-        && schema.oneOf.every(value => IsSchema(value));
-}

package/node_modules/typebox/build/schema/types/pattern.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XPattern<Pattern extends string | RegExp = string | RegExp> {
-    pattern: Pattern;
-}
-/**
- * Returns true if the schema contains a valid pattern property
- * @specification Json Schema 7
- */
-export declare function IsPattern(schema: XSchemaObject): schema is XPattern;

package/node_modules/typebox/build/schema/types/pattern.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid pattern property
- * @specification Json Schema 7
- */
-export function IsPattern(schema) {
-    return Guard.HasPropertyKey(schema, 'pattern')
-        && (Guard.IsString(schema.pattern)
-            || schema.pattern instanceof RegExp);
-}

package/node_modules/typebox/build/schema/types/patternProperties.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XPatternProperties<PatternProperties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
-    patternProperties: PatternProperties;
-}
-/**
- * Returns true if the schema contains a valid patternProperties property
- * @specification Json Schema 7
- */
-export declare function IsPatternProperties(schema: XSchemaObject): schema is XPatternProperties;

package/node_modules/typebox/build/schema/types/patternProperties.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid patternProperties property
- * @specification Json Schema 7
- */
-export function IsPatternProperties(schema) {
-    return Guard.HasPropertyKey(schema, 'patternProperties')
-        && Guard.IsObject(schema.patternProperties)
-        && Object.values(schema.patternProperties).every(value => IsSchema(value));
-}

package/node_modules/typebox/build/schema/types/prefixItems.d.mts

@@ -1,8 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XPrefixItems<PrefixItems extends XSchema[] = XSchema[]> {
-    prefixItems: PrefixItems;
-}
-/**
- * Returns true if the schema contains a valid prefixItems property
- */
-export declare function IsPrefixItems(schema: XSchemaObject): schema is XPrefixItems;

package/node_modules/typebox/build/schema/types/prefixItems.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid prefixItems property
- */
-export function IsPrefixItems(schema) {
-    return Guard.HasPropertyKey(schema, 'prefixItems')
-        && Guard.IsArray(schema.prefixItems)
-        && schema.prefixItems.every(schema => IsSchema(schema));
-}

package/node_modules/typebox/build/schema/types/properties.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XProperties<Properties extends Record<PropertyKey, XSchema> = Record<PropertyKey, XSchema>> {
-    properties: Properties;
-}
-/**
- * Returns true if the schema contains a valid properties property
- * @specification Json Schema 7
- */
-export declare function IsProperties(schema: XSchemaObject): schema is XProperties;

package/node_modules/typebox/build/schema/types/properties.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid properties property
- * @specification Json Schema 7
- */
-export function IsProperties(schema) {
-    return Guard.HasPropertyKey(schema, 'properties')
-        && Guard.IsObject(schema.properties)
-        && Object.values(schema.properties).every(value => IsSchema(value));
-}

package/node_modules/typebox/build/schema/types/propertyNames.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XPropertyNames<PropertyNames extends XSchema = XSchema> {
-    propertyNames: PropertyNames;
-}
-/**
- * Returns true if the schema contains a valid propertyNames property
- * @specification Json Schema 7
- */
-export declare function IsPropertyNames(schema: XSchemaObject): schema is XPropertyNames;

package/node_modules/typebox/build/schema/types/propertyNames.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid propertyNames property
- * @specification Json Schema 7
- */
-export function IsPropertyNames(schema) {
-    return Guard.HasPropertyKey(schema, 'propertyNames')
-        && (Guard.IsObject(schema.propertyNames)
-            || IsSchema(schema.propertyNames));
-}

package/node_modules/typebox/build/schema/types/recursiveAnchor.d.mts

@@ -1,12 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XRecursiveAnchor<Anchor extends string = string> {
-    $recursiveAnchor: Anchor;
-}
-/**
- * Returns true if the schema contains a valid $recursiveAnchor property
- */
-export declare function IsRecursiveAnchor(schema: XSchemaObject): schema is XRecursiveAnchor;
-/**
- * Returns true if the schema contains a valid $recursiveAnchor property that is true
- */
-export declare function IsRecursiveAnchorTrue(schema: XSchemaObject): schema is XRecursiveAnchor;

package/node_modules/typebox/build/schema/types/recursiveAnchor.mjs

@@ -1,19 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid $recursiveAnchor property
- */
-export function IsRecursiveAnchor(schema) {
-    return Guard.HasPropertyKey(schema, '$recursiveAnchor')
-        && Guard.IsBoolean(schema.$recursiveAnchor);
-}
-/**
- * Returns true if the schema contains a valid $recursiveAnchor property that is true
- */
-export function IsRecursiveAnchorTrue(schema) {
-    return IsRecursiveAnchor(schema)
-        && Guard.IsEqual(schema.$recursiveAnchor, true);
-}

package/node_modules/typebox/build/schema/types/recursiveRef.d.mts

@@ -1,8 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XRecursiveRef<Ref extends string = string> {
-    $recursiveRef: Ref;
-}
-/**
- * Returns true if the schema contains a valid $recursiveRef property
- */
-export declare function IsRecursiveRef(schema: XSchemaObject): schema is XRecursiveRef;

package/node_modules/typebox/build/schema/types/recursiveRef.mjs

@@ -1,12 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid $recursiveRef property
- */
-export function IsRecursiveRef(schema) {
-    return Guard.HasPropertyKey(schema, '$recursiveRef')
-        && Guard.IsString(schema.$recursiveRef);
-}

package/node_modules/typebox/build/schema/types/ref.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XRef<Ref extends string = string> {
-    $ref: Ref;
-}
-/**
- * Returns true if the schema contains a valid $ref property
- * @specification Json Schema 7
- */
-export declare function IsRef(schema: XSchemaObject): schema is XRef;

package/node_modules/typebox/build/schema/types/ref.mjs

@@ -1,13 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid $ref property
- * @specification Json Schema 7
- */
-export function IsRef(schema) {
-    return Guard.HasPropertyKey(schema, '$ref')
-        && Guard.IsString(schema.$ref);
-}

package/node_modules/typebox/build/schema/types/required.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XRequired<Required extends string[] = string[]> {
-    required: Required;
-}
-/**
- * Returns true if the schema contains a valid required property
- * @specification Json Schema 7
- */
-export declare function IsRequired(schema: XSchemaObject): schema is XRequired;

package/node_modules/typebox/build/schema/types/required.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid required property
- * @specification Json Schema 7
- */
-export function IsRequired(schema) {
-    return Guard.HasPropertyKey(schema, 'required')
-        && Guard.IsArray(schema.required)
-        && schema.required.every(value => Guard.IsString(value));
-}

package/node_modules/typebox/build/schema/types/schema.d.mts

@@ -1,9 +0,0 @@
-export type XSchemaObject = object;
-/** Returns true if this value is object like */
-export declare function IsSchemaObject(value: unknown): value is XSchemaObject;
-export type XSchemaBoolean = boolean;
-/** Returns true if this value is a boolean */
-export declare function IsBooleanSchema(value: unknown): value is XSchemaBoolean;
-export type XSchema = XSchemaObject | XSchemaBoolean;
-/** Returns true if this value is schema like */
-export declare function IsSchema(value: unknown): value is XSchema;

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

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-/** Returns true if this value is object like */
-export function IsSchemaObject(value) {
-    return Guard.IsObject(value) && !Guard.IsArray(value);
-}
-/** Returns true if this value is a boolean */
-export function IsBooleanSchema(value) {
-    return Guard.IsBoolean(value);
-}
-/** Returns true if this value is schema like */
-export function IsSchema(value) {
-    return IsSchemaObject(value) || IsBooleanSchema(value);
-}

package/node_modules/typebox/build/schema/types/then.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XThen<Then extends XSchema = XSchema> {
-    then: Then;
-}
-/**
- * Returns true if the schema contains a valid then property
- * @specification Json Schema 7
- */
-export declare function IsThen(schema: XSchemaObject): schema is XThen;

package/node_modules/typebox/build/schema/types/then.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid then property
- * @specification Json Schema 7
- */
-export function IsThen(schema) {
-    return Guard.HasPropertyKey(schema, 'then')
-        && IsSchema(schema.then);
-}

package/node_modules/typebox/build/schema/types/type.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XType<Type extends string | string[] = string | string[]> {
-    type: Type;
-}
-/**
- * Returns true if the schema contains a valid type property
- * @specification Json Schema 7
- */
-export declare function IsType(schema: XSchemaObject): schema is XType;

package/node_modules/typebox/build/schema/types/type.mjs

@@ -1,15 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid type property
- * @specification Json Schema 7
- */
-export function IsType(schema) {
-    return Guard.HasPropertyKey(schema, 'type')
-        && (Guard.IsString(schema.type)
-            || (Guard.IsArray(schema.type)
-                && schema.type.every(value => Guard.IsString(value))));
-}

package/node_modules/typebox/build/schema/types/unevaluatedItems.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XUnevaluatedItems<unevaluatedItems extends XSchema = XSchema> {
-    unevaluatedItems: XSchema;
-}
-/**
- * Returns true if the schema contains a valid unevaluatedItems property
- * @specification Json Schema 2019-09
- */
-export declare function IsUnevaluatedItems(schema: XSchemaObject): schema is XUnevaluatedItems;

package/node_modules/typebox/build/schema/types/unevaluatedItems.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid unevaluatedItems property
- * @specification Json Schema 2019-09
- */
-export function IsUnevaluatedItems(schema) {
-    return Guard.HasPropertyKey(schema, 'unevaluatedItems')
-        && IsSchema(schema.unevaluatedItems);
-}

package/node_modules/typebox/build/schema/types/unevaluatedProperties.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject, type XSchema } from './schema.mjs';
-export interface XUnevaluatedProperties<UnevaluatedProperties extends XSchema = XSchema> {
-    unevaluatedProperties: UnevaluatedProperties;
-}
-/**
- * Returns true if the schema contains a valid unevaluatedProperties property
- * @specification Json Schema 2019-09
- */
-export declare function IsUnevaluatedProperties(schema: XSchemaObject): schema is XUnevaluatedProperties;

package/node_modules/typebox/build/schema/types/unevaluatedProperties.mjs

@@ -1,14 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-import { IsSchema } from './schema.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid unevaluatedProperties property
- * @specification Json Schema 2019-09
- */
-export function IsUnevaluatedProperties(schema) {
-    return Guard.HasPropertyKey(schema, 'unevaluatedProperties')
-        && IsSchema(schema.unevaluatedProperties);
-}

package/node_modules/typebox/build/schema/types/uniqueItems.d.mts

@@ -1,9 +0,0 @@
-import { type XSchemaObject } from './schema.mjs';
-export interface XUniqueItems<UniqueItems extends boolean = boolean> {
-    uniqueItems: UniqueItems;
-}
-/**
- * Returns true if the schema contains a valid uniqueItems property
- * @specification Json Schema 7
- */
-export declare function IsUniqueItems(schema: XSchemaObject): schema is XUniqueItems;

package/node_modules/typebox/build/schema/types/uniqueItems.mjs

@@ -1,13 +0,0 @@
-// deno-fmt-ignore-file
-import { Guard } from '../../guard/index.mjs';
-// ------------------------------------------------------------------
-// Guard
-// ------------------------------------------------------------------
-/**
- * Returns true if the schema contains a valid uniqueItems property
- * @specification Json Schema 7
- */
-export function IsUniqueItems(schema) {
-    return Guard.HasPropertyKey(schema, 'uniqueItems')
-        && Guard.IsBoolean(schema.uniqueItems);
-}

package/node_modules/typebox/build/system/arguments/arguments.d.mts

@@ -1,5 +0,0 @@
-/**
- * Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
- * are parsed using argument length only.
- */
-export declare function Match<Result>(args: unknown[], match: Record<number, (...args: unknown[]) => unknown>): Result;

package/node_modules/typebox/build/system/arguments/arguments.mjs

@@ -1,9 +0,0 @@
-/**
- * Match arguments for overloaded functions that use the `...args: unknown[]` pattern. Arguments
- * are parsed using argument length only.
- */
-export function Match(args, match) {
-    return (match[args.length]?.(...args) ?? (() => {
-        throw Error('Invalid Arguments');
-    })());
-}

package/node_modules/typebox/build/system/arguments/index.d.mts

@@ -1 +0,0 @@
-export * as Arguments from './arguments.mjs';

package/node_modules/typebox/build/system/arguments/index.mjs

@@ -1 +0,0 @@
-export * as Arguments from './arguments.mjs';

package/node_modules/typebox/build/system/environment/environment.d.mts

@@ -1 +0,0 @@
-export * from './evaluate.mjs';

package/node_modules/typebox/build/system/environment/environment.mjs

@@ -1 +0,0 @@
-export * from './evaluate.mjs';

package/node_modules/typebox/build/system/environment/evaluate.d.mts

@@ -1,9 +0,0 @@
-/** Returns true if the environment supports dynamic JavaScript evaluation */
-export declare function CanEvaluate(): boolean;
-/**
- * Evaluates code in the current environment. This function will throw if the
- * environment Content-Security-Policy does not support `unsafe-eval`. Use the
- * Environment.CanEvaluate() to determine if the environment supports Evaluate
- * before calling this function.
- */
-export declare function Evaluate(...args: string[]): globalThis.Function;

package/node_modules/typebox/build/system/environment/evaluate.mjs

@@ -1,37 +0,0 @@
-import { Settings } from '../settings/index.mjs';
-import { Guard } from '../../guard/index.mjs';
-let supported = undefined;
-// ------------------------------------------------------------------
-// TryEvaluate
-// ------------------------------------------------------------------
-function TryEvaluate() {
-    try {
-        Evaluate('null')();
-        return true;
-    } // deno-coverage-ignore-start - unreachable in test-suite
-    catch {
-        return false;
-    }
-    // deno-coverage-ignore-stop
-}
-// ------------------------------------------------------------------
-// CanEvaluate
-// ------------------------------------------------------------------
-/** Returns true if the environment supports dynamic JavaScript evaluation */
-export function CanEvaluate() {
-    if (Guard.IsUndefined(supported))
-        supported = TryEvaluate();
-    return supported && Settings.Get().useAcceleration;
-}
-// ------------------------------------------------------------------
-// Evaluate
-// ------------------------------------------------------------------
-/**
- * Evaluates code in the current environment. This function will throw if the
- * environment Content-Security-Policy does not support `unsafe-eval`. Use the
- * Environment.CanEvaluate() to determine if the environment supports Evaluate
- * before calling this function.
- */
-export function Evaluate(...args) {
-    return new (globalThis.Function)(...args);
-}

package/node_modules/typebox/build/system/environment/index.d.mts

@@ -1 +0,0 @@
-export * as Environment from './environment.mjs';

package/node_modules/typebox/build/system/environment/index.mjs

@@ -1 +0,0 @@
-export * as Environment from './environment.mjs';

package/node_modules/typebox/build/system/hashing/hash.d.mts

@@ -1,4 +0,0 @@
-/** Generates a FNV1A-64 non cryptographic hash of the given value */
-export declare function HashCode(value: unknown): bigint;
-/** Generates a FNV1A-64 non cryptographic hash of the given value */
-export declare function Hash(value: unknown): string;