@jay-framework/compiler-shared 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,317 @@
+import * as prettier from 'prettier';
+
+declare enum ImportsFor {
+    definition = 0,
+    implementation = 1,
+    elementSandbox = 2
+}
+interface ImportName {
+    index: number;
+    statement: string;
+    module: string;
+    usage: ImportsFor[];
+}
+declare const Import: {
+    jayElement: ImportName;
+    element: ImportName;
+    svgElement: ImportName;
+    mathMlElement: ImportName;
+    dynamicText: ImportName;
+    dynamicAttribute: ImportName;
+    booleanAttribute: ImportName;
+    dynamicProperty: ImportName;
+    RenderElement: ImportName;
+    ReferencesManager: ImportName;
+    SecureReferencesManager: ImportName;
+    conditional: ImportName;
+    dynamicElement: ImportName;
+    svgDynamicElement: ImportName;
+    mathMLDynamicElement: ImportName;
+    forEach: ImportName;
+    ConstructContext: ImportName;
+    HTMLElementCollectionProxy: ImportName;
+    HTMLElementProxy: ImportName;
+    childComp: ImportName;
+    elemRef: ImportName;
+    elemCollectionRef: ImportName;
+    compRef: ImportName;
+    compCollectionRef: ImportName;
+    RenderElementOptions: ImportName;
+    MapEventEmitterViewState: ImportName;
+    OnlyEventEmitters: ImportName;
+    ComponentCollectionProxy: ImportName;
+    sandboxElementBridge: ImportName;
+    sandboxRoot: ImportName;
+    sandboxElement: ImportName;
+    sandboxChildComp: ImportName;
+    sandboxElemRef: ImportName;
+    sandboxElemCollectionRef: ImportName;
+    sandboxCompRef: ImportName;
+    sandboxCompCollectionRef: ImportName;
+    sandboxForEach: ImportName;
+    handshakeMessageJayChannel: ImportName;
+    jayPort: ImportName;
+    setWorkerPort: ImportName;
+    secureMainRoot: ImportName;
+    secureChildComp: ImportName;
+    functionRepository: ImportName;
+    ReactElement: ImportName;
+    Jay4ReactElementProps: ImportName;
+    eventsFor: ImportName;
+    jay2React: ImportName;
+    mimicJayElement: ImportName;
+    jayContract: ImportName;
+};
+declare class Imports {
+    private readonly imports;
+    constructor(imports: Array<boolean>);
+    plus(addImport: ImportName | Imports): Imports;
+    has(anImport: ImportName): boolean;
+    render(importsFor: ImportsFor): string;
+    static none(): Imports;
+    static for(...imports: Array<ImportName>): Imports;
+    static merge(imports1: Imports, imports2: Imports): Imports;
+}
+
+declare const JAY_EXTENSION = ".jay-html";
+declare const JAY_CONTRACT_EXTENSION = ".jay-contract";
+declare const JAY_TS_EXTENSION = ".jay-html.ts";
+declare const JAY_DTS_EXTENSION = ".jay-html.d.ts";
+declare const JAY_CONTRACT_DTS_EXTENSION = ".jay-contract.d.ts";
+declare const JAY_COMPONENT = "@jay-framework/component";
+declare const JAY_SECURE = "@jay-framework/secure";
+declare const JAY_RUNTIME = "@jay-framework/runtime";
+declare const JAY_4_REACT = "@jay-framework/4-react";
+declare const JAY_FULLSTACK_COMPONENTS = "@jay-framework/fullstack-component";
+declare const REACT = "react";
+declare const MAKE_JAY_COMPONENT = "makeJayComponent";
+declare const MAKE_JAY_TSX_COMPONENT = "makeJayTsxComponent";
+declare const MAKE_JAY_4_REACT_COMPONENT = "jay4react";
+
+declare enum JayTypeKind {
+    atomic = 0,
+    typeAlias = 1,
+    enum = 2,
+    html = 3,
+    imported = 4,
+    element = 5,
+    elementConstructor = 6,
+    component = 7,
+    object = 8,
+    array = 9,
+    union = 10
+}
+interface JayType {
+    name: string;
+    readonly kind: JayTypeKind;
+}
+declare class JayAtomicType implements JayType {
+    readonly name: string;
+    constructor(name: string);
+    readonly kind = JayTypeKind.atomic;
+}
+declare const JayString: JayAtomicType;
+declare const JayNumber: JayAtomicType;
+declare const JayBoolean: JayAtomicType;
+declare const JayDate: JayAtomicType;
+declare const JayUnknown: JayAtomicType;
+declare function resolvePrimitiveType(typeName: string): JayType;
+declare class JayTypeAlias implements JayType {
+    readonly name: string;
+    constructor(name: string);
+    readonly kind = JayTypeKind.typeAlias;
+}
+declare class JayEnumType implements JayType {
+    readonly name: string;
+    readonly values: Array<string>;
+    constructor(name: string, values: Array<string>);
+    readonly kind = JayTypeKind.enum;
+}
+declare class JayHTMLType implements JayType {
+    readonly name: string;
+    constructor(name: string);
+    readonly kind = JayTypeKind.html;
+}
+declare class JayImportedType implements JayType {
+    readonly name: string;
+    readonly type: JayType;
+    constructor(name: string, type: JayType);
+    readonly kind = JayTypeKind.imported;
+}
+declare class JayElementType implements JayType {
+    readonly name: string;
+    constructor(name: string);
+    readonly kind = JayTypeKind.element;
+}
+declare class JayElementConstructorType implements JayType {
+    readonly name: string;
+    readonly typeName: string;
+    constructor(name: string, typeName: string);
+    readonly kind = JayTypeKind.elementConstructor;
+}
+declare class JayComponentApiMember {
+    readonly property: string;
+    readonly isEvent: boolean;
+    constructor(property: string, isEvent: boolean);
+}
+declare class JayComponentType implements JayType {
+    readonly name: string;
+    readonly api: Array<JayComponentApiMember>;
+    constructor(name: string, api: Array<JayComponentApiMember>);
+    readonly kind = JayTypeKind.component;
+}
+declare class JayObjectType implements JayType {
+    readonly name: string;
+    readonly props: {
+        [key: string]: JayType;
+    };
+    constructor(name: string, props: {
+        [key: string]: JayType;
+    });
+    readonly kind = JayTypeKind.object;
+}
+declare class JayArrayType implements JayType {
+    readonly itemType: JayType;
+    constructor(itemType: JayType);
+    get name(): string;
+    readonly kind = JayTypeKind.array;
+}
+declare class JayUnionType implements JayType {
+    readonly ofTypes: JayType[];
+    constructor(ofTypes: JayType[]);
+    readonly kind = JayTypeKind.union;
+    get name(): string;
+    hasType(aType: JayType): any;
+}
+declare function isAtomicType(aType: JayType): aType is JayAtomicType;
+declare function isTypeAliasType(aType: JayType): aType is JayTypeAlias;
+declare function isEnumType(aType: JayType): aType is JayEnumType;
+declare function isHTMLType(aType: JayType): aType is JayHTMLType;
+declare function isImportedType(aType: JayType): aType is JayImportedType;
+declare function isElementConstructorType(aType: JayType): aType is JayElementConstructorType;
+declare function isElementType(aType: JayType): aType is JayElementType;
+declare function isComponentType(aType: JayType): aType is JayComponentType;
+declare function isObjectType(aType: JayType): aType is JayObjectType;
+declare function isArrayType(aType: JayType): aType is JayArrayType;
+declare function isUnionType(aType: JayType): aType is JayUnionType;
+declare function equalJayTypes(a: JayType, b: JayType): any;
+
+interface JayImportName {
+    name: string;
+    as?: string;
+    type: JayType;
+}
+interface JayImportLink {
+    module: string;
+    names: JayImportName[];
+    sandbox?: boolean;
+}
+
+declare enum RuntimeMode {
+    MainTrusted = "mainTrusted",
+    MainSandbox = "mainSandbox",
+    WorkerTrusted = "workerTrusted",
+    WorkerSandbox = "workerSandbox"
+}
+type MainRuntimeModes = RuntimeMode.MainSandbox | RuntimeMode.MainTrusted;
+declare const TS_EXTENSION = ".ts";
+declare const TSX_EXTENSION = ".tsx";
+declare const JAY_QUERY_PREFIX = "?jay-";
+declare const JAY_QUERY_MAIN_SANDBOX = "?jay-mainSandbox";
+declare const JAY_QUERY_WORKER_TRUSTED = "?jay-workerTrusted";
+declare const JAY_QUERY_WORKER_SANDBOX = "?jay-workerSandbox";
+declare const JAY_QUERY_MAIN_SANDBOX_TS = "?jay-mainSandbox.ts";
+declare const JAY_QUERY_WORKER_TRUSTED_TS = "?jay-workerTrusted.ts";
+declare const JAY_QUERY_WORKER_SANDBOX_TS = "?jay-workerSandbox.ts";
+declare function hasExtension(filename: string, extension: string, { withTs }?: {
+    withTs?: boolean;
+}): boolean;
+declare function hasJayModeExtension(filename: string, { withTs }?: {
+    withTs?: boolean;
+}): boolean;
+declare function getModeFileExtension(isSandbox: boolean, importerMode: RuntimeMode, { withTs }?: {
+    withTs?: boolean;
+}): string;
+declare function getMode(isSandbox: boolean, importerMode: RuntimeMode): RuntimeMode;
+declare function getModeFromExtension(filename: string): RuntimeMode;
+declare function getJayTsFileSourcePath(filename: string): string;
+declare function withoutExtension(filename: string, extension: string): string;
+
+type JayValidations = Array<string>;
+declare class WithValidations<Value> {
+    val?: Value;
+    validations: JayValidations;
+    constructor(val: Value | undefined, validations?: JayValidations);
+    map<R>(func: (v: Value) => R): WithValidations<R>;
+    mapAsync<R>(func: (v: Value) => Promise<R>): Promise<WithValidations<R>>;
+    flatMap<R>(func: (v: Value) => WithValidations<R>): WithValidations<R>;
+    flatMapAsync<R>(func: (v: Value) => Promise<WithValidations<R>>): Promise<WithValidations<R>>;
+    merge(other: WithValidations<Value>, merge: (t1: Value, t2: Value) => Value): WithValidations<Value>;
+}
+declare function checkValidationErrors<T>(withValidations: WithValidations<T>): T;
+
+declare enum SourceFileFormat {
+    JayHtml = "jay-html",
+    JayTsx = "jay-tsx",
+    JayContract = "jay-contract",
+    TypeScript = "typeScript"
+}
+
+interface ImportedRefsTree {
+    readonly refsTypeName: string;
+    readonly repeatedRefsTypeName: string;
+}
+interface RefsTree {
+    readonly kind: 'refTree';
+    readonly refs: Ref[];
+    readonly children: Record<string, RefsTree>;
+    readonly imported?: ImportedRefsTree;
+    readonly repeated: boolean;
+}
+declare function mergeRefsTrees(...trees: RefsTree[]): RefsTree;
+declare function hasRefs(refs: RefsTree, includingAutoRefs: boolean): any;
+declare function nestRefs(path: string[], renderFragment: RenderFragment): RenderFragment;
+declare function mkRefsTree(refs: Ref[], children: Record<string, RefsTree>, repeated?: boolean, refsTypeName?: string, repeatedRefsTypeName?: string): RefsTree;
+interface Ref {
+    readonly kind: 'ref';
+    originalName: string;
+    ref: string;
+    constName: string;
+    repeated: boolean;
+    autoRef: boolean;
+    viewStateType: JayType;
+    elementType: JayType;
+}
+declare function mkRef(ref: string, originalName: string, constName: string, repeated: boolean, autoRef: boolean, viewStateType: JayType, elementType: JayType): Ref;
+declare class RenderFragment {
+    rendered: string;
+    imports: Imports;
+    validations: JayValidations;
+    refs: RefsTree;
+    constructor(rendered: string, imports?: Imports, validations?: JayValidations, refs?: RefsTree);
+    map(f: (s: string) => string): RenderFragment;
+    plusImport(imp: Imports): RenderFragment;
+    static empty(): RenderFragment;
+    static merge(fragment1: RenderFragment, fragment2: RenderFragment, combinator?: string): RenderFragment;
+}
+
+interface CompilerSourceFile {
+    format: SourceFileFormat;
+    imports: JayImportLink[];
+}
+interface GenericTypescriptSourceFile extends CompilerSourceFile {
+    format: SourceFileFormat.TypeScript;
+}
+
+declare enum GenerateTarget {
+    jay = 0,
+    react = 1
+}
+
+declare function withOriginalTrace<T extends Error>(error: T, originalError: Error): T;
+
+declare function prettify(code: string, options?: prettier.Options): Promise<string>;
+declare function prettifyHtml(html: string): string;
+declare function removeComments(code: string): string;
+
+export { type CompilerSourceFile, GenerateTarget, type GenericTypescriptSourceFile, Import, type ImportName, type ImportedRefsTree, Imports, ImportsFor, JAY_4_REACT, JAY_COMPONENT, JAY_CONTRACT_DTS_EXTENSION, JAY_CONTRACT_EXTENSION, JAY_DTS_EXTENSION, JAY_EXTENSION, JAY_FULLSTACK_COMPONENTS, JAY_QUERY_MAIN_SANDBOX, JAY_QUERY_MAIN_SANDBOX_TS, JAY_QUERY_PREFIX, JAY_QUERY_WORKER_SANDBOX, JAY_QUERY_WORKER_SANDBOX_TS, JAY_QUERY_WORKER_TRUSTED, JAY_QUERY_WORKER_TRUSTED_TS, JAY_RUNTIME, JAY_SECURE, JAY_TS_EXTENSION, JayArrayType, JayAtomicType, JayBoolean, JayComponentApiMember, JayComponentType, JayDate, JayElementConstructorType, JayElementType, JayEnumType, JayHTMLType, type JayImportLink, type JayImportName, JayImportedType, JayNumber, JayObjectType, JayString, type JayType, JayTypeAlias, JayTypeKind, JayUnionType, JayUnknown, type JayValidations, MAKE_JAY_4_REACT_COMPONENT, MAKE_JAY_COMPONENT, MAKE_JAY_TSX_COMPONENT, type MainRuntimeModes, REACT, type Ref, type RefsTree, RenderFragment, RuntimeMode, SourceFileFormat, TSX_EXTENSION, TS_EXTENSION, WithValidations, checkValidationErrors, equalJayTypes, getJayTsFileSourcePath, getMode, getModeFileExtension, getModeFromExtension, hasExtension, hasJayModeExtension, hasRefs, isArrayType, isAtomicType, isComponentType, isElementConstructorType, isElementType, isEnumType, isHTMLType, isImportedType, isObjectType, isTypeAliasType, isUnionType, mergeRefsTrees, mkRef, mkRefsTree, nestRefs, prettify, prettifyHtml, removeComments, resolvePrimitiveType, withOriginalTrace, withoutExtension };

package/dist/index.js

@@ -0,0 +1,941 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const prettier = require("prettier");
+const jsBeautify = require("js-beautify");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const prettier__namespace = /* @__PURE__ */ _interopNamespaceDefault(prettier);
+const JAY_EXTENSION = ".jay-html";
+const JAY_CONTRACT_EXTENSION = ".jay-contract";
+const JAY_TS_EXTENSION = ".jay-html.ts";
+const JAY_DTS_EXTENSION = ".jay-html.d.ts";
+const JAY_CONTRACT_DTS_EXTENSION = ".jay-contract.d.ts";
+const JAY_COMPONENT = "@jay-framework/component";
+const JAY_SECURE = "@jay-framework/secure";
+const JAY_RUNTIME = "@jay-framework/runtime";
+const JAY_4_REACT = "@jay-framework/4-react";
+const JAY_FULLSTACK_COMPONENTS = "@jay-framework/fullstack-component";
+const REACT = "react";
+const MAKE_JAY_COMPONENT = "makeJayComponent";
+const MAKE_JAY_TSX_COMPONENT = "makeJayTsxComponent";
+const MAKE_JAY_4_REACT_COMPONENT = "jay4react";
+var ImportsFor = /* @__PURE__ */ ((ImportsFor2) => {
+  ImportsFor2[ImportsFor2["definition"] = 0] = "definition";
+  ImportsFor2[ImportsFor2["implementation"] = 1] = "implementation";
+  ImportsFor2[ImportsFor2["elementSandbox"] = 2] = "elementSandbox";
+  return ImportsFor2;
+})(ImportsFor || {});
+let nextKey = 0;
+function importStatementFragment(module2, statement, ...usage) {
+  return { module: module2, index: nextKey++, statement, usage };
+}
+const importsOrder = {
+  JAY_RUNTIME: 1,
+  JAY_SECURE: 2,
+  REACT: 3,
+  JAY_4_REACT: 4
+};
+const Import = {
+  jayElement: importStatementFragment(
+    JAY_RUNTIME,
+    "JayElement",
+    0,
+    1,
+    2
+    /* elementSandbox */
+  ),
+  element: importStatementFragment(
+    JAY_RUNTIME,
+    "element as e",
+    1
+    /* implementation */
+  ),
+  svgElement: importStatementFragment(
+    JAY_RUNTIME,
+    "svgElement as svg",
+    1
+    /* implementation */
+  ),
+  mathMlElement: importStatementFragment(
+    JAY_RUNTIME,
+    "mathMLElement as ml",
+    1
+    /* implementation */
+  ),
+  dynamicText: importStatementFragment(
+    JAY_RUNTIME,
+    "dynamicText as dt",
+    1
+    /* implementation */
+  ),
+  dynamicAttribute: importStatementFragment(
+    JAY_RUNTIME,
+    "dynamicAttribute as da",
+    1
+    /* implementation */
+  ),
+  booleanAttribute: importStatementFragment(
+    JAY_RUNTIME,
+    "booleanAttribute as ba",
+    1
+    /* implementation */
+  ),
+  dynamicProperty: importStatementFragment(
+    JAY_RUNTIME,
+    "dynamicProperty as dp",
+    1
+    /* implementation */
+  ),
+  RenderElement: importStatementFragment(
+    JAY_RUNTIME,
+    "RenderElement",
+    1,
+    0,
+    2
+    /* elementSandbox */
+  ),
+  ReferencesManager: importStatementFragment(
+    JAY_RUNTIME,
+    "ReferencesManager",
+    1
+    /* implementation */
+  ),
+  SecureReferencesManager: importStatementFragment(
+    JAY_SECURE,
+    "SecureReferencesManager",
+    2
+    /* elementSandbox */
+  ),
+  conditional: importStatementFragment(
+    JAY_RUNTIME,
+    "conditional as c",
+    1
+    /* implementation */
+  ),
+  dynamicElement: importStatementFragment(
+    JAY_RUNTIME,
+    "dynamicElement as de",
+    1
+    /* implementation */
+  ),
+  svgDynamicElement: importStatementFragment(
+    JAY_RUNTIME,
+    "svgDynamicElement as dsvg",
+    1
+    /* implementation */
+  ),
+  mathMLDynamicElement: importStatementFragment(
+    JAY_RUNTIME,
+    "mathMLDynamicElement as dml",
+    1
+    /* implementation */
+  ),
+  forEach: importStatementFragment(
+    JAY_RUNTIME,
+    "forEach",
+    1
+    /* implementation */
+  ),
+  ConstructContext: importStatementFragment(
+    JAY_RUNTIME,
+    "ConstructContext",
+    1
+    /* implementation */
+  ),
+  HTMLElementCollectionProxy: importStatementFragment(
+    JAY_RUNTIME,
+    "HTMLElementCollectionProxy",
+    0,
+    1,
+    2
+    /* elementSandbox */
+  ),
+  HTMLElementProxy: importStatementFragment(
+    JAY_RUNTIME,
+    "HTMLElementProxy",
+    0,
+    1,
+    2
+    /* elementSandbox */
+  ),
+  childComp: importStatementFragment(
+    JAY_RUNTIME,
+    "childComp",
+    1
+    /* implementation */
+  ),
+  elemRef: importStatementFragment(
+    JAY_RUNTIME,
+    "elemRef as er",
+    1
+    /* implementation */
+  ),
+  elemCollectionRef: importStatementFragment(
+    JAY_RUNTIME,
+    "elemCollectionRef as ecr",
+    1
+    /* implementation */
+  ),
+  compRef: importStatementFragment(
+    JAY_RUNTIME,
+    "compRef as cr",
+    1
+    /* implementation */
+  ),
+  compCollectionRef: importStatementFragment(
+    JAY_RUNTIME,
+    "compCollectionRef as ccr",
+    1
+    /* implementation */
+  ),
+  RenderElementOptions: importStatementFragment(
+    JAY_RUNTIME,
+    "RenderElementOptions",
+    1,
+    0
+    /* definition */
+  ),
+  MapEventEmitterViewState: importStatementFragment(
+    JAY_RUNTIME,
+    "MapEventEmitterViewState",
+    1,
+    0,
+    2
+    /* elementSandbox */
+  ),
+  OnlyEventEmitters: importStatementFragment(
+    JAY_RUNTIME,
+    "OnlyEventEmitters",
+    1,
+    0,
+    2
+    /* elementSandbox */
+  ),
+  ComponentCollectionProxy: importStatementFragment(
+    JAY_RUNTIME,
+    "ComponentCollectionProxy",
+    1,
+    0,
+    2
+    /* elementSandbox */
+  ),
+  sandboxElementBridge: importStatementFragment(
+    JAY_SECURE,
+    "elementBridge",
+    2
+    /* elementSandbox */
+  ),
+  sandboxRoot: importStatementFragment(
+    JAY_SECURE,
+    "sandboxRoot",
+    2
+    /* elementSandbox */
+  ),
+  sandboxElement: importStatementFragment(
+    JAY_SECURE,
+    "sandboxElement as e",
+    2
+    /* elementSandbox */
+  ),
+  sandboxChildComp: importStatementFragment(
+    JAY_SECURE,
+    "sandboxChildComp as childComp",
+    2
+    /* elementSandbox */
+  ),
+  sandboxElemRef: importStatementFragment(
+    JAY_SECURE,
+    "elemRef as er",
+    2
+    /* elementSandbox */
+  ),
+  sandboxElemCollectionRef: importStatementFragment(
+    JAY_SECURE,
+    "elemCollectionRef as ecr",
+    2
+    /* elementSandbox */
+  ),
+  sandboxCompRef: importStatementFragment(
+    JAY_SECURE,
+    "compRef as cr",
+    2
+    /* elementSandbox */
+  ),
+  sandboxCompCollectionRef: importStatementFragment(
+    JAY_SECURE,
+    "compCollectionRef as ccr",
+    2
+    /* elementSandbox */
+  ),
+  sandboxForEach: importStatementFragment(
+    JAY_SECURE,
+    "sandboxForEach as forEach",
+    2
+    /* elementSandbox */
+  ),
+  handshakeMessageJayChannel: importStatementFragment(
+    JAY_SECURE,
+    "HandshakeMessageJayChannel",
+    2
+    /* elementSandbox */
+  ),
+  jayPort: importStatementFragment(
+    JAY_SECURE,
+    "JayPort",
+    2
+    /* elementSandbox */
+  ),
+  setWorkerPort: importStatementFragment(
+    JAY_SECURE,
+    "setWorkerPort",
+    2
+    /* elementSandbox */
+  ),
+  secureMainRoot: importStatementFragment(
+    JAY_SECURE,
+    "mainRoot as mr",
+    1
+    /* implementation */
+  ),
+  secureChildComp: importStatementFragment(
+    JAY_SECURE,
+    "secureChildComp",
+    1
+    /* implementation */
+  ),
+  functionRepository: importStatementFragment(
+    "./function-repository",
+    "funcRepository",
+    1
+    /* implementation */
+  ),
+  ReactElement: importStatementFragment(
+    `react`,
+    "ReactElement",
+    1,
+    0
+    /* definition */
+  ),
+  Jay4ReactElementProps: importStatementFragment(
+    JAY_4_REACT,
+    "Jay4ReactElementProps",
+    1,
+    0
+    /* definition */
+  ),
+  eventsFor: importStatementFragment(
+    JAY_4_REACT,
+    "eventsFor",
+    1,
+    0
+    /* definition */
+  ),
+  jay2React: importStatementFragment(
+    JAY_4_REACT,
+    "jay2React",
+    1,
+    0
+    /* definition */
+  ),
+  mimicJayElement: importStatementFragment(
+    JAY_4_REACT,
+    "mimicJayElement",
+    1,
+    0
+    /* definition */
+  ),
+  jayContract: importStatementFragment(
+    JAY_RUNTIME,
+    "JayContract",
+    1,
+    0,
+    2
+    /* elementSandbox */
+  )
+};
+class Imports {
+  constructor(imports) {
+    this.imports = imports;
+  }
+  plus(addImport) {
+    if (addImport instanceof Imports) {
+      return Imports.merge(this, addImport);
+    } else {
+      let newImports = [...this.imports];
+      newImports[addImport.index] = true;
+      return new Imports(newImports);
+    }
+  }
+  has(anImport) {
+    return !!this.imports[anImport.index];
+  }
+  render(importsFor) {
+    let moduleImportStatements = /* @__PURE__ */ new Map();
+    for (let importKey in Import) {
+      let importName = Import[importKey];
+      if (this.imports[importName.index] && importName.usage.includes(importsFor)) {
+        if (moduleImportStatements.has(importName.module))
+          moduleImportStatements.get(importName.module).push(importName.statement);
+        else
+          moduleImportStatements.set(importName.module, [importName.statement]);
+      }
+    }
+    const modulesToImport = [...moduleImportStatements.keys()].sort(
+      (a, b) => (importsOrder[a] || 999) - (importsOrder[b] || 999)
+    );
+    return modulesToImport.map(
+      (module2) => `import {${moduleImportStatements.get(module2).join(", ")}} from "${module2}";`
+    ).join("\n");
+  }
+  static none() {
+    return new Imports([]);
+  }
+  static for(...imports) {
+    let newImports = Imports.none();
+    imports.forEach((anImport) => newImports = newImports.plus(anImport));
+    return newImports;
+  }
+  static merge(imports1, imports2) {
+    let merged = [];
+    for (let i = 0; i < Math.max(imports1.imports.length, imports2.imports.length); i++)
+      merged[i] = imports1.imports[i] || imports2.imports[i];
+    return new Imports(merged);
+  }
+}
+var JayTypeKind = /* @__PURE__ */ ((JayTypeKind2) => {
+  JayTypeKind2[JayTypeKind2["atomic"] = 0] = "atomic";
+  JayTypeKind2[JayTypeKind2["typeAlias"] = 1] = "typeAlias";
+  JayTypeKind2[JayTypeKind2["enum"] = 2] = "enum";
+  JayTypeKind2[JayTypeKind2["html"] = 3] = "html";
+  JayTypeKind2[JayTypeKind2["imported"] = 4] = "imported";
+  JayTypeKind2[JayTypeKind2["element"] = 5] = "element";
+  JayTypeKind2[JayTypeKind2["elementConstructor"] = 6] = "elementConstructor";
+  JayTypeKind2[JayTypeKind2["component"] = 7] = "component";
+  JayTypeKind2[JayTypeKind2["object"] = 8] = "object";
+  JayTypeKind2[JayTypeKind2["array"] = 9] = "array";
+  JayTypeKind2[JayTypeKind2["union"] = 10] = "union";
+  return JayTypeKind2;
+})(JayTypeKind || {});
+class JayAtomicType {
+  constructor(name) {
+    __publicField(this, "kind", 0);
+    this.name = name;
+  }
+}
+const JayString = new JayAtomicType("string");
+const JayNumber = new JayAtomicType("number");
+const JayBoolean = new JayAtomicType("boolean");
+const JayDate = new JayAtomicType("Date");
+const JayUnknown = new JayAtomicType("Unknown");
+const typesMap = {
+  string: JayString,
+  number: JayNumber,
+  boolean: JayBoolean,
+  date: JayDate
+};
+function resolvePrimitiveType(typeName) {
+  return typesMap[typeName] || JayUnknown;
+}
+class JayTypeAlias {
+  constructor(name) {
+    __publicField(this, "kind", 1);
+    this.name = name;
+  }
+}
+class JayEnumType {
+  constructor(name, values) {
+    __publicField(this, "kind", 2);
+    this.name = name;
+    this.values = values;
+  }
+}
+class JayHTMLType {
+  constructor(name) {
+    __publicField(this, "kind", 3);
+    this.name = name;
+  }
+}
+class JayImportedType {
+  constructor(name, type) {
+    __publicField(this, "kind", 4);
+    this.name = name;
+    this.type = type;
+  }
+}
+class JayElementType {
+  constructor(name) {
+    __publicField(this, "kind", 5);
+    this.name = name;
+  }
+}
+class JayElementConstructorType {
+  constructor(name, typeName) {
+    __publicField(this, "kind", 6);
+    this.name = name;
+    this.typeName = typeName;
+  }
+}
+class JayComponentApiMember {
+  constructor(property, isEvent) {
+    this.property = property;
+    this.isEvent = isEvent;
+  }
+}
+class JayComponentType {
+  constructor(name, api) {
+    __publicField(this, "kind", 7);
+    this.name = name;
+    this.api = api;
+  }
+}
+class JayObjectType {
+  constructor(name, props) {
+    __publicField(this, "kind", 8);
+    this.name = name;
+    this.props = props;
+  }
+}
+class JayArrayType {
+  constructor(itemType) {
+    __publicField(this, "kind", 9);
+    this.itemType = itemType;
+  }
+  get name() {
+    return `Array<${this.itemType.name}>`;
+  }
+}
+class JayUnionType {
+  constructor(ofTypes) {
+    __publicField(this, "kind", 10);
+    this.ofTypes = ofTypes;
+  }
+  get name() {
+    return this.ofTypes.map((_) => _.name).join(" | ");
+  }
+  hasType(aType) {
+    return !!this.ofTypes.find((bType) => equalJayTypes(aType, bType));
+  }
+}
+function isAtomicType(aType) {
+  return aType.kind === 0;
+}
+function isTypeAliasType(aType) {
+  return aType.kind === 1;
+}
+function isEnumType(aType) {
+  return aType.kind === 2;
+}
+function isHTMLType(aType) {
+  return aType.kind === 3;
+}
+function isImportedType(aType) {
+  return aType.kind === 4;
+}
+function isElementConstructorType(aType) {
+  return aType.kind === 6;
+}
+function isElementType(aType) {
+  return aType.kind === 5;
+}
+function isComponentType(aType) {
+  return aType.kind === 7;
+}
+function isObjectType(aType) {
+  return aType.kind === 8;
+}
+function isArrayType(aType) {
+  return aType.kind === 9;
+}
+function isUnionType(aType) {
+  return aType.kind === 10;
+}
+function equalJayTypes(a, b) {
+  if (a.name !== b.name)
+    return false;
+  if (a instanceof JayAtomicType && b instanceof JayAtomicType)
+    return true;
+  else if (a instanceof JayEnumType && b instanceof JayEnumType)
+    return a.values.length === b.values.length && a.values.reduce(
+      (res, a_val, currentIndex) => res && a_val === b.values[currentIndex],
+      true
+    );
+  else if (a instanceof JayArrayType && b instanceof JayArrayType)
+    return equalJayTypes(a.itemType, b.itemType);
+  else if (a instanceof JayTypeAlias && b instanceof JayTypeAlias)
+    return true;
+  else if (a instanceof JayHTMLType && b instanceof JayHTMLType)
+    return true;
+  else if (a instanceof JayImportedType && b instanceof JayImportedType)
+    return equalJayTypes(a.type, b.type);
+  else if (a instanceof JayElementType && b instanceof JayElementType)
+    return true;
+  else if (a instanceof JayElementConstructorType && b instanceof JayElementConstructorType)
+    return a.typeName === b.typeName;
+  else if (a instanceof JayComponentType && b instanceof JayComponentType)
+    return a.api.length === b.api.length && a.api.reduce(
+      (res, a_val, currentIndex) => res && a_val.property === b.api[currentIndex].property && a_val.isEvent === b.api[currentIndex].isEvent,
+      true
+    );
+  else if (a instanceof JayObjectType && b instanceof JayObjectType) {
+    const aProps = new Set(Object.keys(a.props));
+    const bProps = new Set(Object.keys(b.props));
+    return aProps.size === bProps.size && [...aProps].map((aProp) => bProps.has(aProp) && equalJayTypes(a[aProp], b[aProp]));
+  } else if (a instanceof JayUnionType && b instanceof JayUnionType) {
+    return a.ofTypes.length === b.ofTypes.length && a.ofTypes.reduce((res, aType) => res && b.hasType(aType), true);
+  } else
+    ;
+}
+var RuntimeMode = /* @__PURE__ */ ((RuntimeMode2) => {
+  RuntimeMode2["MainTrusted"] = "mainTrusted";
+  RuntimeMode2["MainSandbox"] = "mainSandbox";
+  RuntimeMode2["WorkerTrusted"] = "workerTrusted";
+  RuntimeMode2["WorkerSandbox"] = "workerSandbox";
+  return RuntimeMode2;
+})(RuntimeMode || {});
+const TS_EXTENSION = ".ts";
+const TSX_EXTENSION = ".tsx";
+const JAY_QUERY_PREFIX = "?jay-";
+const JAY_QUERY_MAIN_SANDBOX = `${JAY_QUERY_PREFIX}${"mainSandbox"}`;
+const JAY_QUERY_WORKER_TRUSTED = `${JAY_QUERY_PREFIX}${"workerTrusted"}`;
+const JAY_QUERY_WORKER_SANDBOX = `${JAY_QUERY_PREFIX}${"workerSandbox"}`;
+const JAY_QUERY_MAIN_SANDBOX_TS = `${JAY_QUERY_PREFIX}${"mainSandbox"}${TS_EXTENSION}`;
+const JAY_QUERY_WORKER_TRUSTED_TS = `${JAY_QUERY_PREFIX}${"workerTrusted"}${TS_EXTENSION}`;
+const JAY_QUERY_WORKER_SANDBOX_TS = `${JAY_QUERY_PREFIX}${"workerSandbox"}${TS_EXTENSION}`;
+function hasExtension(filename, extension, { withTs = false } = {}) {
+  const fullTsExtension = withTs ? `${extension}${TS_EXTENSION}` : extension;
+  const fullTsxExtension = withTs ? `${extension}${TSX_EXTENSION}` : extension;
+  return filename.endsWith(fullTsExtension) && filename.length > fullTsExtension.length || filename.endsWith(fullTsxExtension) && filename.length > fullTsxExtension.length;
+}
+function hasJayModeExtension(filename, { withTs = false } = {}) {
+  return hasExtension(filename, JAY_QUERY_MAIN_SANDBOX, { withTs }) || hasExtension(filename, JAY_QUERY_WORKER_TRUSTED, { withTs }) || hasExtension(filename, JAY_QUERY_WORKER_SANDBOX, { withTs });
+}
+function getModeFileExtension(isSandbox, importerMode, { withTs = false } = {}) {
+  const tsExtension = withTs ? TS_EXTENSION : "";
+  const mode = getMode(isSandbox, importerMode);
+  return mode === "mainTrusted" ? tsExtension : `${JAY_QUERY_PREFIX}${mode}${tsExtension}`;
+}
+function getMode(isSandbox, importerMode) {
+  switch (importerMode) {
+    case "mainTrusted":
+      return isSandbox ? "mainSandbox" : "mainTrusted";
+    case "workerTrusted":
+      return isSandbox ? "workerSandbox" : "workerTrusted";
+    default:
+      return importerMode;
+  }
+}
+function getModeFromExtension(filename) {
+  const modeString = `?${filename.split("?").pop()}`;
+  switch (modeString) {
+    case JAY_QUERY_MAIN_SANDBOX_TS:
+      return "mainSandbox";
+    case JAY_QUERY_WORKER_TRUSTED_TS:
+      return "workerTrusted";
+    case JAY_QUERY_WORKER_SANDBOX_TS:
+      return "workerSandbox";
+    default:
+      return "mainTrusted";
+  }
+}
+function getJayTsFileSourcePath(filename) {
+  const beforeExtension = filename.split("?");
+  if (beforeExtension.length === 1) {
+    throw new Error(
+      `Filename ${filename} does not contain jay mode extension "?jay-[mode].ts"`
+    );
+  }
+  return `${beforeExtension.slice(0, -1).join("")}.ts`;
+}
+function withoutExtension(filename, extension) {
+  if (!filename.endsWith(extension)) {
+    throw new Error(`Filename ${filename} does not end with extension ${extension}`);
+  }
+  return filename.slice(0, -extension.length);
+}
+class WithValidations {
+  constructor(val, validations = []) {
+    __publicField(this, "val");
+    __publicField(this, "validations");
+    this.val = val;
+    this.validations = validations;
+  }
+  map(func) {
+    if (this.val)
+      return new WithValidations(func(this.val), this.validations);
+    else
+      return new WithValidations(void 0, this.validations);
+  }
+  async mapAsync(func) {
+    if (this.val) {
+      const result = await func(this.val);
+      return new WithValidations(result, this.validations);
+    } else {
+      return new WithValidations(void 0, this.validations);
+    }
+  }
+  flatMap(func) {
+    if (this.val) {
+      let that = func(this.val);
+      return new WithValidations(that.val, [...this.validations, ...that.validations]);
+    } else
+      return new WithValidations(void 0, this.validations);
+  }
+  async flatMapAsync(func) {
+    if (this.val) {
+      const result = await func(this.val);
+      return new WithValidations(result.val, [...this.validations, ...result.validations]);
+    } else {
+      return new WithValidations(void 0, this.validations);
+    }
+  }
+  merge(other, merge) {
+    return new WithValidations(merge(this.val, other.val), [
+      ...this.validations,
+      ...other.validations
+    ]);
+  }
+}
+function checkValidationErrors(withValidations) {
+  const { validations } = withValidations;
+  if (validations.length > 0) {
+    throw new Error(validations.join("\n"));
+  }
+  return withValidations.val;
+}
+var SourceFileFormat = /* @__PURE__ */ ((SourceFileFormat2) => {
+  SourceFileFormat2["JayHtml"] = "jay-html";
+  SourceFileFormat2["JayTsx"] = "jay-tsx";
+  SourceFileFormat2["JayContract"] = "jay-contract";
+  SourceFileFormat2["TypeScript"] = "typeScript";
+  return SourceFileFormat2;
+})(SourceFileFormat || {});
+function mergeRefsTrees(...trees) {
+  const allRefs = trees.flatMap((tree) => tree.refs);
+  const allChildren = {};
+  const allKeys = new Set(trees.flatMap((tree) => Object.keys(tree.children)));
+  for (const key of allKeys) {
+    const childTrees = trees.filter((tree) => tree.children[key] !== void 0).map((tree) => tree.children[key]);
+    if (childTrees.length > 0) {
+      allChildren[key] = mergeRefsTrees(...childTrees);
+    }
+  }
+  const isRepeated = trees.some((tree) => tree.repeated);
+  return mkRefsTree(allRefs, allChildren, isRepeated);
+}
+function hasRefs(refs, includingAutoRefs) {
+  const onlyNonAutoRefs = (ref) => !ref.autoRef;
+  const allRefs = (ref) => true;
+  return refs.refs.filter(includingAutoRefs ? allRefs : onlyNonAutoRefs).length > 0 || refs.imported || Object.entries(refs.children).map(([ref, refs2]) => hasRefs(refs2, includingAutoRefs)).reduce((prev, curr) => prev || curr, false);
+}
+function nestRefs(path, renderFragment) {
+  let refs = renderFragment.refs;
+  for (let index = path.length - 1; index >= 0; --index) {
+    refs = mkRefsTree([], { [path[index]]: refs }, refs.repeated);
+  }
+  return new RenderFragment(
+    renderFragment.rendered,
+    renderFragment.imports,
+    renderFragment.validations,
+    refs
+  );
+}
+function mkRefsTree(refs, children, repeated = false, refsTypeName, repeatedRefsTypeName) {
+  if (refsTypeName)
+    return {
+      kind: "refTree",
+      refs,
+      children,
+      repeated,
+      imported: { refsTypeName, repeatedRefsTypeName }
+    };
+  else
+    return { kind: "refTree", refs, children, repeated };
+}
+function mkRef(ref, originalName, constName, repeated, autoRef, viewStateType, elementType) {
+  return {
+    kind: "ref",
+    originalName,
+    ref,
+    constName,
+    repeated,
+    autoRef,
+    viewStateType,
+    elementType
+  };
+}
+class RenderFragment {
+  constructor(rendered, imports = Imports.none(), validations = [], refs = mkRefsTree([], {})) {
+    __publicField(this, "rendered");
+    __publicField(this, "imports");
+    __publicField(this, "validations");
+    __publicField(this, "refs");
+    this.rendered = rendered;
+    this.imports = imports;
+    this.validations = validations;
+    this.refs = refs;
+  }
+  map(f) {
+    return new RenderFragment(f(this.rendered), this.imports, this.validations, this.refs);
+  }
+  plusImport(imp) {
+    return new RenderFragment(
+      this.rendered,
+      this.imports.plus(imp),
+      this.validations,
+      this.refs
+    );
+  }
+  static empty() {
+    return new RenderFragment("", Imports.none());
+  }
+  static merge(fragment1, fragment2, combinator = "") {
+    const rendered = !!fragment1.rendered && !!fragment2.rendered ? `${fragment1.rendered}${combinator}${fragment2.rendered}` : !!fragment1.rendered ? fragment1.rendered : fragment2.rendered;
+    const newRefsTree = mergeRefsTrees(fragment1.refs, fragment2.refs);
+    return new RenderFragment(
+      rendered,
+      Imports.merge(fragment1.imports, fragment2.imports),
+      [...fragment1.validations, ...fragment2.validations],
+      newRefsTree
+    );
+  }
+}
+var GenerateTarget = /* @__PURE__ */ ((GenerateTarget2) => {
+  GenerateTarget2[GenerateTarget2["jay"] = 0] = "jay";
+  GenerateTarget2[GenerateTarget2["react"] = 1] = "react";
+  return GenerateTarget2;
+})(GenerateTarget || {});
+function withOriginalTrace(error, originalError) {
+  error.stack = `${error.stack}
+Caused by
+${originalError.stack}`;
+  return error;
+}
+async function prettify(code, options = {}) {
+  try {
+    return await prettier__namespace.format(code, {
+      printWidth: 100,
+      singleQuote: true,
+      tabWidth: 4,
+      parser: "typescript",
+      ...options
+    });
+  } catch (error) {
+    throw new Error(`failed to prettify code
+original error: ${error.message}
+code:
+${code}`);
+  }
+}
+function prettifyHtml(html) {
+  return jsBeautify.html(
+    html.split("\n").map((line) => line.trim()).join(""),
+    {
+      indent_size: 2,
+      wrap_line_length: 100
+    }
+  );
+}
+function removeComments(code) {
+  return code.split("\n").filter(
+    (line) => !(line.includes("// @ts-expect-error ") || line.includes("// @ts-ignore") || line.includes("{/* @ts-ignore */}"))
+  ).join("\n");
+}
+exports.GenerateTarget = GenerateTarget;
+exports.Import = Import;
+exports.Imports = Imports;
+exports.ImportsFor = ImportsFor;
+exports.JAY_4_REACT = JAY_4_REACT;
+exports.JAY_COMPONENT = JAY_COMPONENT;
+exports.JAY_CONTRACT_DTS_EXTENSION = JAY_CONTRACT_DTS_EXTENSION;
+exports.JAY_CONTRACT_EXTENSION = JAY_CONTRACT_EXTENSION;
+exports.JAY_DTS_EXTENSION = JAY_DTS_EXTENSION;
+exports.JAY_EXTENSION = JAY_EXTENSION;
+exports.JAY_FULLSTACK_COMPONENTS = JAY_FULLSTACK_COMPONENTS;
+exports.JAY_QUERY_MAIN_SANDBOX = JAY_QUERY_MAIN_SANDBOX;
+exports.JAY_QUERY_MAIN_SANDBOX_TS = JAY_QUERY_MAIN_SANDBOX_TS;
+exports.JAY_QUERY_PREFIX = JAY_QUERY_PREFIX;
+exports.JAY_QUERY_WORKER_SANDBOX = JAY_QUERY_WORKER_SANDBOX;
+exports.JAY_QUERY_WORKER_SANDBOX_TS = JAY_QUERY_WORKER_SANDBOX_TS;
+exports.JAY_QUERY_WORKER_TRUSTED = JAY_QUERY_WORKER_TRUSTED;
+exports.JAY_QUERY_WORKER_TRUSTED_TS = JAY_QUERY_WORKER_TRUSTED_TS;
+exports.JAY_RUNTIME = JAY_RUNTIME;
+exports.JAY_SECURE = JAY_SECURE;
+exports.JAY_TS_EXTENSION = JAY_TS_EXTENSION;
+exports.JayArrayType = JayArrayType;
+exports.JayAtomicType = JayAtomicType;
+exports.JayBoolean = JayBoolean;
+exports.JayComponentApiMember = JayComponentApiMember;
+exports.JayComponentType = JayComponentType;
+exports.JayDate = JayDate;
+exports.JayElementConstructorType = JayElementConstructorType;
+exports.JayElementType = JayElementType;
+exports.JayEnumType = JayEnumType;
+exports.JayHTMLType = JayHTMLType;
+exports.JayImportedType = JayImportedType;
+exports.JayNumber = JayNumber;
+exports.JayObjectType = JayObjectType;
+exports.JayString = JayString;
+exports.JayTypeAlias = JayTypeAlias;
+exports.JayTypeKind = JayTypeKind;
+exports.JayUnionType = JayUnionType;
+exports.JayUnknown = JayUnknown;
+exports.MAKE_JAY_4_REACT_COMPONENT = MAKE_JAY_4_REACT_COMPONENT;
+exports.MAKE_JAY_COMPONENT = MAKE_JAY_COMPONENT;
+exports.MAKE_JAY_TSX_COMPONENT = MAKE_JAY_TSX_COMPONENT;
+exports.REACT = REACT;
+exports.RenderFragment = RenderFragment;
+exports.RuntimeMode = RuntimeMode;
+exports.SourceFileFormat = SourceFileFormat;
+exports.TSX_EXTENSION = TSX_EXTENSION;
+exports.TS_EXTENSION = TS_EXTENSION;
+exports.WithValidations = WithValidations;
+exports.checkValidationErrors = checkValidationErrors;
+exports.equalJayTypes = equalJayTypes;
+exports.getJayTsFileSourcePath = getJayTsFileSourcePath;
+exports.getMode = getMode;
+exports.getModeFileExtension = getModeFileExtension;
+exports.getModeFromExtension = getModeFromExtension;
+exports.hasExtension = hasExtension;
+exports.hasJayModeExtension = hasJayModeExtension;
+exports.hasRefs = hasRefs;
+exports.isArrayType = isArrayType;
+exports.isAtomicType = isAtomicType;
+exports.isComponentType = isComponentType;
+exports.isElementConstructorType = isElementConstructorType;
+exports.isElementType = isElementType;
+exports.isEnumType = isEnumType;
+exports.isHTMLType = isHTMLType;
+exports.isImportedType = isImportedType;
+exports.isObjectType = isObjectType;
+exports.isTypeAliasType = isTypeAliasType;
+exports.isUnionType = isUnionType;
+exports.mergeRefsTrees = mergeRefsTrees;
+exports.mkRef = mkRef;
+exports.mkRefsTree = mkRefsTree;
+exports.nestRefs = nestRefs;
+exports.prettify = prettify;
+exports.prettifyHtml = prettifyHtml;
+exports.removeComments = removeComments;
+exports.resolvePrimitiveType = resolvePrimitiveType;
+exports.withOriginalTrace = withOriginalTrace;
+exports.withoutExtension = withoutExtension;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@jay-framework/compiler-shared",
+  "version": "0.5.0",
+  "description": "",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "dist",
+    "readme.md"
+  ],
+  "scripts": {
+    "build": "npm run build:js && npm run build:types",
+    "build:watch": "npm run build:js -- --watch & npm run build:types -- --watch",
+    "build:js": "vite build",
+    "build:types": "tsup lib/index.ts --dts-only --format cjs",
+    "build:check-types": "tsc",
+    "clean": "rimraf dist",
+    "confirm": "npm run clean && npm run build && npm run build:check-types && npm run test",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "author": "",
+  "dependencies": {
+    "@jay-framework/component": "workspace:^",
+    "@jay-framework/runtime": "workspace:^",
+    "@jay-framework/secure": "workspace:^",
+    "@types/js-yaml": "^4.0.9",
+    "change-case": "^4.1.2",
+    "js-beautify": "^1.14.11",
+    "js-yaml": "^4.1.0",
+    "node-html-parser": "^6.1.12",
+    "pegjs": "^0.10.0",
+    "pluralize": "^8.0.0",
+    "typescript": "^5.3.3"
+  },
+  "devDependencies": {
+    "@caiogondim/strip-margin": "^1.0.0",
+    "@jay-framework/dev-environment": "workspace:^",
+    "@testing-library/jest-dom": "^6.2.0",
+    "@types/js-beautify": "^1",
+    "@types/node": "^20.11.5",
+    "jest-diff": "^29.7.0",
+    "jest-matcher-utils": "^29.7.0",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.1",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.1"
+  }
+}