regor 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ahmed Yasin Koculu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+![img](https://raw.githubusercontent.com/koculu/regor/main/docs/images/logo1.png)
+
+# Regor
+
+Regor is a powerful UI framework designed to streamline the development of HTML5-based applications for both web and desktop environments. With a template syntax that closely follows Vue.js, transitioning from VueJS to Regor is seamless for developers familiar with Vue.
+
+## Key Features
+
+- **Simplicity:** Develop UIs without a Virtual DOM for a more straightforward implementation and easier debugging.
+- **TypeScript:** Enjoy native TypeScript support without workarounds.
+- **No Build Step Required:** Define components in TypeScript using tagged string templates, no build step needed.
+- **Secure Evaluation:** Regor's secure JavaScript VM ensures safe runtime compilation. You can enable security policy in your page without removing runtime compilation support.
+
+```html
+<meta
+  http-equiv="Content-Security-Policy"
+  content="require-trusted-types-for 'script';"
+/>
+```
+
+- **Flexible Reactivity:** Empowering developers with a highly flexible reactivity system.
+- **Non-JS SSR:** Bind to the existing DOM without removing already mounted HTML elements, suitable for non-JavaScript server-side rendering.
+- **Reentrance:** Regor supports multiple mountings in the previously mounted area using the same or different app contexts. This enables creating and mounting new directives dynamically.
+- **Compatibility:** Rendered pages are designed for seamless integration with other libraries manipulating the DOM.
+
+## Getting started
+
+Click and count sample source:
+
+```ts
+import { createApp, ref } from 'regor'
+
+createApp({
+  count: ref(0),
+})
+```
+
+HTML:
+
+```html
+<div id="app">
+  <button @click="count++">Count is: {{ count }}</button>
+</div>
+```
+
+Defining component:
+
+```ts
+import { createApp, createComponent, ref, html, type Ref } from 'regor'
+
+interface MyComponent {
+  message: Ref<string>
+}
+
+const myComponent = createComponent<MyComponent>(
+  'MyComponent',
+  (head) => ({
+    message: head.props.message,
+    count: ref(0),
+  }),
+  {
+    html: html`<button @click="count++">{{ message }} {{ count }}</button>`,
+  },
+  {
+    props: ['message'],
+  },
+)
+
+createApp({
+  components: { myComponent },
+  message: ref('Count is:'),
+})
+```
+
+HTML:
+
+```html
+<div id="app">
+  <MyComponent :message="message"></MyComponent>
+</div>
+```
+
+## Installation
+
+`yarn add regor`
+
+## Comparison with VueJs
+
+Regor shares core functionality with VueJs but differs in implementation, TypeScript support, template evaluation, reactivity, server-side rendering support, compatibility.
+
+## Supported Directives
+
+Regor provides a set of directives that allow you to enhance the behavior and appearance of your applications. Similar to Vue's directives, Regor's directives start with the "r-" prefix.
+
+> **Note:** The directive prefix "r-" can be customized using `RegorConfig.getDefault().setDirectives('v-')` to align with a different naming convention, such as Vue's "v-" prefix.
+
+- **r-bind:** Binds an element's attribute to a component's data, allowing dynamic updates.
+- **r-model:** Enables two-way data binding between form inputs.
+- **r-text:** Sets the element's text content to the result of an expression.
+- **r-html:** Renders the result of an expression as HTML content within the element.
+- **r-on:** Attaches event listeners to the element and invokes specified component methods.
+- **r-show:** Conditionally displays the element based on the truthiness of an expression.
+- **r-for:** Renders a set of elements based on an array and a template.
+- **r-if:** Conditionally renders the element based on the truthiness of an expression.
+- **r-else:** Provides an alternative rendering when used in conjunction with r-if.
+- **r-else-if:** Conditionally renders the element as an alternative to r-if.
+- **r-pre:** Excludes HTML element from Regor bindings.
+- **:class:** Binds one or more class names to an element based on expressions.
+- **:style:** Binds one or more inline styles to an element based on expressions.
+- **:ref:** Provides a reference to an element in the template, allowing you to interact with it programmatically.
+- **:key:** Provides a unique identifier for each item in a list, aiding efficient updates and rendering.
+- **:is:** Specifies the component to dynamically render based on a value or expression.
+- **r-teleport:** Teleports the element to anywhere in the DOM. Unlike Vue, teleport is a directive to avoid component overhead.
+- **:props:** Vue uses v-bind for component property passing. However, this can conflict with v-bind's attribute fall-through logic. Hence, Regor defines a dedicated directive to pass properties using object syntax. It enables passing properties without defining them in the component's props contract.
+- **:props-once:** Similar to :props but it doesn't observe entire reactive tree of the template expression. Tail reactivity still works.
+- **@** Shorthand for `r-on` to bind event listeners.
+- **:** Shorthand for `r-bind` to bind element attributes.
+- **.** Shorthand for `r-bind.prop` to set properties.
+
+These directives empower you to create dynamic and interactive user interfaces, enhancing the user experience of your Regor-powered applications.
+
+## Regor API
+
+**App / Component Template Functions**
+
+- **createApp:** Similar to Vue's `createApp`, it initializes a Regor application instance.
+- **createComponent:** Creates a Regor component instance, akin to Vue's component creation.
+- **toFragment:** Converts a JSON template to a DOM element fragment.
+- **toJsonTemplate:** Converts a DOM element to a JSON template.
+
+**Cleanup Functions**
+
+- **addUnbinder:** Adds an unbinder to a DOM element.
+- **getBindData:** Retrieves bind data associated with a DOM element.
+- **removeNode:** Removes a node while properly disposing of associated bind data and observers.
+- **unbind:** Unbinds a node, disposing of observers and bind data.
+
+**Compute Functions**
+
+- **computed:** Similar to Vue's `computed`, it creates a computed property.
+- **computeRef:** Computes the value observing a single ref, more efficient than observing any.
+- **computeMany:** Computes the value observing given refs, more efficient than observing any.
+- **watchEffect:** Similar to Vue's `watchEffect`, it watches for reactive changes.
+- **collectRefs:** Like `watchEffect`, but runs once and returns all refs used in the evaluated action.
+- **silence:** Silences the ref collection in a `watchEffect` or `collectRefs`.
+
+**Misc Functions**
+
+- **flatten:** Flattens a given ref object into a raw object recursively.
+- **isRaw:** Checks if a given ref is marked as raw.
+- **markRaw:** Marks a ref as raw.
+- **persist:** Persists a given ref in local storage reactively.
+- **html:** A tag to produce HTML string using template literals. Recommended to use with the VS-Code [`lit-html`](https://marketplace.visualstudio.com/items?itemName=bierner.lit-html) extension for formatting and highlighting.
+- **raw:** A tag to produce HTML string, similar to `html`, but it is excluded from formatting when [`lit-html`](https://marketplace.visualstudio.com/items?itemName=bierner.lit-html) extension is installed.
+
+**Observe Functions**
+
+- **observe:** Observes changes in a single ref.
+- **observeMany:** Observes changes in multiple refs.
+- **observerCount:** Retrieves the active observer count of a ref.
+- **batch:** Performs batch updates, triggering changes at the end. Use with caution due to possible dirty reads.
+- **startBatch:** Starts a batch update.
+- **endBatch:** Ends a started batch update and triggers affected refs.
+
+**Reactivity Functions**
+
+- **ref:** Creates a deep ref object recursively, modifying the source object in place.
+- **sref:** Creates a simple ref object from a given value, without nested ref creation.
+- **isDeepRef:** Returns true if a given ref is created with `ref()` function.
+- **isRef:** Returns true for any ref, false for non-refs.
+- **pause:** Pauses a ref's auto-trigger on value change.
+- **resume:** Resumes a ref's auto-trigger on value change.
+- **trigger:** Manually triggers a ref to inform its observers.
+- **unref:** Unwraps a ref, returning the raw value.
+- **entangle:** Entangles two refs to sync their value changes.
+
+**Composition Functions**
+
+- **useScope:** In a scope, you can use `onMounted` and `onUnmounted` functions. Components are always created in scope. Use the useScope for apps created by createApp. Similar to Vue's `effectScope`, useScope provides efficient cleanup of watchEffects, computed refs and enables the `onMounted` and `onUnmounted` usage.
+- **onMounted:** Similar to Vue's `onMounted`, it executes when the component is mounted.
+- **onUnmounted:** Similar to Vue's `onUnmounted`, it executes when the component is unmounted.
+
+**Log Configuration**
+
+- **warningHandler:** Customize or turn off console warnings.
+
+## Contributing
+
+This project welcomes contributions and suggestions. Please follow [CONTRIBUTING.md](.github/CONTRIBUTING.md) instructions.
+
+## Acknowledgments
+
+Regor is built upon the shoulders of giants, drawing inspiration from Vue and its vibrant community of contributors. The well-defined concepts and principles from Vue have played a pivotal role in shaping Regor's foundation. We extend our heartfelt gratitude to the Vue project and its dedicated contributors for their pioneering work in the realm of UI frameworks.
+
+Special thanks to the Vue team and its community for creating a thriving ecosystem that continues to inspire innovation in the field of web development.
+
+Regor also utilizes [**Jsep**](https://github.com/EricSmekens/jsep), a fast and lightweight JavaScript expression parser. Jsep's contribution to Regor's functionality is greatly appreciated.
+
+Additionally, we would like to acknowledge the [**happy-dom**](https://github.com/capricorn86/happy-dom) library, which played a significant role in our testing process.
+
+We also extend a warm welcome to any future contributors who join the Regor project. Your contributions will play a vital role in shaping the framework's growth and evolution.
+
+Thank you to everyone who has contributed, inspired, and supported Regor's development journey. Your dedication and passion are invaluable.

package/dist/regor.d.ts

@@ -0,0 +1,267 @@
+// Generated by dts-bundle-generator v8.0.1
+
+export declare class ComponentHead<TProps = Record<any, any>> {
+	props: TProps;
+	start: Comment;
+	end: Comment;
+	ctx: IRegorContext[];
+	/** Automatically assigns properties defined in the :props binding to the component context when enabled. If disabled, props should be manually assigned using head.props.
+	 * Default: true */
+	autoProps: boolean;
+	/** When both autoProps and entangle are enabled,
+	 * the refs defined in the component context (without using head.props)
+	 * become entangled with the head.props refs. (parent[ref] <==> component[ref])
+	 * This means that changes to parent[ref] reflect in component[ref], and vice versa.
+	 * Disable this flag to isolate refs created within the component context.
+	 * Default: true */
+	entangle: boolean;
+	/** disables slot context switch to the parent */
+	disableSwitch: boolean;
+	/** A callback invoked after auto props get assigned to the component context. */
+	onAutoPropsAssigned?: () => void;
+	constructor(props: TProps, element: Element, ctx: IRegorContext[], start: Comment, end: Comment);
+	/** use arrow syntax to be called without using head.emit.bind(head) in Binder.ts. */
+	emit: (event: string, args: Record<any, any>) => void;
+	unmount(): void;
+}
+export declare class RegorConfig {
+	static getDefault(): RegorConfig;
+	forGrowThreshold: number;
+	globalContext: Record<string, any>;
+	useInterpolation: boolean;
+	constructor(globalContext?: Record<any, any>);
+	addComponent<TProps = Record<any, any>>(...components: Array<Component<TProps>>): void;
+	setDirectives(prefix: string): void;
+	updateDirectives(updater: (directiveMap: Record<string, Directive>, builtInNames: Record<string, string>) => void): void;
+}
+export type IsNull<T> = [
+	T
+] extends [
+	null
+] ? true : false;
+export type Equals<T, U> = T extends U ? (U extends T ? true : false) : false;
+export type RawTypes = string | Function | number | boolean | symbol | undefined | null | bigint | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | Node | EventTarget | Event | RawMarker | Date | RegExp | Promise<unknown> | Error;
+declare const RefSymbol: unique symbol;
+declare const RawSymbol: unique symbol;
+declare const ScopeSymbol: unique symbol;
+export type AnyRef = (newValue?: unknown, eventSource?: unknown) => any & {
+	[RefSymbol]: true;
+};
+export type Ref<TValueType> = ((newValue?: RefContent<TValueType> | Ref<RefParam<TValueType>> | SRef<RefContent<TValueType>>, eventSource?: any) => RefContent<TValueType>) & AnyRef & {
+	value: RefContent<TValueType>;
+};
+export type SRef<TValueType> = ((newValue?: TValueType | SRef<TValueType>, eventSource?: any) => SRefContent<TValueType>) & AnyRef & {
+	value: SRefContent<TValueType>;
+};
+export type ComputedRef<TValueType> = SRef<TValueType> & {
+	stop: StopObserving;
+};
+export interface RawMarker {
+	[RawSymbol]: true;
+}
+export type RefContent<TValueType> = TValueType extends undefined ? never : TValueType extends Ref<infer V1> ? RefContent<V1> : TValueType extends SRef<infer V2> ? V2 : TValueType extends Array<infer V3> ? Array<Ref<RefParam<V3>>> : TValueType extends RawTypes ? TValueType : {
+	[Key in keyof TValueType]: Key extends symbol ? TValueType[Key] : TValueType[Key] extends Ref<infer V4> ? Ref<RefParam<V4>> : TValueType[Key] extends SRef<infer V5> ? Ref<RefParam<V5>> : TValueType[Key] extends RawMarker ? TValueType[Key] : Ref<RefParam<TValueType[Key]>>;
+};
+export type RefParam<TValueType> = Equals<TValueType, MakeRefParam<TValueType>> extends true ? TValueType : MakeRefParam<TValueType>;
+export type MakeRefParam<TValueType> = TValueType extends undefined ? never : TValueType extends Ref<infer V1> ? MakeRefParam<V1> : TValueType extends SRef<infer V2> ? MakeRefParam<V2> : TValueType extends Array<infer V3> ? Array<MakeRefParam<V3>> : TValueType extends RawTypes ? TValueType : {
+	[Key in keyof TValueType]: TValueType[Key] extends Ref<infer V4> ? MakeRefParam<V4> : TValueType[Key] extends SRef<infer V5> ? MakeRefParam<V5> : MakeRefParam<TValueType[Key]>;
+};
+export type SRefContent<TValueType> = Equals<TValueType, MakeSRefContent<TValueType>> extends true ? TValueType : MakeSRefContent<TValueType>;
+export type MakeSRefContent<TValueType> = TValueType extends undefined ? never : TValueType extends Ref<infer V1> ? RefContent<V1> : TValueType extends SRef<infer V2> ? V2 : TValueType extends Array<infer V3> ? V3[] : TValueType extends RawTypes ? TValueType : TValueType;
+export type UnwrapRef<TRef> = TRef extends Ref<infer V1> ? RefContent<V1> : TRef extends SRef<infer V2> ? SRefContent<V2> : TRef;
+export type FlattenRef<TRef> = TRef extends Array<infer V1> ? Array<FlattenRef<V1>> : TRef extends Ref<infer V2> ? FlattenRef<V2> : TRef extends SRef<infer V3> ? FlattenRef<V3> : TRef extends AnyRef ? unknown : TRef extends RawTypes ? TRef : {
+	[Key in keyof TRef]: FlattenRef<TRef[Key]>;
+};
+export type ObserveCallback<TValueType> = (newValue: TValueType, eventSource?: any) => void;
+export type StopObserving = () => void;
+export declare interface IRegorContext extends Record<any, any> {
+	components?: Record<string, Component<any>>;
+	mounted?: () => void;
+	unmounted?: () => void;
+}
+export type IsLazy = (i: number, d: number) => boolean;
+export type IsLazyKey = (key: string, d: number) => boolean;
+export interface Directive {
+	isLazy?: IsLazy;
+	isLazyKey?: IsLazyKey;
+	collectRefObj?: boolean;
+	/** if once is enabled, the onChange is never triggered.
+	 * The refs in parseResult are still reactive. */
+	once?: boolean;
+	/** Called on every value change. */
+	onChange?: (el: HTMLElement, values: any[], previousValues?: any[], option?: any, previousOption?: any, flags?: string[]) => void;
+	/** Called on binding. Returns unbinder.  */
+	onBind?: (el: HTMLElement, parseResult: ParseResult, expr: string, option?: string, dynamicOption?: ParseResult, flags?: string[]) => Unbinder;
+}
+export interface BindData {
+	unbinders: Unbinder[];
+	data: Record<any, any>;
+}
+export type Unbinder = () => void;
+export interface ParseResult {
+	value: SRef<unknown[]>;
+	stop: StopObserving;
+	refs: Array<AnyRef | undefined>;
+	context: Record<any, any>;
+}
+export type OnCleanup = (cleanup: () => void) => void;
+export interface JSONTemplate {
+	/** tag-name */
+	t?: string;
+	/** attributes */
+	a?: Record<string, string>;
+	/** children */
+	c?: JSONTemplate[];
+	/** text node content */
+	d?: string;
+	/** node type if node is COMMENT_NODE */
+	n?: number;
+}
+/**
+ * Represents a template configuration for rendering a component or an app.
+ * If used with 'createApp':
+ * - Define either 'selector' or 'element' to specify the mounting point.
+ * - Optionally, 'html' or 'json' can be defined to override the inner HTML of the mounting point.
+ * - If neither 'html' nor 'json' template is defined, the mounting point's inner HTML remains unchanged.
+ * If used with 'createComponent':
+ * - Define only one option: 'selector', 'element', 'html', or 'json'. The single option defines the component's HTML template.
+ */
+export interface Template {
+	/**
+	 * If used with 'createApp', specifies the target root element for mounting the application.
+	 * If used with 'createComponent', identifies the component template using a selector.
+	 */
+	selector?: string;
+	/**
+	 * If used with 'createApp', represents the actual DOM element where the app will be mounted.
+	 * If used with 'createComponent', specifies the component template using an element.
+	 * Use this property if you already have a reference to the target element.
+	 */
+	element?: Node;
+	/**
+	 *  If used with 'createApp', HTML template string that will replace the content of the root element defined by 'selector' or 'element'.
+	 * If used with 'createComponent', this template populates the content of the component.
+	 */
+	html?: string;
+	/**
+	 * JSON-based template representation, enabling rendering within secure contexts.
+	 * Can be a single JSONTemplate object or an array of JSONTemplate objects.
+	 * This property is applicable to both 'createApp' and 'createComponent'.
+	 */
+	json?: JSONTemplate | JSONTemplate[];
+	/**
+	 * Indicates whether the component template contains SVG elements.
+	 * Enable this flag if SVG content is present to ensure proper rendering.
+	 * This property is applicable to both 'createApp' and 'createComponent'.
+	 */
+	isSVG?: boolean;
+}
+export interface App<TRegorContext extends IRegorContext> {
+	context: TRegorContext;
+	unmount: () => void;
+	unbind: () => void;
+}
+export interface Component<TProps = Record<any, any>> {
+	name: string;
+	context: (head: ComponentHead<TProps>) => IRegorContext;
+	template: Template;
+	inheritAttrs?: boolean;
+	props?: string[];
+}
+export type OnMounted = () => void;
+export type OnUnmounted = () => void;
+export interface CreateComponentOptions {
+	useInterpolation?: boolean;
+	config?: RegorConfig;
+	inheritAttrs?: boolean;
+	/**
+	 * Notes on component props:
+	 * The props defined in the props list can be used with :foo or r-bind:foo syntax.
+	 * <MyComponent :prop-kebab-1="1" r-bind:prop-kebab-2="x ? 1 : 0" :props="{ propFoo3: true, propFoo4: x ? 'a' : 'b' }></MyComponent>
+	 * It is required to define prop-kebab-1 and prop-kebab-2 in the props list camelized.
+	 * It is not required to define propFoo3 and propFoo4 in the props list because it uses :props binding. :props binding enables binding to any property of component regardless it is explicitly defined in props list.
+	 */
+	props?: string[];
+}
+export interface Scope<TRegorContext> {
+	context: TRegorContext;
+	unmount: () => void;
+	[ScopeSymbol]: true;
+}
+export declare const createApp: <TRegorContext extends IRegorContext>(context: TRegorContext | Scope<TRegorContext>, template?: Template, config?: RegorConfig) => App<TRegorContext>;
+export declare const createComponent: <TProps = Record<any, any>>(name: string, context: (head: ComponentHead<TProps>) => IRegorContext, template: Template, options?: CreateComponentOptions) => Component<TProps>;
+export declare const toFragment: (json: JSONTemplate | JSONTemplate[], isSVG?: boolean, config?: RegorConfig) => DocumentFragment;
+export declare const toJsonTemplate: (node: Element | Element[]) => JSONTemplate | JSONTemplate[];
+export declare const addUnbinder: (node: Node, unbinder: Unbinder) => void;
+export declare const getBindData: (node: any) => BindData;
+export declare const removeNode: (node: ChildNode) => void;
+export declare const unbind: (node: Node) => void;
+export declare const computed: <TReturnType>(compute: () => TReturnType) => ComputedRef<UnwrapRef<TReturnType>>;
+export declare const computeMany: <TReturnType>(sources: AnyRef[], compute: (...values: any[]) => TReturnType) => ComputedRef<UnwrapRef<TReturnType>>;
+export declare const computeRef: <TValueType extends AnyRef, TReturnType>(source: TValueType, compute: (value: UnwrapRef<TValueType>) => TReturnType) => ComputedRef<UnwrapRef<TReturnType>>;
+export declare const watchEffect: (effect: (onCleanup?: OnCleanup) => void) => StopObserving;
+export declare const silence: <TReturnType>(action: () => TReturnType) => TReturnType;
+export declare const collectRefs: <TReturnType>(action: () => TReturnType) => {
+	value: TReturnType;
+	refs: AnyRef[];
+};
+export declare const flatten: <TValueType>(reference: TValueType) => FlattenRef<TValueType>;
+export declare const isRaw: (value: any) => boolean;
+export type Raw<TValueType> = TValueType & RawMarker;
+export declare const markRaw: <TValueType extends object>(value: TValueType) => Raw<TValueType>;
+export declare const persist: <TRef extends AnyRef>(anyRef: TRef, key: string) => TRef;
+export declare const html: (templates: TemplateStringsArray, ...args: any[]) => string;
+export declare const raw: (templates: TemplateStringsArray, ...args: any[]) => string;
+export declare const observe: <TValueType extends AnyRef>(source: TValueType, observer: ObserveCallback<UnwrapRef<TValueType>>, init?: boolean) => StopObserving;
+export declare const observeMany: (sources: AnyRef[], observer: ObserveCallback<any[]>, init?: boolean) => StopObserving;
+export declare const observerCount: <TValueType extends AnyRef>(source: TValueType) => number;
+export declare const batch: (updater: () => void) => void;
+export declare const startBatch: () => void;
+export declare const endBatch: () => void;
+export declare const isDeepRef: (value: unknown) => value is AnyRef;
+export declare const isRef: (value: unknown) => value is AnyRef;
+export declare const pause: <TValueType extends AnyRef>(source: TValueType) => void;
+/**
+ * Converts the given value and it's all properties to ref objects and returns the ref.
+ * The returned object's type reflects it's nested properties as well.
+ * Regor provides two options to get or update the value of a ref.
+ * Getting the ref value:
+ * 1. refObj.value
+ * 2. refObj()
+ * Setting the ref value:
+ * 1. refObj.value = newValue
+ * 2. refObj(newValue)
+ *
+ * @param value any value
+ * @returns ref
+ */
+export declare const ref: <TValueType>(value?: TValueType | RefContent<TValueType> | RefParam<TValueType> | (TValueType extends Ref<infer V1> ? Ref<RefParam<V1>> : never) | (TValueType extends SRef<infer V2> ? SRef<UnwrapRef<V2>> : never) | (TValueType extends (infer V1_1)[] ? V1_1[] : never) | null | undefined) => IsNull<TValueType> extends true ? Ref<unknown> : Ref<RefParam<TValueType>>;
+export declare const resume: <TValueType extends AnyRef>(source: TValueType) => void;
+/**
+ * Converts the given value to sref object and returns the sref.
+ * Regor provides two options to get or update the value of a sref.
+ * Getting the sref value:
+ * 1. refObj.value
+ * 2. refObj()
+ * Setting the sref value:
+ * 1. refObj.value = newValue
+ * 2. refObj(newValue)
+ *
+ * @param value any value
+ * @returns ref
+ */
+export declare const sref: <TValueType>(value?: TValueType | (TValueType extends SRef<infer V2> ? SRef<UnwrapRef<V2>> : never) | (TValueType extends (infer V1)[] ? V1[] : never) | null | undefined) => IsNull<TValueType> extends true ? SRef<unknown> : SRef<SRefContent<TValueType>>;
+export declare const trigger: <TValueType extends AnyRef>(source: TValueType, eventSource?: any, isRecursive?: boolean) => void;
+export declare const unref: <TValueType>(value: TValueType) => UnwrapRef<TValueType>;
+export declare const entangle: (r1: AnyRef, r2: AnyRef) => StopObserving;
+export declare const useScope: <TRegorContext extends IRegorContext>(context: () => TRegorContext) => Scope<TRegorContext>;
+export declare const onMounted: (onMounted: OnMounted) => void;
+export declare const onUnmounted: (onUnmounted: OnUnmounted, noThrow?: boolean) => void;
+export declare const warningHandler: {
+	warning: {
+		(...data: any[]): void;
+		(message?: any, ...optionalParams: any[]): void;
+	};
+};
+
+export {};