@geektech/tsone 0.0.1 → 0.1.0

package/dist/core/form.d.ts

@@ -0,0 +1,24 @@
+export type ValidationResult = boolean | string;
+export type ValidationRule<T = unknown> = (value: T, model: object) => ValidationResult;
+export type ValidationRules<TModel extends object> = {
+    [TPath in keyof TModel & string]?: readonly ValidationRule[];
+} & Record<string, readonly ValidationRule[] | undefined>;
+export interface FieldValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface FormValidationResult {
+    valid: boolean;
+    errors: Record<string, string[]>;
+}
+export interface FormController<TModel extends object> {
+    readonly model: TModel;
+    readonly errors: Record<string, string[]>;
+    validate(): FormValidationResult;
+    validateField(path: string): FieldValidationResult;
+    resetErrors(): void;
+}
+export declare function required(message?: string): ValidationRule;
+export declare function minLength(length: number, message?: string): ValidationRule;
+export declare function validate(rule: ValidationRule): ValidationRule;
+export declare function createForm<TModel extends object>(model: TModel, rules: ValidationRules<TModel>): FormController<TModel>;

package/dist/core/index.d.ts

@@ -4,3 +4,7 @@ export * from './reactive';
 export * from './vnode';
 export * from './template';
 export * from './renderer';
+export * from './document';
+export * from './model';
+export * from './form';
+export * from './animation';

package/dist/core/model.d.ts

@@ -0,0 +1,18 @@
+export interface ModelBindingOptions {
+    path: string;
+    parse?: (value: unknown) => unknown;
+    format?: (value: unknown) => string;
+}
+export type ModelBinding = string | ModelBindingOptions;
+type ModelState = Record<string, unknown>;
+export declare function modelPath(binding: ModelBinding): string;
+export declare function getModelValue(state: ModelState, path: string): unknown;
+export declare function setModelValue(state: ModelState, path: string, value: unknown): void;
+export declare class ModelBindingController {
+    private readonly bindings;
+    bind(element: HTMLElement, binding: ModelBinding, state: ModelState): void;
+    cleanup(element: HTMLElement): void;
+    private isSupportedControl;
+    private sameBinding;
+}
+export {};

package/dist/core/reactive/types.d.ts

@@ -8,12 +8,17 @@ export interface ReactiveEffect<T = unknown> {
 export interface ReactiveEffectOptions {
     lazy?: boolean;
     scheduler?: (effect: ReactiveEffect) => void;
+    throwOnError?: boolean;
 }
 export interface ComputedRef<T> {
     readonly value: T;
 }
 export declare const IS_REACTIVE: unique symbol;
 export declare const IS_READONLY: unique symbol;
+export declare const IS_REF: unique symbol;
+export interface Ref<T = unknown> {
+    value: T;
+}
 export declare const MUTATING_ARRAY_METHODS: readonly ["push", "pop", "shift", "unshift", "splice", "sort", "reverse"];
 export declare function hasReactiveFlag(value: object, flag: typeof IS_REACTIVE | typeof IS_READONLY): boolean;
 export declare function isObject(value: unknown): value is object;

package/dist/core/reactive.d.ts

@@ -1,5 +1,5 @@
-import { ComputedRef, ReactiveEffect, ReactiveEffectOptions } from './reactive/types';
-export type { ComputedRef, ReactiveEffect, ReactiveEffectOptions, } from './reactive/types';
+import { ComputedRef, Ref, ReactiveEffect, ReactiveEffectOptions } from './reactive/types';
+export type { ComputedRef, Ref, ReactiveEffect, ReactiveEffectOptions, } from './reactive/types';
 export declare class ReactiveSystem {
     private static instance;
     private activeEffect;
@@ -26,6 +26,9 @@ export declare function reactive<T extends object>(target: T): T;
 export declare function readonly<T extends object>(target: T): Readonly<T>;
 export declare function effect<T = unknown>(fn: () => T, options?: ReactiveEffectOptions): ReactiveEffect<T>;
 export declare function computed<T>(getter: () => T): ComputedRef<T>;
+export declare function ref<T>(value: T): Ref<T>;
+export declare function isRef(value: unknown): value is Ref<unknown>;
+export declare function unref<T>(value: T | Ref<T>): T;
 export declare function stop(effect: ReactiveEffect): void;
 export declare function isReactive(value: unknown): boolean;
 export declare function isReadonly(value: unknown): boolean;

package/dist/core/renderer/element-strategy.d.ts

@@ -0,0 +1,25 @@
+import { HTMLNode } from '../vnode';
+import type { RenderRuntimeContext, RenderStrategy, Renderable } from './types';
+export declare class ElementRenderStrategy<TNode extends HTMLNode = HTMLNode> implements RenderStrategy<TNode> {
+    private readonly listeners;
+    private readonly effects;
+    private readonly modelBindings;
+    matches(vnode: Renderable): vnode is TNode;
+    mount(vnode: TNode, context: RenderRuntimeContext): Node;
+    patch(oldVNode: TNode, newVNode: TNode, currentNode: Node, context: RenderRuntimeContext): Node;
+    unmount(vnode: TNode, currentNode: Node, context: RenderRuntimeContext): void;
+    protected mountChildren(element: HTMLElement, vnode: TNode, context: RenderRuntimeContext): void;
+    protected updateChildren(element: HTMLElement, oldVNode: TNode, newVNode: TNode, context: RenderRuntimeContext): void;
+    protected unmountChildren(element: HTMLElement, vnode: TNode, context: RenderRuntimeContext): void;
+    private applyProps;
+    private applyDirections;
+    private updateOrdinaryChildren;
+    private updateKeyedChildren;
+    private hasOnlyKeyedChildren;
+    private assertNoDuplicateKeys;
+    private getVNodeKey;
+    private collectListeners;
+    private updateListeners;
+    private setupReactiveAttribute;
+    private trackEffect;
+}

package/dist/core/renderer/types.d.ts

@@ -1,5 +1,6 @@
 import type { TemplateEngine } from '../template';
 import type { ComponentEventListener, ComponentProps } from '../component';
+import type { InjectionKey, InjectionResult } from '../component';
 import type { VNode } from '../vnode';
 export interface ComponentInstance {
     mountToNode(): Node;
@@ -7,8 +8,11 @@ export interface ComponentInstance {
     unmount(): void;
     setProps(props: Partial<ComponentProps>): void;
     setAppContext?(context: unknown): void;
+    setParentComponent?(parent: ComponentInstance | null): void;
+    setElementChangeListener?(listener: (previousElement: Node, nextElement: Node) => void): void;
+    resolveInjection?<T>(key: InjectionKey<T>): InjectionResult<T>;
     getElement(): Node | null;
-    on(eventName: string, listener: ComponentEventListener): void;
+    on(eventName: string, listener: ComponentEventListener): () => void;
 }
 export type Renderable = VNode | string;
 export interface RendererHost {
@@ -22,6 +26,7 @@ export interface RenderRuntimeContext {
     renderer: RendererHost;
     slots: Record<string, Array<VNode | string>>;
     registerChild(component: ComponentInstance): void;
+    unregisterChild(component: ComponentInstance): void;
 }
 export interface RenderStrategy<T extends Renderable = Renderable> {
     matches(vnode: Renderable): vnode is T;

package/dist/core/renderer.d.ts

@@ -1,4 +1,5 @@
-import { ComponentNode, HTMLNode, SlotProvider } from './vnode';
+import { ComponentNode, SlotProvider } from './vnode';
+export { ElementRenderStrategy } from './renderer/element-strategy';
 export type { ComponentInstance, RenderRuntimeContext, RenderStrategy, Renderable, RendererHost, } from './renderer/types';
 import type { RenderRuntimeContext, RenderStrategy, Renderable } from './renderer/types';
 export declare class RendererContext {
@@ -17,11 +18,17 @@ export declare class TextRenderStrategy implements RenderStrategy<string> {
 }
 export declare class ComponentRenderStrategy implements RenderStrategy<ComponentNode> {
     private readonly instances;
+    private readonly instanceNodes;
+    private readonly emitterUnsubscribers;
     matches(vnode: Renderable): vnode is ComponentNode;
     mount(vnode: ComponentNode, context: RenderRuntimeContext): Node;
     patch(oldVNode: ComponentNode, newVNode: ComponentNode, currentNode: Node, context: RenderRuntimeContext): Node;
-    unmount(_vnode: ComponentNode, currentNode: Node): void;
+    unmount(_vnode: ComponentNode, currentNode: Node, context: RenderRuntimeContext): void;
     private createProps;
+    private syncEmitters;
+    private clearEmitters;
+    private trackInstanceNode;
+    private clearInstanceNodes;
 }
 export declare class SlotRenderStrategy implements RenderStrategy<SlotProvider> {
     private readonly renderedChildren;
@@ -34,24 +41,3 @@ export declare class SlotRenderStrategy implements RenderStrategy<SlotProvider>
     private mountSlotChildren;
     private unmountSlotChildren;
 }
-export declare class ElementRenderStrategy implements RenderStrategy<HTMLNode> {
-    private readonly listeners;
-    private readonly effects;
-    private readonly modelBindings;
-    matches(vnode: Renderable): vnode is HTMLNode;
-    mount(vnode: HTMLNode, context: RenderRuntimeContext): Node;
-    patch(oldVNode: HTMLNode, newVNode: HTMLNode, currentNode: Node, context: RenderRuntimeContext): Node;
-    unmount(vnode: HTMLNode, currentNode: Node, context: RenderRuntimeContext): void;
-    private applyProps;
-    private applyDirections;
-    private updateChildren;
-    private updateKeyedChildren;
-    private hasKeyedChildren;
-    private getVNodeKey;
-    private collectListeners;
-    private updateListeners;
-    private setupReactiveAttribute;
-    private setupTwoWayBinding;
-    private getStateValue;
-    private trackEffect;
-}

package/dist/core/vnode.d.ts

@@ -1,8 +1,9 @@
 import type { AnyComponentConstructor, ComponentConstructor, ComponentEventListener, ComponentProps } from './component';
+import type { ModelBinding } from './model';
 export interface ComponentType {
     mount(container: HTMLElement): void;
     unmount(): void;
-    on(eventName: string, listener: ComponentEventListener): void;
+    on(eventName: string, listener: ComponentEventListener): () => void;
 }
 type VNodeComponentProps = ComponentProps;
 export type VNodeComponentConstructor<P extends VNodeComponentProps = VNodeComponentProps> = ComponentConstructor<P> | AnyComponentConstructor;
@@ -17,48 +18,87 @@ export interface EventListeners {
     [eventName: string]: (event: Event) => void;
 }
 export interface Directions {
-    model?: string;
+    model?: ModelBinding;
     if?: boolean;
     show?: boolean;
 }
-export interface HTMLNode {
+export interface VNodeBase {
+    key?: string | number;
+    slot?: string;
+    directions?: Directions;
+}
+export interface HTMLNode extends VNodeBase {
     tag: string;
     props?: HTMLProps;
     children?: Array<VNode | string>;
     listeners?: EventListeners;
-    key?: string | number;
-    slot?: string;
-    directions?: Directions;
 }
-export interface ComponentNode<P extends VNodeComponentProps = VNodeComponentProps> {
+export interface ComponentNode<P extends VNodeComponentProps = VNodeComponentProps> extends VNodeBase {
     component: VNodeComponentConstructor<P>;
     props?: P;
     children?: Array<VNode | string>;
     emitters?: Record<string, ComponentEventListener>;
-    key?: string | number;
-    slot?: string;
-    directions?: Directions;
 }
-export interface SlotProvider {
+export interface SlotProvider extends VNodeBase {
     tag: 'slot';
     props: {
         name: string;
     };
     children?: Array<VNode | string>;
-    key?: string | number;
-    directions?: Directions;
 }
-export interface SlotInjector {
+export interface SlotInjector extends VNodeBase {
     tag: string;
     slot: string;
-    key?: string | number;
-    directions?: Directions;
 }
 export type VNode = HTMLNode | ComponentNode | SlotProvider | SlotInjector;
+export type ElementShortcutOptions = Omit<HTMLNode, 'tag'>;
+export type ElementShortcut = (options?: ElementShortcutOptions) => HTMLNode;
 export declare function isComponentNode(vnode: VNode): vnode is ComponentNode;
 export declare function isHTMLNode(vnode: VNode): vnode is HTMLNode;
 export declare function isSlotProvider(vnode: VNode): vnode is SlotProvider;
 export declare function h(tag: string, props?: HTMLProps, children?: Array<VNode | string>, listeners?: EventListeners, key?: string | number, directions?: Directions): HTMLNode;
+export declare function Tag(tag: string, options?: ElementShortcutOptions): HTMLNode;
+export declare const Div: ElementShortcut;
+export declare const Span: ElementShortcut;
+export declare const P: ElementShortcut;
+export declare const Button: ElementShortcut;
+export declare const Input: ElementShortcut;
+export declare const Section: ElementShortcut;
+export declare const Main: ElementShortcut;
+export declare const Header: ElementShortcut;
+export declare const Footer: ElementShortcut;
+export declare const Nav: ElementShortcut;
+export declare const Article: ElementShortcut;
+export declare const Aside: ElementShortcut;
+export declare const H1: ElementShortcut;
+export declare const H2: ElementShortcut;
+export declare const H3: ElementShortcut;
+export declare const H4: ElementShortcut;
+export declare const H5: ElementShortcut;
+export declare const H6: ElementShortcut;
+export declare const Strong: ElementShortcut;
+export declare const Em: ElementShortcut;
+export declare const Small: ElementShortcut;
+export declare const Pre: ElementShortcut;
+export declare const Code: ElementShortcut;
+export declare const Blockquote: ElementShortcut;
+export declare const Ul: ElementShortcut;
+export declare const Ol: ElementShortcut;
+export declare const Li: ElementShortcut;
+export declare const A: ElementShortcut;
+export declare const Img: ElementShortcut;
+export declare const Form: ElementShortcut;
+export declare const Label: ElementShortcut;
+export declare const Textarea: ElementShortcut;
+export declare const Select: ElementShortcut;
+export declare const Option: ElementShortcut;
+export declare const Table: ElementShortcut;
+export declare const Thead: ElementShortcut;
+export declare const Tbody: ElementShortcut;
+export declare const Tr: ElementShortcut;
+export declare const Th: ElementShortcut;
+export declare const Td: ElementShortcut;
 export declare function createComponent<P extends VNodeComponentProps>(componentClass: ComponentConstructor<P>, props?: P, children?: Array<VNode | string>, key?: string | number, directions?: Directions): ComponentNode<P>;
 export declare function slot(name: string, key?: string | number, directions?: Directions): SlotProvider;
+export declare function each<T>(items: readonly T[], render: (item: T, index: number) => VNode | string, key: (item: T, index: number) => string | number): VNode[];
 export {};

package/dist/{index-dgv88dz4.js → index-8wjswsye.js}

@@ -18,6 +18,10 @@ class StyleManager {
     this.styles.clear();
     this.styleElement.textContent = "";
   }
+  destroy() {
+    this.clearStyles();
+    this.styleElement.remove();
+  }
   convertToCSS(properties) {
     return Object.entries(properties).map(([key, value]) => {
       const cssKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
@@ -55,5 +59,5 @@ ${this.convertToCSS(properties)}
 
 export { StyleManager };
 
-//# debugId=16D14DDEF181BE5A64756E2164756E21
-//# sourceMappingURL=index-dgv88dz4.js.map
+//# debugId=401A1B62728D384364756E2164756E21
+//# sourceMappingURL=index-8wjswsye.js.map

package/dist/index-8wjswsye.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../lib/style/StyleManager.ts"],
+  "sourcesContent": [
+    "export interface StyleOptions {\n  selector: string;\n  properties: Record<string, string | number>;\n  hover?: Record<string, string | number>;\n  media?: Record<string, Record<string, string | number>>;\n}\n\nexport class StyleManager {\n  public styleElement: HTMLStyleElement;\n  public styles: Map<string, StyleOptions> = new Map();\n\n  constructor() {\n    this.styleElement = document.createElement('style');\n    document.head.appendChild(this.styleElement);\n  }\n\n  public addStyle(name: string, options: StyleOptions): void {\n    this.styles.set(name, options);\n    this.updateStyles();\n  }\n\n  public removeStyle(name: string): void {\n    this.styles.delete(name);\n    this.updateStyles();\n  }\n\n  public clearStyles(): void {\n    this.styles.clear();\n    this.styleElement.textContent = '';\n  }\n\n  public destroy(): void {\n    this.clearStyles();\n    this.styleElement.remove();\n  }\n\n  private convertToCSS(properties: Record<string, string | number>): string {\n    return Object.entries(properties)\n      .map(([key, value]) => {\n        const cssKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();\n        return `${cssKey}: ${value};`;\n      })\n      .join('\\n');\n  }\n\n  private updateStyles(): void {\n    let cssText = '';\n\n    this.styles.forEach((style) => {\n      // 基础样式\n      cssText += `${style.selector} {\\n${this.convertToCSS(style.properties)}\\n}\\n`;\n\n      // hover 样式\n      if (style.hover) {\n        cssText += `${style.selector}:hover {\\n${this.convertToCSS(style.hover)}\\n}\\n`;\n      }\n\n      // media 查询\n      if (style.media) {\n        Object.entries(style.media).forEach(([query, properties]) => {\n          cssText += `@media ${query} {\\n${style.selector} {\\n${this.convertToCSS(properties)}\\n}\\n}\\n`;\n        });\n      }\n    });\n\n    this.styleElement.textContent = cssText;\n  }\n}\n"
+  ],
+  "mappings": ";AAOO,MAAM,aAAa;AAAA,EACjB;AAAA,EACA,SAAoC,IAAI;AAAA,EAE/C,WAAW,GAAG;AAAA,IACZ,KAAK,eAAe,SAAS,cAAc,OAAO;AAAA,IAClD,SAAS,KAAK,YAAY,KAAK,YAAY;AAAA;AAAA,EAGtC,QAAQ,CAAC,MAAc,SAA6B;AAAA,IACzD,KAAK,OAAO,IAAI,MAAM,OAAO;AAAA,IAC7B,KAAK,aAAa;AAAA;AAAA,EAGb,WAAW,CAAC,MAAoB;AAAA,IACrC,KAAK,OAAO,OAAO,IAAI;AAAA,IACvB,KAAK,aAAa;AAAA;AAAA,EAGb,WAAW,GAAS;AAAA,IACzB,KAAK,OAAO,MAAM;AAAA,IAClB,KAAK,aAAa,cAAc;AAAA;AAAA,EAG3B,OAAO,GAAS;AAAA,IACrB,KAAK,YAAY;AAAA,IACjB,KAAK,aAAa,OAAO;AAAA;AAAA,EAGnB,YAAY,CAAC,YAAqD;AAAA,IACxE,OAAO,OAAO,QAAQ,UAAU,EAC7B,IAAI,EAAE,KAAK,WAAW;AAAA,MACrB,MAAM,SAAS,IAAI,QAAQ,YAAY,KAAK,EAAE,YAAY;AAAA,MAC1D,OAAO,GAAG,WAAW;AAAA,KACtB,EACA,KAAK;AAAA,CAAI;AAAA;AAAA,EAGN,YAAY,GAAS;AAAA,IAC3B,IAAI,UAAU;AAAA,IAEd,KAAK,OAAO,QAAQ,CAAC,UAAU;AAAA,MAE7B,WAAW,GAAG,MAAM;AAAA,EAAe,KAAK,aAAa,MAAM,UAAU;AAAA;AAAA;AAAA,MAGrE,IAAI,MAAM,OAAO;AAAA,QACf,WAAW,GAAG,MAAM;AAAA,EAAqB,KAAK,aAAa,MAAM,KAAK;AAAA;AAAA;AAAA,MACxE;AAAA,MAGA,IAAI,MAAM,OAAO;AAAA,QACf,OAAO,QAAQ,MAAM,KAAK,EAAE,QAAQ,EAAE,OAAO,gBAAgB;AAAA,UAC3D,WAAW,UAAU;AAAA,EAAY,MAAM;AAAA,EAAe,KAAK,aAAa,UAAU;AAAA;AAAA;AAAA;AAAA,SACnF;AAAA,MACH;AAAA,KACD;AAAA,IAED,KAAK,aAAa,cAAc;AAAA;AAEpC;",
+  "debugId": "401A1B62728D384364756E2164756E21",
+  "names": []
+}

package/dist/index-vpx80nq5.js

@@ -0,0 +1,32 @@
+// lib/style/sheet.ts
+function renderStyleSheet(styles) {
+  return styles.map((entry) => renderStyleEntry(entry)).join(`
+
+`);
+}
+function renderStyleEntry(entry, indent = "") {
+  if ("atRule" in entry) {
+    const rules = entry.rules.map((rule) => renderStyleEntry(rule, `${indent}  `)).join(`
+
+`);
+    return `${indent}${entry.atRule} {
+${rules}
+${indent}}`;
+  }
+  const declarations = Object.entries(entry.properties).map(([property, value]) => `${indent}  ${toCssProperty(property)}: ${String(value)};`).join(`
+`);
+  return `${indent}${entry.selector} {
+${declarations}
+${indent}}`;
+}
+function toCssProperty(property) {
+  if (property.startsWith("--") || property.includes("-")) {
+    return property;
+  }
+  return property.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+
+export { renderStyleSheet };
+
+//# debugId=61B1187B7ADC17DB64756E2164756E21
+//# sourceMappingURL=index-vpx80nq5.js.map

package/dist/index-vpx80nq5.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../lib/style/sheet.ts"],
+  "sourcesContent": [
+    "export type StyleValue = string | number;\n\nexport type StyleProperties = Record<string, StyleValue>;\n\nexport interface StyleRule {\n  selector: string;\n  properties: StyleProperties;\n}\n\nexport interface StyleAtRule {\n  atRule: string;\n  rules: StyleRule[];\n}\n\nexport type StyleSheetEntry = StyleRule | StyleAtRule;\n\nexport type StyleSheet = StyleSheetEntry[];\n\nexport function renderStyleSheet(styles: StyleSheet): string {\n  return styles.map((entry) => renderStyleEntry(entry)).join('\\n\\n');\n}\n\nfunction renderStyleEntry(entry: StyleSheetEntry, indent = ''): string {\n  if ('atRule' in entry) {\n    const rules = entry.rules\n      .map((rule) => renderStyleEntry(rule, `${indent}  `))\n      .join('\\n\\n');\n\n    return `${indent}${entry.atRule} {\\n${rules}\\n${indent}}`;\n  }\n\n  const declarations = Object.entries(entry.properties)\n    .map(\n      ([property, value]) =>\n        `${indent}  ${toCssProperty(property)}: ${String(value)};`\n    )\n    .join('\\n');\n\n  return `${indent}${entry.selector} {\\n${declarations}\\n${indent}}`;\n}\n\nfunction toCssProperty(property: string): string {\n  if (property.startsWith('--') || property.includes('-')) {\n    return property;\n  }\n\n  return property.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);\n}\n"
+  ],
+  "mappings": ";AAkBO,SAAS,gBAAgB,CAAC,QAA4B;AAAA,EAC3D,OAAO,OAAO,IAAI,CAAC,UAAU,iBAAiB,KAAK,CAAC,EAAE,KAAK;AAAA;AAAA,CAAM;AAAA;AAGnE,SAAS,gBAAgB,CAAC,OAAwB,SAAS,IAAY;AAAA,EACrE,IAAI,YAAY,OAAO;AAAA,IACrB,MAAM,QAAQ,MAAM,MACjB,IAAI,CAAC,SAAS,iBAAiB,MAAM,GAAG,UAAU,CAAC,EACnD,KAAK;AAAA;AAAA,CAAM;AAAA,IAEd,OAAO,GAAG,SAAS,MAAM;AAAA,EAAa;AAAA,EAAU;AAAA,EAClD;AAAA,EAEA,MAAM,eAAe,OAAO,QAAQ,MAAM,UAAU,EACjD,IACC,EAAE,UAAU,WACV,GAAG,WAAW,cAAc,QAAQ,MAAM,OAAO,KAAK,IAC1D,EACC,KAAK;AAAA,CAAI;AAAA,EAEZ,OAAO,GAAG,SAAS,MAAM;AAAA,EAAe;AAAA,EAAiB;AAAA;AAG3D,SAAS,aAAa,CAAC,UAA0B;AAAA,EAC/C,IAAI,SAAS,WAAW,IAAI,KAAK,SAAS,SAAS,GAAG,GAAG;AAAA,IACvD,OAAO;AAAA,EACT;AAAA,EAEA,OAAO,SAAS,QAAQ,UAAU,CAAC,UAAU,IAAI,MAAM,YAAY,GAAG;AAAA;",
+  "debugId": "61B1187B7ADC17DB64756E2164756E21",
+  "names": []
+}