@manyducks.co/dolla 2.0.0-alpha.55 → 2.0.0-alpha.56

package/dist/core/context.d.ts

@@ -1,18 +1,14 @@
-import { Logger, LoggerOptions } from "./logger";
+import type { Store } from "../types";
+import { type Logger, type LoggerOptions } from "./logger";
 import { type EffectFn, type MaybeSignal, type UnsubscribeFn } from "./signals";
-/**
- *
- */
-export type Store<Options, Value> = (this: Context, options: Options, context: Context) => Value;
 type StoreMap = Map<Store<any, any>, any>;
-export declare const globalStores: StoreMap;
+export declare enum LifecycleEvent {
+    WILL_MOUNT = 0,
+    DID_MOUNT = 1,
+    WILL_UNMOUNT = 2,
+    DID_UNMOUNT = 3
+}
 type LifecycleListener = () => void;
-type ContextLifecycleListeners = {
-    willMount?: LifecycleListener[];
-    didMount?: LifecycleListener[];
-    willUnmount?: LifecycleListener[];
-    didUnmount?: LifecycleListener[];
-};
 declare enum LifecycleState {
     Unmounted = 0,
     WillMount = 1,
@@ -30,18 +26,16 @@ declare class ContextLifecycle {
     #private;
     state: LifecycleState;
     dependents: number;
-    on<E extends keyof ContextLifecycleListeners>(event: E, listener: LifecycleListener): void;
-    off<E extends keyof ContextLifecycleListeners>(event: E, listener: LifecycleListener): void;
-    willMount(dependent?: boolean): void;
-    didMount(dependent?: boolean): void;
-    willUnmount(dependent?: boolean): void;
-    didUnmount(dependent?: boolean): void;
+    on<E extends LifecycleEvent>(event: E, listener: LifecycleListener): void;
+    off<E extends LifecycleEvent>(event: E, listener: LifecycleListener): void;
+    notify<E extends LifecycleEvent>(event: E): void;
+    emit<E extends LifecycleEvent>(event: E, dependent?: boolean): void;
     dispose(): void;
 }
 export interface ContextOptions {
     logger?: LoggerOptions;
 }
-export interface InheritedContextOptions extends ContextOptions {
+export interface LinkedContextOptions extends ContextOptions {
     bindLifecycleToParent?: boolean;
 }
 export interface Context extends Logger {
@@ -49,15 +43,16 @@ export interface Context extends Logger {
 export declare class Context implements Logger {
     #private;
     _name: string;
-    _parent?: Context;
     _lifecycle: ContextLifecycle;
-    _stores: StoreMap;
-    _state: Map<any, any>;
+    _parent?: Context;
+    _stores?: StoreMap;
+    _state?: Map<any, any>;
     get isMounted(): boolean;
     /**
      * Returns a new Context with this one as its parent.
      */
-    static inherit(parent: Context, name: MaybeSignal<string>, options?: InheritedContextOptions): Context;
+    static linked(parent: Context, name: MaybeSignal<string>, options?: LinkedContextOptions): Context;
+    static emit(event: LifecycleEvent, context: Context): void;
     constructor(name: MaybeSignal<string>, options?: ContextOptions);
     /**
      * Returns the current name of this context.
@@ -69,9 +64,21 @@ export declare class Context implements Logger {
     setName(name: MaybeSignal<string>): void;
     addStore<T>(store: Store<any, T>, options?: any): this;
     getStore<T>(store: Store<any, T>): T;
+    /**
+     * Schedule a callback function to run just before this context is mounted.
+     */
     beforeMount(listener: LifecycleListener): () => void;
+    /**
+     * Schedule a callback function to run after this context is mounted.
+     */
     onMount(listener: LifecycleListener): () => void;
+    /**
+     * Schedule a callback function to run just before this context is unmounted.
+     */
     beforeUnmount(listener: LifecycleListener): () => void;
+    /**
+     * Schedule a callback function to run after this context is unmounted.
+     */
     onUnmount(listener: LifecycleListener): () => void;
     effect(callback: EffectFn): UnsubscribeFn;
     /**
@@ -83,11 +90,17 @@ export declare class Context implements Logger {
      */
     getState<T>(key: any): T;
     /**
-     * Gets all values available to this context.
+     * Returns a Map containing all state values available to this context.
      */
     getState(): Map<any, any>;
+    /**
+     * Stores `value` at `key` in this context's state.
+     */
     setState<T>(key: any, value: T): void;
-    setState(entries: [any, any][]): void;
+    /**
+     * For each tuple in `entries`, stores `value` at `key` in this context's state.
+     */
+    setState(entries: [key: any, value: any][]): void;
 }
 export declare function createContext(name: MaybeSignal<string>, options?: ContextOptions): Context;
 export declare class StoreError extends Error {

package/dist/core/env.d.ts

@@ -1,9 +1,3 @@
-export type Env = "production" | "development";
-/**
- * Gets the current environment value.
- */
-export declare function getEnv(): Env;
-/**
- * Sets the environment value. Affects which log messages will print and how much debugging info is included in the DOM.
- */
+import type { Env } from "../types";
+export declare function getEnv(): string;
 export declare function setEnv(value: Env): void;

package/dist/core/index.d.ts

@@ -1,19 +1,17 @@
 export { $, effect, get, peek } from "./signals.js";
 export type { MaybeSignal, Signal, Source } from "./signals.js";
 export { createContext } from "./context.js";
-export type { Context, Store } from "./context.js";
+export type { Context } from "./context.js";
 export { m, portal, render, repeat, unless, when } from "./markup.js";
-export type { Markup, MarkupElement } from "./markup.js";
+export type { MarkupNode } from "./markup.js";
 export { type Mixin } from "./nodes/html.js";
 export { ref, type Ref } from "./ref.js";
 export { mount, type UnmountFn } from "./mount.js";
 export { deepEqual, shallowEqual, strictEqual } from "../utils.js";
 export { getEnv, setEnv } from "./env.js";
-export type { Env } from "./env.js";
 export { createLogger, setLogFilter, setLogLevels } from "./logger.js";
 export type { Logger, LoggerErrorContext, LoggerOptions, LogLevels } from "./logger.js";
-export type { InputType, Renderable } from "../types.js";
-export type { View } from "./nodes/view.js";
+export type { View, Store, InputType, Renderable, Env } from "../types.js";
 export type { CrashViewProps } from "./views/default-crash-view.js";
 import type { IntrinsicElements as Elements } from "../types.js";
 declare global {

package/dist/core/logger.d.ts

@@ -1,5 +1,5 @@
-import { type Env } from "./env";
-import { type MaybeSignal } from "./signals";
+import type { Env } from "../types.js";
+import { type MaybeSignal } from "./signals.js";
 export interface LogLevels {
     info: boolean | Env;
     log: boolean | Env;

package/dist/core/markup.d.ts

@@ -1,63 +1,68 @@
-import type { Mountable, Renderable } from "../types.js";
+import type { Renderable, View } from "../types.js";
 import { Context } from "./context.js";
-import { ViewInstance, type View, type ViewResult } from "./nodes/view.js";
+import { KeyFn, RenderFn } from "./nodes/repeat.js";
 import { type MaybeSignal, type Signal } from "./signals.js";
 /**
  * Markup is a set of element metadata that hasn't been constructed into a MarkupElement yet.
  */
-export interface Markup {
+export declare class Markup<P extends Record<any, any> = Record<any, any>> {
     /**
      * In the case of a view, type will be the View function itself. It can also hold an identifier for special nodes like "$cond", "$repeat", etc.
      * DOM nodes can be created by name, such as HTML elements like "div", "ul" or "span", SVG elements like ""
      */
-    type: string | View<any>;
+    type: string | View<P>;
     /**
-     * Data that will be passed to a new MarkupElement instance when it is constructed.
+     * Data that will be passed to a new MarkupNode instance when it is constructed.
      */
-    props?: Record<string, any>;
+    props: P | undefined;
     /**
      *
      */
-    children?: any[];
+    children: Renderable[];
+    constructor(type: string | View<P>, props?: P, ...children: Renderable[]);
 }
 /**
- * A DOM node that has been constructed from a Markup object.
+ * A mountable node that has been constructed from Markup metadata.
  */
-export interface MarkupElement extends Mountable {
-    readonly domNode?: Node;
+export interface MarkupNode {
+    /**
+     *
+     */
+    readonly root?: Node;
+    /**
+     *
+     */
     readonly isMounted: boolean;
+    /**
+     *
+     */
+    mount(parent: Node, after?: Node): void;
+    /**
+     *
+     */
+    unmount(parentIsUnmounting?: boolean): void;
 }
-export declare function isMarkup(value: any): value is Markup;
-export declare function isMarkupElement(value: any): value is MarkupElement;
-export declare function toMarkup(renderables: Renderable | Renderable[]): Markup[];
+export declare function isMarkupNode(value: any): value is MarkupNode;
 export declare enum MarkupType {
     Text = "$text",
     Repeat = "$repeat",
     Dynamic = "$dynamic",
-    Outlet = "$outlet",
-    Fragment = "$fragment",
-    Node = "$node",
+    DOM = "$dom",
     Portal = "$portal"
 }
-export interface MarkupAttributes {
+export interface MarkupProps {
     [MarkupType.Text]: {
         value: any;
     };
     [MarkupType.Repeat]: {
         items: Signal<any[]>;
-        keyFn: (value: any, index: number) => string | number | symbol;
-        renderFn: (item: Signal<any>, index: Signal<number>, ctx: Context) => ViewResult;
+        key: KeyFn<any>;
+        render: RenderFn<any>;
     };
     [MarkupType.Dynamic]: {
-        source: Signal<Renderable>;
+        source: Signal<any>;
     };
-    [MarkupType.Outlet]: {
-        view: Signal<ViewInstance<{}> | undefined>;
-    };
-    [MarkupType.Fragment]: {
-        children: MaybeSignal<MarkupElement[]>;
-    };
-    [MarkupType.Node]: {
+    [MarkupType.DOM]: {
         value: Node;
     };
     [MarkupType.Portal]: {
@@ -66,32 +71,28 @@ export interface MarkupAttributes {
     };
     [tag: string]: Record<string, any>;
 }
-export declare function m<T extends keyof MarkupAttributes>(type: T, attributes: MarkupAttributes[T], ...children: Renderable[]): Markup;
-export declare function m<I>(type: View<I>, attributes?: I, ...children: any[]): Markup;
+export declare function m<T extends keyof MarkupProps>(type: T, props: MarkupProps[T], ...children: Renderable[]): Markup;
+export declare function m<P extends {}>(type: View<P>, props?: P, ...children: Renderable[]): Markup;
+export declare function m<P>(type: View<P>, props: P, ...children: any[]): Markup;
 /**
- * Displays `thenContent` when `condition` is truthy and `elseContent` when falsy.
+ * If `condition` is truthy, displays `thenContent`, otherwise `elseContent`.
  */
 export declare function when(condition: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
 /**
- * Inverted `when`. Displays `thenContent` when `condition` is falsy and `elseContent` when truthy.
+ * Inverted `when`. If `condition` is falsy, displays `thenContent`, otherwise `elseContent`.
  */
 export declare function unless(condition: MaybeSignal<any>, thenContent?: Renderable, elseContent?: Renderable): Markup;
 /**
- * Calls `renderFn` for each item in `items`. Dynamically adds and removes views as items change.
- * The result of `keyFn` is used to compare items and decide if item was added, removed or updated.
+ * Calls `render` for each item in `items`. Dynamically adds and removes views as items change.
+ * The result of `key` is used to compare items and decide if item was added, removed or updated.
  */
-export declare function repeat<T>(items: MaybeSignal<T[]>, keyFn: (value: T, index: number) => string | number | symbol, renderFn: (item: Signal<T>, index: Signal<number>, ctx: Context) => ViewResult): Markup;
+export declare function repeat<T>(items: MaybeSignal<T[]>, key: KeyFn<T>, render: RenderFn<T>): Markup;
 /**
  * Renders `content` into a `parent` node anywhere in the page, rather than its usual position in the view.
  */
 export declare function portal(parent: Node, content: Renderable): Markup;
-export declare function render(content: Renderable, context?: Context): MarkupElement;
-/**
- * Construct Markup metadata into a set of MarkupElements.
- */
-export declare function toMarkupElements(context: Context, markup: Markup | Markup[]): MarkupElement[];
+export declare function render(content: Renderable, context?: Context): MarkupNode;
 /**
- * Combines one or more MarkupElements into a single MarkupElement.
+ * Convert basically anything into a set of MarkupElements.
  */
-export declare function groupElements(elements: MarkupElement[]): MarkupElement;
-export declare function isRenderable(value: unknown): value is Renderable;
+export declare function toMarkupNodes(context: Context, ...content: any[]): MarkupNode[];

package/dist/core/mount.d.ts

@@ -1,7 +1,7 @@
 import { Router } from "../router/router";
+import type { View } from "../types";
 import { Context } from "./context";
 import { type LoggerErrorContext } from "./logger";
-import { type View } from "./nodes/view";
 export type UnmountFn = () => Promise<void>;
 export interface MountOptions {
     crashView?: View<LoggerErrorContext>;

package/dist/core/nodes/dom.d.ts

@@ -1,11 +1,11 @@
-import type { MarkupElement } from "../markup";
-import { IS_MARKUP_ELEMENT } from "../symbols";
+import type { MarkupNode } from "../markup";
+import { IS_MARKUP_NODE } from "../symbols";
 /**
- * Wraps any plain DOM node in a MarkupElement interface.
+ * Wraps any plain DOM node in a MarkupNode interface.
  */
-export declare class DOMNode implements MarkupElement {
-    [IS_MARKUP_ELEMENT]: boolean;
-    domNode: Node;
+export declare class DOMNode implements MarkupNode {
+    [IS_MARKUP_NODE]: boolean;
+    root: Node;
     get isMounted(): boolean;
     constructor(node: Node);
     mount(parent: Node, after?: Node): void;

package/dist/core/nodes/dynamic.d.ts

@@ -1,30 +1,28 @@
-import type { Renderable } from "../../types.js";
 import type { Context } from "../context.js";
-import { type MarkupElement } from "../markup.js";
+import { type MarkupNode } from "../markup.js";
 import { Signal } from "../signals.js";
-import { IS_MARKUP_ELEMENT } from "../symbols.js";
-interface DynamicOptions {
-    source: Signal<Renderable>;
-    context: Context;
-}
+import { IS_MARKUP_NODE } from "../symbols.js";
 /**
  * Displays dynamic children without a parent element.
  * Renders a Reactive value via a render function.
  *
  * This is probably the most used element type aside from HTML.
  */
-export declare class Dynamic implements MarkupElement {
-    [IS_MARKUP_ELEMENT]: boolean;
-    domNode: Text;
+export declare class Dynamic implements MarkupNode {
+    [IS_MARKUP_NODE]: boolean;
+    root: Text;
     private children;
     private context;
-    private source;
+    private $slot;
     private unsubscribe?;
     get isMounted(): boolean;
-    constructor(options: DynamicOptions);
+    constructor(context: Context, $slot: Signal<any>);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
-    cleanup(parentIsUnmounting: boolean): void;
-    update(children: Renderable[]): void;
+    private cleanup;
+    private update;
+    /**
+     * Move marker node to end of children.
+     */
+    private moveMarker;
 }
-export {};

package/dist/core/nodes/html.d.ts

@@ -1,26 +1,19 @@
 import { Context } from "../context.js";
-import { type MarkupElement } from "../markup.js";
-import { IS_MARKUP_ELEMENT } from "../symbols.js";
+import { type MarkupNode } from "../markup.js";
+import { IS_MARKUP_NODE } from "../symbols.js";
 export type Mixin<E extends Element = Element> = (element: E, context: Context) => void;
-type HTMLOptions = {
-    context: Context;
-    tag: string;
-    props: Record<string, any>;
-    children?: any[];
-};
-export declare class HTML implements MarkupElement {
-    [IS_MARKUP_ELEMENT]: boolean;
-    domNode: SVGElement | HTMLElement;
-    context: Context;
+export declare class HTML implements MarkupNode {
+    [IS_MARKUP_NODE]: boolean;
+    root: HTMLElement | SVGElement;
+    private context;
     private props;
-    private childMarkup;
-    private children;
+    private children?;
+    private childNodes;
     private unsubscribers;
-    private logger;
     private ref?;
     private canClickAway;
     get isMounted(): boolean;
-    constructor({ tag, props, children, context }: HTMLOptions);
+    constructor(context: Context, tag: string, props: Record<string, any>, children?: any[]);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
     private attachProp;
@@ -28,8 +21,3 @@ export declare class HTML implements MarkupElement {
     private applyStyles;
     private applyClasses;
 }
-/**
- * Converts a camelCase string to kebab-case.
- */
-export declare function camelToKebab(value: string): string;
-export {};

package/dist/core/nodes/portal.d.ts

@@ -1,22 +1,18 @@
 import type { Renderable } from "../../types.js";
 import { Context } from "../context.js";
-import { type MarkupElement } from "../markup.js";
-import { IS_MARKUP_ELEMENT } from "../symbols.js";
-interface PortalConfig {
-    content: Renderable;
-    parent: Node;
-    context: Context;
-}
+import { type MarkupNode } from "../markup.js";
+import { IS_MARKUP_NODE } from "../symbols.js";
 /**
  * Renders content into a specified parent node.
  */
-export declare class Portal implements MarkupElement {
-    [IS_MARKUP_ELEMENT]: boolean;
-    private config;
+export declare class Portal implements MarkupNode {
+    [IS_MARKUP_NODE]: boolean;
+    private context;
+    private content;
+    private parent;
     private element?;
     get isMounted(): boolean;
-    constructor(config: PortalConfig);
+    constructor(context: Context, content: Renderable, parent: Node);
     mount(_parent: Node, _after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
 }
-export {};

package/dist/core/nodes/repeat.d.ts

@@ -1,28 +1,23 @@
-import { type Context } from "../context.js";
-import { type MarkupElement } from "../markup.js";
+import type { Renderable } from "../../types.js";
+import type { Context } from "../context.js";
+import type { MarkupNode } from "../markup.js";
 import { type Signal } from "../signals.js";
-import { IS_MARKUP_ELEMENT } from "../symbols.js";
-import { type ViewResult } from "./view.js";
-interface RepeatOptions<T> {
-    context: Context;
-    items: Signal<T[]>;
-    keyFn: (item: T, index: number) => string | number | symbol;
-    renderFn: (item: Signal<T>, index: Signal<number>, ctx: Context) => ViewResult;
-}
-export declare class Repeat<T> implements MarkupElement {
-    [IS_MARKUP_ELEMENT]: boolean;
-    domNode: Text;
+import { IS_MARKUP_NODE } from "../symbols.js";
+export type KeyFn<T> = (item: T, index: number) => string | number | symbol;
+export type RenderFn<T> = (item: Signal<T>, index: Signal<number>, ctx: Context) => Renderable;
+export declare class Repeat<T> implements MarkupNode {
+    [IS_MARKUP_NODE]: boolean;
+    root: Text;
+    private context;
     private items;
+    private key;
+    private render;
     private unsubscribe;
     private connectedItems;
-    private context;
-    private renderFn;
-    private keyFn;
     get isMounted(): boolean;
-    constructor({ context, items, renderFn, keyFn }: RepeatOptions<T>);
+    constructor(context: Context, items: Signal<T[]>, key: KeyFn<T>, render: RenderFn<T>);
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
     private _cleanup;
     private _update;
 }
-export {};

package/dist/core/nodes/view.d.ts

@@ -1,33 +1,20 @@
+import type { View } from "../../types.js";
 import { Context } from "../context.js";
-import { type Markup, type MarkupElement } from "../markup.js";
-import { type Signal } from "../signals.js";
-import { IS_MARKUP_ELEMENT } from "../symbols.js";
-export declare const ROUTE: unique symbol;
+import { type MarkupNode } from "../markup.js";
+import { IS_MARKUP_NODE } from "../symbols.js";
 export declare const VIEW: unique symbol;
-/**
- * Any valid value that a View can return.
- */
-export type ViewResult = Node | Signal<any> | Markup | Markup[] | null;
-/**
- *
- */
-export type View<P> = (this: Context, props: P, context: Context) => ViewResult;
-/**
- * A view that has been constructed into DOM nodes.
- */
-export declare class ViewInstance<P> implements MarkupElement {
-    [IS_MARKUP_ELEMENT]: boolean;
+export declare class ViewInstance<P> implements MarkupNode {
+    [IS_MARKUP_NODE]: boolean;
     uniqueId: string;
     context: Context;
     props: P & {
-        children: Markup[] | undefined;
+        children: any[] | undefined;
     };
     fn: View<P>;
-    element?: MarkupElement;
-    $name: import("../signals.js").Source<string>;
-    constructor(context: Context, fn: View<P>, props: P, children?: Markup[]);
-    get domNode(): Node;
-    isMounted: boolean;
+    node?: MarkupNode;
+    constructor(context: Context, fn: View<P>, props: P, children?: any[]);
+    get root(): Node;
+    get isMounted(): boolean;
     mount(parent: Node, after?: Node): void;
     unmount(parentIsUnmounting?: boolean): void;
     private _initialize;

package/dist/core/ref.d.ts

@@ -13,10 +13,6 @@ export interface Ref<T> {
     (value: T): T;
 }
 /**
- * Creates a ref with no initial value.
+ * Creates a Ref.
  */
-export declare function ref<T>(): Ref<T>;
-/**
- * Creates a ref with an initial value.
- */
-export declare function ref<T>(value: T): Ref<T>;
+export declare function ref<T>(value?: T): Ref<T>;

package/dist/core/symbols.d.ts

@@ -1,2 +1,2 @@
 export declare const IS_MARKUP: unique symbol;
-export declare const IS_MARKUP_ELEMENT: unique symbol;
+export declare const IS_MARKUP_NODE: unique symbol;

package/dist/core/views/default-crash-view.d.ts

@@ -19,4 +19,4 @@ export type CrashViewProps = {
      */
     tagName?: string;
 };
-export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup;
+export declare function DefaultCrashView(props: CrashViewProps): import("../markup.js").Markup<Record<any, any>>;

package/dist/core/views/fragment.d.ts

@@ -1,8 +1,7 @@
 import type { Renderable } from "../../types.js";
-import { Context } from "../context.js";
 /**
  * A utility view that displays its children.
  */
 export declare function Fragment(props: {
     children?: Renderable;
-}, ctx: Context): string | number | false | import("../signals.js").Signal<any> | import("../markup.js").Markup | (string | number | false | import("../signals.js").Signal<any> | import("../markup.js").Markup | null | undefined)[] | null;
+}): Renderable;

package/dist/fragment-BahD_BJA.js

@@ -0,0 +1,7 @@
+function r(n) {
+  return n.children;
+}
+export {
+  r as F
+};
+//# sourceMappingURL=fragment-BahD_BJA.js.map

package/dist/fragment-BahD_BJA.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fragment-BahD_BJA.js","sources":["../src/core/views/fragment.ts"],"sourcesContent":["import type { Renderable } from \"../../types.js\";\n\n/**\n * A utility view that displays its children.\n */\nexport function Fragment(props: { children?: Renderable }) {\n  return props.children;\n}\n"],"names":["Fragment","props"],"mappings":"AAKO,SAASA,EAASC,GAAkC;AACzD,SAAOA,EAAM;AACf;"}

package/dist/http.js

@@ -6,7 +6,7 @@ var g = (r, e, t) => e in r ? b(r, e, { enumerable: !0, configurable: !0, writab
 var a = (r, e, t) => g(r, typeof e != "symbol" ? e + "" : e, t), m = (r, e, t) => e.has(r) || f("Cannot " + t);
 var d = (r, e, t) => (m(r, e, "read from private field"), t ? t.call(r) : e.get(r)), c = (r, e, t) => e.has(r) ? f("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t);
 var o = (r, e, t) => (m(r, e, "access private method"), t);
-import { i as w } from "./typeChecking-lgllKIVq.js";
+import { i as w } from "./typeChecking-BJ-ymQ2F.js";
 var l, p, i, h;
 class O {
   constructor() {

package/dist/i18n.js

@@ -5,8 +5,8 @@ var D = (o) => {
 var J = (o, t, e) => t in o ? B(o, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[t] = e;
 var O = (o, t, e) => J(o, typeof t != "symbol" ? t + "" : t, e), _ = (o, t, e) => t.has(o) || D("Cannot " + e);
 var i = (o, t, e) => (_(o, t, "read from private field"), e ? e.call(o) : t.get(o)), m = (o, t, e) => t.has(o) ? D("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(o) : t.set(o, e), N = (o, t, e, n) => (_(o, t, "write to private field"), n ? n.call(o, e) : t.set(o, e), e), g = (o, t, e) => (_(o, t, "access private method"), e);
-import { $, f as K, d as Q, g as x } from "./logger-CXdzxt1e.js";
-import { b as C, i as j, c as U, t as P } from "./typeChecking-lgllKIVq.js";
+import { $, f as K, d as Q, g as x } from "./logger-sSxIw5od.js";
+import { b as C, i as j, c as U, t as P } from "./typeChecking-BJ-ymQ2F.js";
 var I, F, p, S, G;
 class W {
   constructor(t) {