@omujs/omu 0.9.42 → 0.9.47

package/dist/dts/api/registry/extension.d.ts

@@ -1,26 +0,0 @@
-import { Identifier } from "../../identifier";
-import { Omu } from "../../omu";
-import { JsonType, Serializer } from "../../serialize";
-import { type Extension, ExtensionType } from "../extension.js";
-import { type Registry, RegistryType } from "./registry.js";
-export declare class RegistryExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<RegistryExtension>;
-	private readonly registries;
-	constructor(omu: Omu);
-	private createRegistry;
-	get<T>(registryType: RegistryType<T>): Registry<T>;
-	json<
-		T,
-		D extends JsonType = JsonType
-	>(name: string, options: {
-		default: T;
-		serializer?: Serializer<T, D>;
-	}): Registry<T>;
-	serialized<T>(name: string, options: {
-		default: T;
-		serializer: Serializer<T, Uint8Array>;
-	}): Registry<T>;
-}
-export declare const REGISTRY_EXTENSION_TYPE: ExtensionType<RegistryExtension>;
-export declare const REGISTRY_PERMISSION_ID: Identifier;

package/dist/dts/api/registry/index.d.ts

@@ -1,2 +0,0 @@
-export { REGISTRY_PERMISSION_ID } from "./extension.js";
-export { RegistryType, type Registry, type RegistryPermissions } from "./registry.js";

package/dist/dts/api/registry/packets.d.ts

@@ -1,20 +0,0 @@
-import { Identifier } from "../../identifier";
-import { RegistryPermissions, RegistryPermissionsJSON } from "./registry";
-export declare class RegistryPacket {
-	readonly id: Identifier;
-	readonly value: Uint8Array | null;
-	constructor(id: Identifier, value: Uint8Array | null);
-	static serialize(packet: RegistryPacket): Uint8Array;
-	static deserialize(data: Uint8Array): RegistryPacket;
-}
-export interface RegisterPacketJSON {
-	id: string;
-	permissions: RegistryPermissionsJSON;
-}
-export declare class RegisterPacket {
-	readonly id: Identifier;
-	readonly permissions: RegistryPermissions;
-	constructor(id: Identifier, permissions: RegistryPermissions);
-	static serialize(packet: RegisterPacket): RegisterPacketJSON;
-	static deserialize(data: RegisterPacketJSON): RegisterPacket;
-}

package/dist/dts/api/registry/registry.d.ts

@@ -1,57 +0,0 @@
-import type { Unlisten } from "../../event";
-import { Identifier, IntoId } from "../../identifier";
-import type { JsonType, Serializable } from "../../serialize";
-export interface RegistryPermissionsJSON {
-	all?: string;
-	read?: string;
-	write?: string;
-}
-export interface RegistryPermissions {
-	all?: IntoId;
-	read?: IntoId;
-	write?: IntoId;
-}
-export declare class RegistryType<T> {
-	readonly id: Identifier;
-	readonly defaultValue: T;
-	readonly serializer: Serializable<T, Uint8Array>;
-	readonly permissions: RegistryPermissions;
-	constructor(id: Identifier, defaultValue: T, serializer: Serializable<T, Uint8Array>, permissions: RegistryPermissions);
-	static createJson<
-		T,
-		D extends JsonType = JsonType
-	>(identifier: IntoId, { name, defaultValue, permissions, serializer }: {
-		name: string;
-		defaultValue: T;
-		permissions?: RegistryPermissions;
-		serializer?: Serializable<T, D>;
-	}): RegistryType<T>;
-	static createSerialized<T>(identifier: IntoId, { name, defaultValue, serializer, permissions }: {
-		name: string;
-		defaultValue: T;
-		serializer: Serializable<T, Uint8Array>;
-		permissions?: RegistryPermissions;
-	}): RegistryType<T>;
-}
-export interface Registry<T> {
-	readonly type: RegistryType<T>;
-	readonly value: T;
-	get(): Promise<T>;
-	set(value: T): Promise<void>;
-	update(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
-	modify(fn: (value: T) => PromiseLike<void> | void): Promise<T>;
-	listen(fn: (value: T) => void): Unlisten;
-	compatSvelte(): Writable<T>;
-}
-export type Subscriber<T> = (value: T) => void;
-export type Unsubscriber = () => void;
-export type Updater<T> = (value: T) => T;
-export type StartStopNotifier<T> = (set: (value: T) => void, update: (fn: Updater<T>) => void) => void | (() => void);
-export interface Readable<T> {
-	subscribe(this: void, run: Subscriber<T>): Unsubscriber;
-}
-export interface Writable<T> extends Readable<T> {
-	set(this: void, value: T): void;
-	update(this: void, updater: Updater<T>): void;
-	wait(): Promise<T>;
-}

package/dist/dts/api/server/extension.d.ts

@@ -1,61 +0,0 @@
-import { App, AppJson } from "../../app.js";
-import { Identifier, IdentifierMap, IntoId } from "../../identifier";
-import { LocalizedText } from "../../localization/localization.js";
-import { Omu } from "../../omu.js";
-import { ExtensionType, type Extension } from "../extension.js";
-import { Registry, RegistryType } from "../registry";
-import { type Table } from "../table";
-export declare const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension>;
-export interface AppIndexEntry {
-	url: string;
-	meta?: AppIndexRegistryMeta;
-	added_at: string;
-}
-export interface AppIndex {
-	indexes: Record<string, AppIndexEntry>;
-}
-export declare const SERVER_APPS_READ_PERMISSION_ID: Identifier;
-export declare const SERVER_APPS_WRITE_PERMISSION_ID: Identifier;
-export declare const SERVER_INDEX_READ_PERMISSION_ID: Identifier;
-export declare const SERVER_INDEX_REGISTRY_TYPE: RegistryType<AppIndex>;
-export declare const SERVER_SHUTDOWN_PERMISSION_ID: Identifier;
-export declare const TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier;
-export declare const TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier;
-export declare class ServerExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<ServerExtension>;
-	readonly apps: Table<App>;
-	readonly index: Registry<AppIndex>;
-	readonly trustedHosts: Registry<Record<string, string>>;
-	constructor(omu: Omu);
-	shutdown(restart?: boolean): Promise<boolean>;
-}
-export declare class SessionObserver {
-	readonly onConnectCallbacks: Array<(app: App) => Promise<void> | void>;
-	readonly onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>;
-	constructor(onConnectCallbacks: Array<(app: App) => Promise<void> | void>, onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>);
-	onConnect(callback: (app: App) => Promise<void> | void): void;
-	onDisconnect(callback: (app: App) => Promise<void> | void): void;
-}
-export type AppIndexRegistryMeta = {
-	name: LocalizedText;
-	note: LocalizedText;
-};
-export interface AppIndexRegistryJSON {
-	id: string;
-	meta?: AppIndexRegistryMeta;
-	apps: Record<string, AppJson>;
-}
-export declare class AppIndexRegistry {
-	id: Identifier;
-	apps: IdentifierMap<App>;
-	meta: AppIndexRegistryMeta | undefined;
-	constructor(id: Identifier, apps: IdentifierMap<App>, meta: AppIndexRegistryMeta | undefined);
-	static build(options: {
-		id: IntoId;
-		meta: AppIndexRegistryMeta;
-		apps: App[];
-	}): AppIndexRegistry;
-	static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry;
-	toJSON(): AppIndexRegistryJSON;
-}

package/dist/dts/api/server/index.d.ts

@@ -1 +0,0 @@
-export { AppIndexRegistry, SERVER_APPS_READ_PERMISSION_ID, SERVER_SHUTDOWN_PERMISSION_ID, TRUSTED_ORIGINS_GET_PERMISSION_ID, TRUSTED_ORIGINS_SET_PERMISSION_ID, type AppIndex, type AppIndexEntry, type AppIndexRegistryJSON } from "./extension.js";

package/dist/dts/api/session/extension.d.ts

@@ -1,52 +0,0 @@
-import { App } from "../../app";
-import { Identifier, IntoId } from "../../identifier";
-import { Omu } from "../../omu";
-import { SessionParam } from "../../token";
-import { Extension, ExtensionType } from "../extension";
-import { SessionObserver } from "../server/extension";
-import { Table } from "../table";
-export declare const SESSION_EXTENSION_TYPE: ExtensionType<SessionExtension>;
-export declare const SESSIONS_READ_PERMISSION_ID: Identifier;
-export type RequestRemoteAppResponse = {
-	type: "success";
-	token: string;
-	lan_ip: string;
-} | {
-	type: "error";
-	message: string;
-};
-export declare const REMOTE_APP_REQUEST_PERMISSION_ID: Identifier;
-export type GenerateTokenResponse = {
-	type: "success";
-	token: string;
-} | {
-	type: "error";
-	message: string;
-};
-export declare const GENERATE_TOKEN_PERMISSION_ID: Identifier;
-export declare class SessionExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<SessionExtension>;
-	readonly sessions: Table<App>;
-	private readonly sessionObservers;
-	private readonly requiredApps;
-	constructor(omu: Omu);
-	has(id: IntoId): Promise<boolean>;
-	observe(appId: IntoId, options?: {
-		onConnect?(app: App): void;
-		onDisconnect?(app: App): void;
-	}): SessionObserver;
-	private handleSessionConnect;
-	private handleSessionDisconnect;
-	require(...appIds: IntoId[]): void;
-	private onTask;
-	private onReady;
-	requestRemoteApp(options: {
-		app: App;
-		permissions: IntoId[];
-	}): Promise<RequestRemoteAppResponse>;
-	generateToken(options: {
-		app: App;
-		permissions?: IntoId[];
-	}): Promise<SessionParam>;
-}

package/dist/dts/api/session/index.d.ts

@@ -1 +0,0 @@
-export { GENERATE_TOKEN_PERMISSION_ID, REMOTE_APP_REQUEST_PERMISSION_ID, SESSION_EXTENSION_TYPE, SessionExtension, SESSIONS_READ_PERMISSION_ID, type RequestRemoteAppResponse } from "./extension";

package/dist/dts/api/signal/extension.d.ts

@@ -1,22 +0,0 @@
-import { Omu } from "../../omu";
-import { JsonType, Serializable } from "../../serialize";
-import { ExtensionType, type Extension } from "../extension.js";
-import { SignalType, type Signal } from "./signal.js";
-export declare const SIGNAL_EXTENSION_TYPE: ExtensionType<SignalExtension>;
-export declare class SignalExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<SignalExtension>;
-	private readonly signals;
-	constructor(omu: Omu);
-	private createSignal;
-	json<
-		T,
-		D extends JsonType = JsonType
-	>(name: string, options?: {
-		serializer?: Serializable<T, D>;
-	}): Signal<T>;
-	serialized<T>(name: string, options: {
-		serializer: Serializable<T, Uint8Array>;
-	}): Signal<T>;
-	get<T>(signalType: SignalType<T>): Signal<T>;
-}

package/dist/dts/api/signal/index.d.ts

@@ -1 +0,0 @@
-export { SignalPermissions, SignalType, type Signal } from "./signal.js";

package/dist/dts/api/signal/packets.d.ts

@@ -1,21 +0,0 @@
-import { Identifier } from "../../identifier";
-import { SignalPermissions, SignalPermissionsJSON } from "./signal.js";
-export declare class SignalPacket {
-	readonly id: Identifier;
-	readonly body: Uint8Array;
-	constructor(id: Identifier, body: Uint8Array);
-	static serialize(packet: SignalPacket): Uint8Array;
-	static deserialize(data: Uint8Array): SignalPacket;
-}
-interface SignalRegisterPacketJSON {
-	id: string;
-	permissions: SignalPermissionsJSON;
-}
-export declare class SignalRegisterPacket {
-	readonly id: Identifier;
-	readonly permissions: SignalPermissions;
-	constructor(id: Identifier, permissions: SignalPermissions);
-	static serialize(packet: SignalRegisterPacket): SignalRegisterPacketJSON;
-	static deserialize(data: SignalRegisterPacketJSON): SignalRegisterPacket;
-}
-export {};

package/dist/dts/api/signal/signal.d.ts

@@ -1,33 +0,0 @@
-import type { Unlisten } from "../../event";
-import { Identifier, IntoId } from "../../identifier";
-import type { Serializable } from "../../serialize";
-export interface SignalPermissionsJSON {
-	all?: string;
-	listen?: string;
-	send?: string;
-}
-export interface SignalPermissions {
-	all?: IntoId | undefined;
-	listen?: IntoId | undefined;
-	send?: IntoId | undefined;
-}
-export declare class SignalType<T> {
-	readonly id: Identifier;
-	readonly serializer: Serializable<T, Uint8Array>;
-	readonly permissions: SignalPermissions;
-	constructor(id: Identifier, serializer: Serializable<T, Uint8Array>, permissions: SignalPermissions);
-	static createJson<T>(identifier: IntoId, { name, serializer, permissions }: {
-		name: string;
-		serializer?: Serializable<T, any>;
-		permissions?: SignalPermissions;
-	}): SignalType<T>;
-	static createSerialized<T>(identifier: IntoId, { name, serializer, permissions }: {
-		name: string;
-		serializer: Serializable<T, Uint8Array>;
-		permissions?: SignalPermissions;
-	}): SignalType<T>;
-}
-export interface Signal<T> {
-	listen(handler: (value: T) => void): Unlisten;
-	notify(body: T): void;
-}

package/dist/dts/api/table/extension.d.ts

@@ -1,29 +0,0 @@
-import { Identifier } from "../../identifier";
-import { Omu } from "../../omu";
-import type { JsonType, Serializable } from "../../serialize";
-import type { Extension } from "../extension.js";
-import { ExtensionType } from "../extension.js";
-import type { Table } from "./table.js";
-import { TableType } from "./table.js";
-export declare const TABLE_EXTENSION_TYPE: ExtensionType<TableExtension>;
-export declare const TABLE_PERMISSION_ID: Identifier;
-export declare class TableExtension implements Extension {
-	private readonly omu;
-	readonly type: ExtensionType<TableExtension>;
-	private readonly tableMap;
-	constructor(omu: Omu);
-	private createTable;
-	json<
-		T,
-		D extends JsonType = JsonType
-	>(name: string, options: {
-		key: (item: T) => string;
-		serializer?: Serializable<T, D>;
-	}): Table<T>;
-	serialized<T>(name: string, options: {
-		key: (item: T) => string;
-		serializer: Serializable<T, Uint8Array>;
-	}): Table<T>;
-	get<T>(type: TableType<T>): Table<T>;
-	has(identifier: Identifier): boolean;
-}

package/dist/dts/api/table/index.d.ts

@@ -1,2 +0,0 @@
-export { TABLE_PERMISSION_ID } from "./extension.js";
-export { TableType, type Table, type TableConfig } from "./table.js";

package/dist/dts/api/table/packets.d.ts

@@ -1,65 +0,0 @@
-import { Identifier } from "../../identifier";
-import type { TableConfig } from "./table.js";
-export declare class TablePacket {
-	readonly id: Identifier;
-	constructor(id: Identifier);
-	static serialize(packet: TablePacket): Uint8Array;
-	static deserialize(data: Uint8Array): TablePacket;
-}
-export declare class TableItemsPacket {
-	readonly id: Identifier;
-	readonly items: Record<string, Uint8Array>;
-	constructor(id: Identifier, items: Record<string, Uint8Array>);
-	static serialize(packet: TableItemsPacket): Uint8Array;
-	static deserialize(data: Uint8Array): TableItemsPacket;
-}
-export declare class TableKeysPacket {
-	readonly id: Identifier;
-	readonly keys: string[];
-	constructor(id: Identifier, keys: string[]);
-	static serialize(packet: TableKeysPacket): Uint8Array;
-	static deserialize(data: Uint8Array): TableKeysPacket;
-}
-export declare class TableProxyPacket {
-	readonly id: Identifier;
-	readonly items: Record<string, Uint8Array>;
-	readonly key: number;
-	constructor(id: Identifier, items: Record<string, Uint8Array>, key: number);
-	static serialize(packet: TableProxyPacket): Uint8Array;
-	static deserialize(data: Uint8Array): TableProxyPacket;
-}
-export declare class TableFetchPacket {
-	readonly id: Identifier;
-	readonly limit: number;
-	readonly backward: boolean;
-	readonly cursor: string | null;
-	constructor(id: Identifier, limit: number, backward?: boolean, cursor?: string | null);
-	static serialize(packet: TableFetchPacket): Uint8Array;
-	static deserialize(data: Uint8Array): TableFetchPacket;
-}
-export declare class TableFetchRangePacket {
-	readonly id: Identifier;
-	readonly start: string;
-	readonly end: string;
-	constructor(id: Identifier, start: string, end: string);
-	static serialize(packet: TableFetchRangePacket): Uint8Array;
-	static deserialize(data: Uint8Array): TableFetchRangePacket;
-}
-export declare class SetConfigPacket {
-	readonly id: Identifier;
-	readonly config: TableConfig;
-	constructor(id: Identifier, config: TableConfig);
-	static serialize(packet: SetConfigPacket): Uint8Array;
-	static deserialize(data: Uint8Array): SetConfigPacket;
-}
-export declare class SetPermissionPacket {
-	readonly id: Identifier;
-	readonly all: Identifier | null;
-	readonly read: Identifier | null;
-	readonly write: Identifier | null;
-	readonly remove: Identifier | null;
-	readonly proxy: Identifier | null;
-	constructor(id: Identifier, all: Identifier | null, read: Identifier | null, write: Identifier | null, remove: Identifier | null, proxy: Identifier | null);
-	static serialize(packet: SetPermissionPacket): Uint8Array;
-	static deserialize(data: Uint8Array): SetPermissionPacket;
-}

package/dist/dts/api/table/table.d.ts

@@ -1,76 +0,0 @@
-import type { EventEmitter, Unlisten } from "../../event";
-import { Identifier, IntoId } from "../../identifier";
-import type { JsonType, Serializable } from "../../serialize";
-export type TableConfig = {
-	cache_size: number;
-};
-export interface Table<T> {
-	readonly cache: ReadonlyMap<string, T>;
-	readonly event: TableEvents<T>;
-	get(key: string): Promise<T | undefined>;
-	getMany(...keys: string[]): Promise<Map<string, T>>;
-	add(...item: T[]): Promise<void>;
-	update(...item: T[]): Promise<void>;
-	remove(...items: T[]): Promise<void>;
-	clear(): Promise<void>;
-	has(key: string): Promise<boolean>;
-	hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{ [key in keyof T] : boolean }>;
-	hasAll(...keys: string[]): Promise<boolean>;
-	hasAny(...keys: string[]): Promise<boolean>;
-	fetchItems({ limit, backward, cursor }: {
-		limit: number;
-		backward?: boolean;
-		cursor?: string;
-	}): Promise<Map<string, T>>;
-	fetchRange({ start, end }: {
-		start: string;
-		end: string;
-	}): Promise<Map<string, T>>;
-	fetchAll(): Promise<Map<string, T>>;
-	iterate({ backward, cursor }: {
-		backward?: boolean;
-		cursor?: string;
-	}): AsyncIterable<T>;
-	size(): Promise<number>;
-	proxy(proxy: (item: T) => T | undefined): Unlisten;
-	setCacheSize(size: number): void;
-	setConfig(config: TableConfig): void;
-	setPermissions(permissions: TablePermissions): void;
-	listen(listener?: (items: Map<string, T>) => void): Unlisten;
-}
-export type TableEvents<T> = {
-	add: EventEmitter<[Map<string, T>]>;
-	update: EventEmitter<[Map<string, T>]>;
-	remove: EventEmitter<[Map<string, T>]>;
-	clear: EventEmitter<[]>;
-	cacheUpdate: EventEmitter<[Map<string, T>]>;
-};
-export type TablePermissions = {
-	all?: Identifier;
-	read?: Identifier;
-	write?: Identifier;
-	remove?: Identifier;
-	proxy?: Identifier;
-};
-export declare class TableType<T> {
-	id: Identifier;
-	serializer: Serializable<T, Uint8Array>;
-	keyFunction: (item: T) => string;
-	permissions?: TablePermissions | undefined;
-	constructor(id: Identifier, serializer: Serializable<T, Uint8Array>, keyFunction: (item: T) => string, permissions?: TablePermissions | undefined);
-	static createJson<
-		T,
-		D extends JsonType = JsonType
-	>(identifier: IntoId, { name, key, permissions, serializer }: {
-		name: string;
-		key: (item: T) => string;
-		permissions?: TablePermissions;
-		serializer?: Serializable<T, D>;
-	}): TableType<T>;
-	static createSerialized<T>(identifier: IntoId, { name, key, permissions, serializer }: {
-		name: string;
-		key: (item: T) => string;
-		permissions?: TablePermissions;
-		serializer: Serializable<T, Uint8Array>;
-	}): TableType<T>;
-}

package/dist/dts/app.d.ts

@@ -1,49 +0,0 @@
-import { Identifier, IntoId } from "./identifier";
-import type { Locale } from "./localization/locale.js";
-import type { LocalizedText } from "./localization/localization.js";
-export type AppMetadata = {
-	locale: Locale;
-	name?: LocalizedText;
-	icon?: LocalizedText;
-	description?: LocalizedText;
-	image?: LocalizedText;
-	site?: LocalizedText;
-	repository?: LocalizedText;
-	authors?: LocalizedText;
-	license?: LocalizedText;
-	tags?: string[];
-};
-export type AppType = "app" | "service" | "remote" | "plugin" | "dashboard";
-export type DependencySpecifier = {
-	version: string;
-	index?: string;
-};
-export type AppJson = {
-	id: string;
-	type: AppType;
-	parent_id?: string;
-	version?: string;
-	url?: string;
-	metadata?: AppMetadata;
-	dependencies?: Record<string, DependencySpecifier | string>;
-};
-export declare class App {
-	readonly id: Identifier;
-	readonly type: AppType;
-	readonly parentId?: Identifier;
-	readonly version?: string;
-	readonly url?: string;
-	readonly metadata?: AppMetadata;
-	readonly dependencies: Record<string, DependencySpecifier | string>;
-	constructor(id: IntoId, options: {
-		type?: AppType;
-		parentId?: IntoId;
-		version?: string;
-		url?: string;
-		metadata?: AppMetadata;
-		dependencies?: Record<string, DependencySpecifier | string>;
-	});
-	static deserialize(info: AppJson): App;
-	static serialize(data: App): AppJson;
-	join(...paths: string[]): App;
-}

package/dist/dts/const.d.ts

@@ -1,2 +0,0 @@
-export declare const textEncoder: TextEncoder;
-export declare const textDecoder: TextDecoder;

package/dist/dts/errors.d.ts

@@ -1,36 +0,0 @@
-import { DisconnectType } from "./network/packet/packet-types.js";
-export declare class OmuError extends Error {
-	constructor(message: string | null);
-}
-export declare class DisconnectReason extends OmuError {
-	type: DisconnectType;
-	message: string;
-	constructor(type: DisconnectType, message?: string);
-}
-export declare class ServerRestart extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class AnotherConnection extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class PermissionDenied extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class AppRemoved extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class InvalidToken extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class InvalidOrigin extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class InvalidVersion extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class InvalidPacket extends DisconnectReason {
-	constructor(message: string);
-}
-export declare class InternalError extends DisconnectReason {
-	constructor(message: string);
-}

package/dist/dts/event/index.d.ts

@@ -1,6 +0,0 @@
-export type Unlisten = () => void;
-export declare class EventEmitter<P extends Array<any>> {
-	private readonly listeners;
-	listen(listener: (...args: P) => any): Unlisten;
-	emit(...args: P): Promise<void>;
-}

package/dist/dts/helper.d.ts

@@ -1,13 +0,0 @@
-type Ok<T> = {
-	ok: true;
-	data: T;
-};
-type Err<E> = {
-	ok: false;
-	data: E;
-};
-export declare function tryCatch<
-	T,
-	E = Error
->(func: () => T): Ok<T> | Err<E>;
-export {};

package/dist/dts/identifier.d.ts

@@ -1,51 +0,0 @@
-import type { ExtensionType } from "./api";
-import { App } from "./app";
-export type IntoId = Identifier | string | ExtensionType | App;
-export declare class Identifier {
-	readonly namespace: string;
-	readonly path: string[];
-	constructor(namespace: string, ...path: string[]);
-	static serialize(identifier: Identifier): string;
-	static deserialize(json: string): Identifier;
-	static from(id: IntoId): Identifier;
-	static fromOptional(id: IntoId | undefined | null): Identifier | undefined;
-	static validate(namespace: string, path: string[]): void;
-	static format(namespace: string, ...path: string[]): string;
-	static fromKey(key: string): Identifier;
-	static fromUrl(url: string | URL): Identifier;
-	static namespaceFromUrl(url: string | URL): string;
-	get base(): Identifier;
-	toJson(): string;
-	static fromJson(json: string): Identifier;
-	key(): string;
-	isEqual(other: Identifier): boolean;
-	isNamespaceEqual(other: Identifier): boolean;
-	isSubpathOf(other: Identifier): boolean;
-	join(...path: string[]): Identifier;
-}
-export declare class IdentifierMap<T> {
-	private readonly map;
-	constructor(entries?: Iterable<[Identifier, T]>);
-	get size(): number;
-	set(identifier: Identifier, value: T): void;
-	get(identifier: Identifier): T | undefined;
-	has(identifier: Identifier): boolean;
-	delete(identifier: Identifier): void;
-	clear(): void;
-	keys(): IterableIterator<Identifier>;
-	values(): IterableIterator<T>;
-	entries(): IterableIterator<[Identifier, T]>;
-	[Symbol.iterator](): IterableIterator<[Identifier, T]>;
-}
-export declare class IdentifierSet {
-	private readonly set;
-	get size(): number;
-	add(identifier: Identifier): void;
-	has(identifier: Identifier): boolean;
-	delete(identifier: Identifier): void;
-	clear(): void;
-	keys(): IterableIterator<Identifier>;
-	values(): IterableIterator<Identifier>;
-	entries(): IterableIterator<[Identifier, Identifier]>;
-	[Symbol.iterator](): IterableIterator<[Identifier, Identifier]>;
-}