tungsten 0.7.2 → 0.8.0

package/dist-ti/Store/makeStore.d.ts

@@ -0,0 +1,53 @@
+// @tightscript-object-permissions
+import type { Key } from '../Key.js';
+import type { TungstenBaseStoreComponentAny } from '../Components.jsx';
+import type { ServerDataLoading } from './ServerDataLoading.js';
+import type { SubscribedElements } from './StoreSubscriptions.types.js';
+export declare const $trueStoreValue: unique symbol;
+export declare class StoreValueServer<T> implements TrueStoreValueInterface<T> {
+    #private;
+    readonly [$trueStoreValue] = true;
+    constructor(value: T, serverDataLoading: ServerDataLoading);
+    readonly get: () => T;
+    readonly sync: () => T;
+    readonly set: (newValue: T) => void;
+    readonly subscribe: () => void;
+    readonly unsubscribe: () => void;
+    readonly notify: <Fn extends ((value: T) => void)>(fn: Fn, element: TungstenBaseStoreComponentAny) => Fn;
+    readonly stopNotify: <Fn extends ((value: T) => void)>(fn: Fn, element: TungstenBaseStoreComponentAny) => Fn;
+    readonly stopNotifyAll: () => void;
+}
+export type NotifyFn<T> = (value: T) => void;
+export interface TrueStoreValueInterface<T> {
+    readonly [$trueStoreValue]: true;
+    readonly get: () => T;
+    readonly sync: (element: TungstenBaseStoreComponentAny) => T;
+    readonly set: (value: T) => void;
+    readonly subscribe: (element: TungstenBaseStoreComponentAny) => void;
+    readonly unsubscribe: (element: TungstenBaseStoreComponentAny) => void;
+    readonly notify: <Fn extends NotifyFn<T>>(fn: Fn, element: TungstenBaseStoreComponentAny) => Fn;
+    readonly stopNotify: <Fn extends NotifyFn<T>>(fn: Fn, element: TungstenBaseStoreComponentAny) => Fn;
+    readonly stopNotifyAll: (element: TungstenBaseStoreComponentAny) => void;
+}
+export type ReadonlyTrueStoreValue<T> = Omit<TrueStoreValueInterface<T>, 'set'>;
+export declare class StoreValue<T> implements TrueStoreValueInterface<T> {
+    #private;
+    readonly [$trueStoreValue] = true;
+    constructor(key: Key, value: T, subscribedElements: SubscribedElements);
+    readonly get: () => T;
+    readonly sync: (element: TungstenBaseStoreComponentAny) => T;
+    readonly set: (newValue: T) => void;
+    readonly subscribe: (element: TungstenBaseStoreComponentAny) => void;
+    readonly unsubscribe: (element: TungstenBaseStoreComponentAny) => void;
+    readonly notify: <Fn extends ((value: T) => void)>(fn: Fn, element: TungstenBaseStoreComponentAny) => Fn;
+    readonly stopNotify: <Fn extends ((value: T) => void)>(fn: Fn, element: TungstenBaseStoreComponentAny) => Fn;
+    readonly stopNotifyAll: (element: TungstenBaseStoreComponentAny) => void;
+}
+export type TrueStore<Schema> = {
+    [Property in keyof Schema]: StoreValue<Schema[Property]>;
+};
+export type ReadonlyTrueStore<Schema> = {
+    [Property in keyof Schema]: ReadonlyTrueStoreValue<Schema[Property]>;
+};
+export declare function makeStore: exact (<Schema extends object>(schema: Schema, subscribedElements: SubscribedElements, serverDataLoading?: ServerDataLoading | null) => TrueStore<Schema>);
+//# sourceMappingURL=makeStore.d.ts.map

package/dist-ti/Store/registerStore.d.ts

@@ -0,0 +1,13 @@
+// @tightscript-object-permissions
+import type { ComponentStore, TungstenBaseStoreComponent, TungstenBaseSimpleStoreComponent, TungstenBaseStatefulStoreComponent } from '../Components.jsx';
+import type { TrueStore } from './makeStore.js';
+import type { StoreSchemaClass } from './StoreSchemaClass.js';
+import { Instance } from '../Instance/Instance.js';
+type BaseStoreComponents = TungstenBaseStoreComponent<any, any, object> | TungstenBaseSimpleStoreComponent<any, any, object> | TungstenBaseStatefulStoreComponent<any, any, any, object>;
+type GetStoreFunctions<StoreSchema extends object> = {
+    getComponentStore: (element: BaseStoreComponents) => ComponentStore<StoreSchema>;
+    getStore: (instanceOrStores: Instance | TrueStore<unknown>[]) => TrueStore<StoreSchema>;
+};
+export declare function registerStore: exact (<StoreSchema extends object>(StoreSchema: StoreSchemaClass<StoreSchema>) => GetStoreFunctions<StoreSchema>);
+export {};
+//# sourceMappingURL=registerStore.d.ts.map

package/dist-ti/Store/storeCreators.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { BrandedStoreSchemaClass } from './StoreSchemaClass.js';
+export declare const storeSchemas: rw BrandedStoreSchemaClass<any>[];
+//# sourceMappingURL=storeCreators.d.ts.map

package/dist-ti/StoreBindVariable.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { ComponentStore } from './Components.jsx';
+export type StoreBindVariable<O extends ComponentStore<object>, K extends keyof O> = [O, K];
+//# sourceMappingURL=StoreBindVariable.d.ts.map

package/dist-ti/StyleProcessor.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { CssNames } from './CssNames.js';
+export type StyleProcessor = (style: TemplateStringsArray) => CssNames;
+//# sourceMappingURL=StyleProcessor.d.ts.map

package/dist-ti/TElement.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=TElement.d.ts.map

package/dist-ti/TungstenApp.d.ts

@@ -0,0 +1,27 @@
+// @tightscript-object-permissions
+import type { TungstenComponent } from './Components.jsx';
+import type { AppRoutes } from './routing/AppRoutes.js';
+type PrivateEnvValidator = never;
+type PublicEnvValidator = never;
+type TungstenAppOptions = {
+    rootComponent?: TungstenComponent;
+    routes?: AppRoutes<any>;
+    privateEnvValidator?: PrivateEnvValidator;
+    publicEnvValidator?: PublicEnvValidator;
+};
+export declare class TungstenApp {
+    rootComponent: undefined | TungstenComponent;
+    appRoutes: undefined | undefined | AppRoutes<any>;
+    privateEnvValidator: undefined | PrivateEnvValidator;
+    publicEnvValidator: undefined | PublicEnvValidator;
+    constructor(options: TungstenAppOptions);
+    setRootComponent: (rootComponent: TungstenComponent) => void;
+    setRoutes: (routes: AppRoutes<any>) => void;
+    setPrivateEnvValidator: (privateEnvValidator: PrivateEnvValidator) => void;
+    setPublicEnvValidator: (publicEnvValidator: PublicEnvValidator) => void;
+    start: ({ dev }: {
+        dev: boolean;
+    }) => rw Promise<void>;
+}
+export {};
+//# sourceMappingURL=TungstenApp.d.ts.map

package/dist-ti/TungstenAppOld.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=TungstenAppOld.d.ts.map

package/dist-ti/TungstenElement.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { AnyComponent } from './AnyComponent.js';
+export type TungstenElement = AnyComponent;
+//# sourceMappingURL=TungstenElement.d.ts.map

package/dist-ti/TungstenError.d.ts

@@ -0,0 +1,10 @@
+// @tightscript-object-permissions
+export declare class TungstenError extends Error {
+    name: string;
+    constructor(message: string);
+}
+export declare class TungstenProductionError extends TungstenError {
+    name: string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=TungstenError.d.ts.map

package/dist-ti/TungstenStyleObject.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export { CssNames as TungstenStyleObject } from './CssNames.js';
+//# sourceMappingURL=TungstenStyleObject.d.ts.map

package/dist-ti/__deproxy.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare function __deproxy: exact ((possibleProxy: unknown) => unknown);
+export declare const dead: exact typeof __deproxy;
+//# sourceMappingURL=__deproxy.d.ts.map

package/dist-ti/_client/RootComponent.d.ts

@@ -0,0 +1,5 @@
+// @tightscript-object-permissions
+import type { TungstenBaseComponentType } from '../Components.jsx';
+export declare const module: Record<string, TungstenBaseComponentType>;
+export declare const filename = "foo";
+//# sourceMappingURL=RootComponent.d.ts.map

package/dist-ti/_client/cjsHelpers.d.ts

@@ -0,0 +1,12 @@
+// @tightscript-object-permissions
+import type { JsonValue } from 'sxy-types';
+import type { Module } from '../CjsTypes.js';
+declare global {
+    interface Window {
+        __tungsten_cjs_import: (location: string) => Promise<{
+            [key: string]: any;
+        }>;
+    }
+}
+export declare function loadDeps: exact ((deps: string[]) => rw Promise<rw Record<string, r Module | JsonValue>>);
+//# sourceMappingURL=cjsHelpers.d.ts.map

package/dist-ti/_client/client.d.ts

@@ -0,0 +1,15 @@
+// @tightscript-object-permissions
+import type { InstanceConfig } from 'tungsten/Instance/InstanceConfig.js';
+declare module '../.tungsten.config.js' {
+    export default InstanceConfig;
+    export const fileVersions: Record<string, string> | undefined;
+    export const pipelineRegistration: boolean;
+}
+declare global {
+    interface Window {
+        __tungsten_hydrate__: Promise<any>;
+        __tungsten_prod__: boolean;
+        foo: number;
+    }
+}
+//# sourceMappingURL=client.d.ts.map

package/dist-ti/_client/hmr.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=hmr.d.ts.map

package/dist-ti/_client/liveReload.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=liveReload.d.ts.map

package/dist-ti/_client/liveReloadSource.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export type FullReload = (reason: string) => void;
+export declare function connectLiveReload: exact ((fullReload: FullReload) => EventSource);
+//# sourceMappingURL=liveReloadSource.d.ts.map

package/dist-ti/_client/rootComponentRelFilePath.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export {};
+//# sourceMappingURL=rootComponentRelFilePath.d.ts.map

package/dist-ti/_client/routes.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { AppRoutes } from '../routing/AppRoutes.js';
+export declare const routes: AppRoutes;
+//# sourceMappingURL=routes.d.ts.map

package/dist-ti/_testing/errorRoute.d.ts

@@ -0,0 +1,9 @@
+// @tightscript-object-permissions
+export declare const errorEndpoint: exact rw {
+    content: () => null;
+};
+export declare const errorRoute: exact r {
+    readonly content: () => null;
+    readonly path: 'error';
+};
+//# sourceMappingURL=errorRoute.d.ts.map

package/dist-ti/_testing/regexEquals.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function regexEquals: exact ((x: RegExp, y: RegExp) => boolean);
+//# sourceMappingURL=regexEquals.d.ts.map

package/dist-ti/_testing/should.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare const should: r Chai.Should;
+//# sourceMappingURL=should.d.ts.map

package/dist-ti/_testing/sxy-test-runner.types.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+export type It = (name: string, func: () => any) => any;
+export type DescribeArg = {
+    it: It;
+};
+//# sourceMappingURL=sxy-test-runner.types.d.ts.map

package/dist-ti/alive.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import { NoDeproxy } from './NoDeproxy.js';
+export declare function alive: exact ((v: unknown) => owned rw NoDeproxy);
+//# sourceMappingURL=alive.d.ts.map

package/dist-ti/api/ApiEndpoint.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { Request, Response, NextFunction } from 'express';
+export type ApiEndpoint = (req: Request, res: Response, next: NextFunction) => void;
+//# sourceMappingURL=ApiEndpoint.d.ts.map

package/dist-ti/api/ApiMethod.type.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export type ApiMethod = 'GET' | 'QUERY' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+//# sourceMappingURL=ApiMethod.type.d.ts.map

package/dist-ti/api/ApiRoute.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+import type { ApiEndpoint } from './ApiEndpoint.js';
+import type { ApiMethod } from './ApiMethod.type.js';
+export type ApiRoute = {
+    method: ApiMethod;
+    endpoint: ApiEndpoint;
+};
+//# sourceMappingURL=ApiRoute.d.ts.map

package/dist-ti/api/ApiRoutes.d.ts

@@ -0,0 +1,6 @@
+// @tightscript-object-permissions
+import type { ApiRoute } from './ApiRoute.js';
+export type ApiRoutes = {
+    [key: string]: ApiRoute;
+};
+//# sourceMappingURL=ApiRoutes.d.ts.map

package/dist-ti/api/Request.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export type { Request } from '../ReqRes.js';
+//# sourceMappingURL=Request.d.ts.map

package/dist-ti/api/Response.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export type { Response } from '../ReqRes.js';
+//# sourceMappingURL=Response.d.ts.map

package/dist-ti/api/getApiRoutes.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+import type { Mode } from '../Mode.js';
+import type { ApiRoutes } from './ApiRoutes.js';
+import type { FrameworkConfig } from '../FrameworkConfig.js';
+import type { CompilationInfo } from '../build/CompilationInfo.js';
+export declare function getApiRoutes: exact ((config: FrameworkConfig, compilationInfo: CompilationInfo, mode: Mode) => rw Promise<r ApiRoutes>);
+//# sourceMappingURL=getApiRoutes.d.ts.map

package/dist-ti/api/getExport.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { Mode } from '../Mode.js';
+export declare function getExport: exact ((filePath: string, relFile: string, mode?: Mode) => Promise<unknown>);
+//# sourceMappingURL=getExport.d.ts.map

package/dist-ti/api/getExportDev.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function getExportDev: exact ((filePathFull: string, relFile: string) => Promise<unknown>);
+//# sourceMappingURL=getExportDev.d.ts.map

package/dist-ti/appBuilder.d.ts

@@ -0,0 +1,75 @@
+// @tightscript-object-permissions
+import type { ReqRes, ReqResOrNull } from './ReqRes.js';
+import type { ComponentStore, ConstructPackage, TungstenComponentPropsBase, TungstenComponentSignalsConstraint, TungstenComponentStateConstraint } from './Components.jsx';
+import type { ComponentHelpers } from './componentHelpers.js';
+import type { MatchedRouteInfo } from './routing/MatchedRouteInfo.js';
+import type { ExactRoutesWithSettings } from './routing/Routes.js';
+import type { RoutesReturn } from './pipeline/pipeline.js';
+import type { NoDuplicatePaths, RoutesArray } from './routing/routesArray.js';
+import type { Serializable } from './routing/Serializable.js';
+import type { DataRedirect } from './routing/DataRedirect.js';
+import type { TrueStore } from './Store/makeStore.js';
+import type { Instance } from './Instance/Instance.js';
+import { TungstenBaseSimpleStoreComponent, TungstenBaseStatefulStoreComponent, TungstenSignalsComponent, TungstenSimpleComponent, TungstenStatefulComponent } from './Components.jsx';
+export type AppHelpers<C extends object, ND extends object, G extends object> = Omit<ComponentHelpers, 'context' | 'networkedData' | 'globalData'> & {
+    readonly context: C;
+    readonly networkedData: ND;
+    readonly globalData: G;
+};
+export declare abstract class AppSimpleComponent<C extends object, ND extends object, G extends object, P extends TungstenComponentPropsBase = TungstenComponentPropsBase, RD = undefined> extends TungstenSimpleComponent<P, RD> {
+    get tungsten(): AppHelpers<C, ND, G>;
+}
+export declare abstract class AppStatefulComponent<C extends object, ND extends object, G extends object, P extends TungstenComponentPropsBase, S extends TungstenComponentStateConstraint, RD = undefined> extends TungstenStatefulComponent<P, S, RD> {
+    get tungsten(): AppHelpers<C, ND, G>;
+}
+export declare abstract class AppSignalsComponent<C extends object, ND extends object, G extends object, P extends TungstenComponentPropsBase, Sg extends TungstenComponentSignalsConstraint, RD = undefined> extends TungstenSignalsComponent<P, Sg, RD> {
+    get tungsten(): AppHelpers<C, ND, G>;
+}
+export declare abstract class AppSimpleStoreComponent<C extends object, ND extends object, G extends object, St extends object, P extends TungstenComponentPropsBase = TungstenComponentPropsBase, RD = undefined> extends TungstenBaseSimpleStoreComponent<P, RD, St> {
+    store: ComponentStore<St>;
+    get tungsten(): AppHelpers<C, ND, G>;
+}
+export declare abstract class AppStatefulStoreComponent<C extends object, ND extends object, G extends object, St extends object, P extends TungstenComponentPropsBase, S extends TungstenComponentStateConstraint, RD = undefined> extends TungstenBaseStatefulStoreComponent<P, S, RD, St> {
+    store: ComponentStore<St>;
+    get tungsten(): AppHelpers<C, ND, G>;
+}
+type Statics<T> = Omit<T, 'prototype'>;
+export type AppComponents<C extends object, ND extends object, G extends object, St extends object | undefined> = {
+    SimpleComponent: (abstract new <P extends TungstenComponentPropsBase = TungstenComponentPropsBase, RD = undefined>(pkg: ConstructPackage<P, RD>) => AppSimpleComponent<C, ND, G, P, RD>) & Statics<typeof AppSimpleComponent>;
+    StatefulComponent: (abstract new <P extends TungstenComponentPropsBase = TungstenComponentPropsBase, S extends TungstenComponentStateConstraint = TungstenComponentStateConstraint, RD = undefined>(pkg: ConstructPackage<P, RD>) => AppStatefulComponent<C, ND, G, P, S, RD>) & Statics<typeof AppStatefulComponent>;
+    SignalsComponent: (abstract new <P extends TungstenComponentPropsBase = TungstenComponentPropsBase, Sg extends TungstenComponentSignalsConstraint = TungstenComponentSignalsConstraint, RD = undefined>(pkg: ConstructPackage<P, RD>) => AppSignalsComponent<C, ND, G, P, Sg, RD>) & Statics<typeof AppSignalsComponent>;
+} & (St extends object ? {
+    getStore: (instanceOrStores: Instance | TrueStore<unknown>[]) => TrueStore<St>;
+    SimpleStoreComponent: (abstract new <P extends TungstenComponentPropsBase = TungstenComponentPropsBase, RD = undefined>(pkg: ConstructPackage<P, RD>) => AppSimpleStoreComponent<C, ND, G, St, P, RD>) & Statics<typeof AppSimpleStoreComponent>;
+    StatefulStoreComponent: (abstract new <P extends TungstenComponentPropsBase = TungstenComponentPropsBase, S extends TungstenComponentStateConstraint = TungstenComponentStateConstraint, RD = undefined>(pkg: ConstructPackage<P, RD>) => AppStatefulStoreComponent<C, ND, G, St, P, S, RD>) & Statics<typeof AppStatefulStoreComponent>;
+} : Record<never, never>);
+type ContextArg<C> = (new (reqRes: ReqResOrNull) => C) | {
+    client: new () => C;
+    server: new (reqRes: ReqRes) => C;
+};
+type NetworkedDataArg<C, ND> = (new (reqRes: ReqResOrNull, context: C) => ND) & (new (reqRes: ReqResOrNull, context: C) => Serializable<NoInfer<ND>>);
+type GlobalDataArg<C, ND, G> = ((reqRes: ReqResOrNull, context: C, networkedData: ND, location: string) => Promise<G | DataRedirect>) & ((reqRes: ReqResOrNull, context: C, networkedData: ND, location: string) => Promise<Serializable<NoInfer<G>> | DataRedirect>);
+type StoreArg<C, ND, G, St> = new (reqRes: ReqResOrNull, context: C, networkedData: ND, globalData: G, matchedRouteInfo: MatchedRouteInfo) => St;
+type RoutesFn<C, ND, Rs> = (reqRes: ReqResOrNull, context: C, networkedData: ND) => Rs;
+export type AppStage<C extends object, ND extends object, G extends object, St extends object | undefined> = {
+    components: () => AppComponents<C, ND, G, St>;
+    routes: {
+        <const exact Rs extends RoutesReturn<G>>(routes: RoutesFn<C, ND, Rs> & NoDuplicatePaths<Rs>): RoutesFn<C, ND, Rs>;
+        <const exact R extends ExactRoutesWithSettings<G> | RoutesArray<G>>(routes: R & NoDuplicatePaths<R>): R;
+    };
+};
+export type StoreStage<C extends object, ND extends object, G extends object> = AppStage<C, ND, G, undefined> & {
+    store: <St extends object>(schema: StoreArg<C, ND, G, St>) => AppStage<C, ND, G, St>;
+};
+export type GlobalDataStage<C extends object, ND extends object> = StoreStage<C, ND, object> & {
+    globalData: <G extends object>(getGlobalData: GlobalDataArg<C, ND, G>) => StoreStage<C, ND, G>;
+};
+export type NetworkedDataStage<C extends object> = GlobalDataStage<C, object> & {
+    networkedData: <ND extends object>(networkedData: NetworkedDataArg<C, ND>) => GlobalDataStage<C, ND>;
+};
+export type AppBuilder = NetworkedDataStage<object> & {
+    context: <C extends object>(context: ContextArg<C>) => NetworkedDataStage<C>;
+};
+export declare const appBuilder: AppBuilder;
+export {};
+//# sourceMappingURL=appBuilder.d.ts.map

package/dist-ti/appOutput.d.ts

@@ -0,0 +1,7 @@
+// @tightscript-object-permissions
+export declare function log: exact ((...texts: any[]) => void);
+export declare function devLog: exact ((...texts: any[]) => void);
+export declare function out: exact ((...texts: any[]) => void);
+export declare function warn: exact ((...texts: any[]) => void);
+export declare function errorOut: exact ((...texts: any[]) => void);
+//# sourceMappingURL=appOutput.d.ts.map

package/dist-ti/assert.d.ts

@@ -0,0 +1,3 @@
+// @tightscript-object-permissions
+export declare function tAssert: exact ((assertion: unknown, message: string) => void);
+//# sourceMappingURL=assert.d.ts.map

package/dist-ti/auth/checkPassword.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare function checkPassword: exact ((password: string, passwordHash: string) => Promise<boolean>);
+export declare function checkPasswordBytes: exact ((password: string, passwordHash: Buffer) => Promise<boolean>);
+//# sourceMappingURL=checkPassword.d.ts.map

package/dist-ti/auth/hashPassword.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export declare function hashPassword: exact ((password: string) => Promise<string>);
+export declare function hashPasswordBytes: exact ((password: string) => Promise<Buffer>);
+//# sourceMappingURL=hashPassword.d.ts.map

package/dist-ti/auth/index.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+export * from './hashPassword.js';
+export * from './checkPassword.js';
+//# sourceMappingURL=index.d.ts.map

package/dist-ti/babelPlugins/BabelAddDevCacheBust.d.ts

@@ -0,0 +1,19 @@
+// @tightscript-object-permissions
+import type { NodePath, BabelFile } from '@babel/core';
+import type { ImportDeclaration, ExportNamedDeclaration, ExportAllDeclaration, StringLiteral } from '@babel/types';
+export declare function MakeBabelAddDevCacheBust: exact (() => () => exact rw {
+    name: string;
+    pre(state: BabelFile): void;
+    visitor: exact rw {
+        ImportDeclaration(path: NodePath<ImportDeclaration & {
+            source: rw StringLiteral;
+        }>): void;
+        ExportNamedDeclaration(path: NodePath<ExportNamedDeclaration & {
+            source?: rw StringLiteral | null;
+        }>): void;
+        ExportAllDeclaration(path: NodePath<ExportAllDeclaration & {
+            source: rw StringLiteral;
+        }>): void;
+    };
+});
+//# sourceMappingURL=BabelAddDevCacheBust.d.ts.map

package/dist-ti/babelPlugins/BabelExtractComponentStylesheet.d.ts

@@ -0,0 +1,14 @@
+// @tightscript-object-permissions
+import type { ClassProperty } from '@babel/types';
+import type { NodePath, PluginPass } from './BabelTypes.js';
+type Opts = {
+    onStylesheet: (rel: string, sourceFile: string) => void;
+};
+export declare function MakeBabelExtractComponentStylesheet: exact ((opts: Opts) => () => exact rw {
+    name: string;
+    visitor: exact rw {
+        ClassProperty(path: NodePath<ClassProperty>, state: PluginPass): void;
+    };
+});
+export {};
+//# sourceMappingURL=BabelExtractComponentStylesheet.d.ts.map

package/dist-ti/babelPlugins/BabelFakeType.d.ts

@@ -0,0 +1,8 @@
+// @tightscript-object-permissions
+import type * as BabelTypes from '@babel/types';
+import { parse } from '@babel/core';
+export type BabelFake = {
+    types: typeof BabelTypes;
+    parse: typeof parse;
+};
+//# sourceMappingURL=BabelFakeType.d.ts.map

package/dist-ti/babelPlugins/BabelState.type.d.ts

@@ -0,0 +1,4 @@
+// @tightscript-object-permissions
+import type { BabelFile } from '@babel/core';
+export type BabelState = BabelFile;
+//# sourceMappingURL=BabelState.type.d.ts.map

package/dist-ti/babelPlugins/BabelTransformBindDirect.d.ts

@@ -0,0 +1,16 @@
+// @tightscript-object-permissions
+import type { NodePath, PluginPass, types } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+export declare function MakeBabelTransformBindDirect: exact (() => (babel: BabelFake) => exact rw {
+    name: string;
+    visitor: exact rw {
+        JSXAttribute(path: NodePath<types.JSXAttribute & {
+            name: rw types.JSXAttribute['name'];
+        }> & {
+            parent: rw types.JSXOpeningElement & {
+                attributes: rw types.JSXOpeningElement['attributes'];
+            };
+        }, state: PluginPass): void;
+    };
+});
+//# sourceMappingURL=BabelTransformBindDirect.d.ts.map

package/dist-ti/babelPlugins/BabelTransformBindVar.d.ts

@@ -0,0 +1,16 @@
+// @tightscript-object-permissions
+import type { NodePath, PluginPass, types } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+export declare function MakeBabelTransformBindVar: exact (() => (babel: BabelFake) => exact rw {
+    name: string;
+    visitor: exact rw {
+        JSXAttribute(path: NodePath<types.JSXAttribute & {
+            name: rw types.JSXAttribute['name'];
+        }> & {
+            parent: rw types.JSXOpeningElement & {
+                attributes: rw types.JSXOpeningElement['attributes'];
+            };
+        }, state: PluginPass): void;
+    };
+});
+//# sourceMappingURL=BabelTransformBindVar.d.ts.map

package/dist-ti/babelPlugins/BabelTransformCjsToEsm.d.ts

@@ -0,0 +1,17 @@
+// @tightscript-object-permissions
+import type { BabelFile, NodePath, types } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+export declare function MakeBabelTransformCjsToEsm: exact (() => (babel: BabelFake) => exact rw {
+    pre(state: BabelFile & {
+        ast: {
+            program: rw types.Program;
+        };
+    }): void;
+    visitor: exact rw {
+        CallExpression(path: NodePath<types.CallExpression>): void;
+        Identifier(path: NodePath<types.Identifier>): void;
+        MemberExpression(path: NodePath<types.MemberExpression>): void;
+    };
+    post(state: BabelFile): void;
+});
+//# sourceMappingURL=BabelTransformCjsToEsm.d.ts.map

package/dist-ti/babelPlugins/BabelTransformCjsToFunction.d.ts

@@ -0,0 +1,21 @@
+// @tightscript-object-permissions
+import type { Directive, Identifier, Program } from '@babel/types';
+import type { BabelFile, NodePath } from '@babel/core';
+import type { BabelFake } from './BabelFakeType.js';
+type Opts = {
+    dependencies: string[];
+};
+export declare function MakeBabelTransformCjsToFunction: exact ((opts: Opts) => (babel: BabelFake) => exact rw {
+    pre(state: BabelFile & {
+        ast: {
+            program: rw Program;
+        };
+    }): void;
+    visitor: exact rw {
+        Identifier(path: NodePath<Identifier>): void;
+        Directive(path: NodePath<Directive>): void;
+    };
+    post(state: BabelFile): void;
+});
+export {};
+//# sourceMappingURL=BabelTransformCjsToFunction.d.ts.map

package/dist-ti/babelPlugins/BabelTransformCjsToFunction2.d.ts

@@ -0,0 +1,22 @@
+// @tightscript-object-permissions
+import type { BabelFile, NodePath } from '@babel/core';
+import type { CallExpression, Directive, Identifier, Program } from '@babel/types';
+import type { Babel } from './BabelTypes.js';
+type Opts = {
+    dependencies: string[];
+};
+export declare function MakeBabelTransformCjsToFunction: exact ((opts: Opts) => (babel: Babel) => exact rw {
+    pre(state: BabelFile & {
+        ast: {
+            program: rw Program;
+        };
+    }): void;
+    visitor: exact rw {
+        CallExpression(path: NodePath<CallExpression>): void;
+        Identifier(path: NodePath<Identifier>): void;
+        Directive(path: NodePath<Directive>): void;
+    };
+    post(state: BabelFile): void;
+});
+export {};
+//# sourceMappingURL=BabelTransformCjsToFunction2.d.ts.map

package/dist-ti/babelPlugins/BabelTransformComponentState.d.ts

@@ -0,0 +1,27 @@
+// @tightscript-object-permissions
+import type { NodePath } from '@babel/core';
+import type { AssignmentExpression, CallExpression, ClassMethod, ClassProperty, JSXExpressionContainer, UpdateExpression, VariableDeclaration, VariableDeclarator } from '@babel/types';
+import type { BabelFake } from './BabelFakeType.js';
+export declare function MakeBabelTransformComponentState: exact (() => (babel: BabelFake) => exact rw {
+    pre(): void;
+    visitor: exact rw {
+        ClassMethod: exact rw {
+            enter(path: NodePath<ClassMethod | ClassProperty>): void;
+            exit(path: NodePath<ClassMethod | ClassProperty>): void;
+        };
+        ClassProperty: exact rw {
+            enter(path: NodePath<ClassMethod | ClassProperty>): void;
+            exit(path: NodePath<ClassMethod | ClassProperty>): void;
+        };
+        AssignmentExpression(path: NodePath<rw AssignmentExpression>): void;
+        UpdateExpression(path: NodePath<UpdateExpression>): void;
+        CallExpression(path: NodePath<CallExpression & {
+            arguments: rw CallExpression['arguments'];
+        }>): void;
+        VariableDeclaration(path: NodePath<{
+            declarations: (rw VariableDeclarator)[];
+        } & VariableDeclaration>): void;
+        JSXExpressionContainer(path: NodePath<rw JSXExpressionContainer>): void;
+    };
+});
+//# sourceMappingURL=BabelTransformComponentState.d.ts.map