@glimmer/runtime

@glimmer/runtime

Version 0.84.3
Published 2 months ago
4.28 MB
13 dependencies
MIT license

Install

npm i @glimmer/runtime

yarn add @glimmer/runtime

pnpm add @glimmer/runtime

Overview

Minimal runtime needed to render Glimmer templates

Index

Variables

variable array

const array: {};

variable concat

const concat: {};

variable DOMChanges

let DOMChanges: typeof DOMChangesImpl;

variable DOMTreeConstruction

const DOMTreeConstruction: typeof DOM.TreeConstruction;

variable EMPTY_ARGS

const EMPTY_ARGS: CapturedArguments;

variable EMPTY_NAMED

const EMPTY_NAMED: CapturedNamedArguments;

variable EMPTY_POSITIONAL

const EMPTY_POSITIONAL: CapturedPositionalArguments;

variable fn

const fn: {};

variable get

const get: {};

variable hash

const hash: {};

variable on

const on: {};

variable SERIALIZATION_FIRST_NODE_STRING

const SERIALIZATION_FIRST_NODE_STRING: string;

variable TEMPLATE_ONLY_COMPONENT_MANAGER

const TEMPLATE_ONLY_COMPONENT_MANAGER: TemplateOnlyComponentManager;

Functions

function clear

clear: (bounds: Bounds) => Option<SimpleNode>;

function clientBuilder

clientBuilder: (env: Environment, cursor: CursorImpl) => ElementBuilder;

function createCapturedArgs

createCapturedArgs: (
    named: Dict<Reference>,
    positional: Reference[]
) => CapturedArguments;

function curry

curry: <T extends CurriedType>(
    type: T,
    spec: object | string | CurriedValue<T>,
    owner: Owner,
    args: CapturedArguments | null,
    resolved?: boolean
) => CurriedValue<T>;

function dynamicAttribute

dynamicAttribute: (
    element: SimpleElement,
    attr: string,
    namespace: Option<AttrNamespace>,
    isTrusting?: boolean
) => DynamicAttribute;

function inTransaction

inTransaction: (env: Environment, cb: () => void) => void;

function invokeHelper

invokeHelper: (
    context: object,
    definition: object,
    computeArgs?: (context: object) => Arguments
) => Cache<unknown>;

function isSerializationFirstNode

isSerializationFirstNode: (node: SimpleNode) => boolean;

function isWhitespace

isWhitespace: (string: string) => boolean;

function normalizeProperty

normalizeProperty: (
    element: SimpleElement,
    slotName: string
) => { normalized: string; type: string };

function rehydrationBuilder

rehydrationBuilder: (env: Environment, cursor: CursorImpl) => ElementBuilder;

function reifyArgs

reifyArgs: (args: CapturedArguments) => {
    named: Dict<unknown>;
    positional: unknown[];
};

function reifyNamed

reifyNamed: (named: CapturedNamedArguments) => Dict<unknown>;

function reifyPositional

reifyPositional: (positional: CapturedPositionalArguments) => unknown[];

function renderComponent

renderComponent: (
    runtime: RuntimeContext,
    treeBuilder: ElementBuilder,
    context: CompileTimeCompilationContext,
    owner: Owner,
    definition: ComponentDefinitionState,
    args?: Record<string, unknown>,
    dynamicScope?: DynamicScope
) => TemplateIterator;

function renderMain

renderMain: (
    runtime: RuntimeContext,
    context: CompileTimeCompilationContext,
    owner: Owner,
    self: Reference,
    treeBuilder: ElementBuilder,
    layout: CompilableProgram,
    dynamicScope?: DynamicScope
) => TemplateIterator;

function renderSync

renderSync: (env: Environment, iterator: TemplateIterator) => RenderResult;

function resetDebuggerCallback

resetDebuggerCallback: () => void;

function runtimeContext

runtimeContext: (
    options: EnvironmentOptions,
    delegate: EnvironmentDelegate,
    artifacts: RuntimeArtifacts,
    resolver: RuntimeResolver
) => RuntimeContext;

function setDebuggerCallback

setDebuggerCallback: (cb: DebugCallback) => void;

function templateOnlyComponent

templateOnlyComponent: (
    moduleName?: string,
    name?: string
) => TemplateOnlyComponentDefinition;

This utility function is used to declare a given component has no backing class. When the rendering engine detects this it is able to perform a number of optimizations. Templates that are associated with templateOnly() will be rendered _as is_ without adding a wrapping <div> (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)). Specifically, this means that the template will be rendered as "outer HTML".
In general, this method will be used by build time tooling and would not be directly written in an application. However, at times it may be useful to use directly to leverage the "outer HTML" semantics mentioned above. For example, if an addon would like to use these semantics for its templates but cannot be certain it will only be consumed by applications that have enabled the template-only-glimmer-components optional feature.
Parameter moduleName
the module name that the template only component represents, this will be used for debugging purposes EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
Example 1
```js import { templateOnlyComponent } from '@glimmer/runtime';
export default templateOnlyComponent(); ```
templateOnly
Modifiers
- @public

Classes

class ConcreteBounds

class ConcreteBounds implements Bounds {}

constructor

constructor(parentNode: SimpleElement, first: SimpleNode, last: SimpleNode);

property parentNode

parentNode: SimpleElement;

method firstNode

firstNode: () => SimpleNode;

method lastNode

lastNode: () => SimpleNode;

method parentElement

parentElement: () => SimpleElement;

class CurriedValue

class CurriedValue<T extends CurriedType = CurriedType> {}

property [ARGS]

[ARGS]: any;

property [INNER]

[INNER]: string | object | CurriedValue<T>;

property [OWNER]

[OWNER]: Owner;

property [RESOLVED]

[RESOLVED]: boolean;

property [TYPE]

[TYPE]: CurriedType;

class CursorImpl

class CursorImpl implements Cursor {}

constructor

constructor(element: SimpleElement, nextSibling: Option<SimpleNode>);

property element

element: SimpleElement;

property nextSibling

nextSibling: Option<SimpleNode>;

class DynamicAttribute

abstract class DynamicAttribute implements AttributeOperation {}

constructor

constructor(attribute: AttributeCursor);

property attribute

attribute: AttributeCursor;

method set

abstract set: (dom: ElementBuilder, value: unknown, env: Environment) => void;

method update

abstract update: (value: unknown, env: Environment) => void;

class DynamicScopeImpl

class DynamicScopeImpl implements DynamicScope {}

constructor

constructor(bucket?: Dict<Reference>);

method child

child: () => DynamicScopeImpl;

method get

get: (key: string) => Reference;

method set

set: (key: string, reference: Reference) => Reference;

class EnvironmentImpl

class EnvironmentImpl implements Environment {}

constructor

constructor(options: EnvironmentOptions, delegate: EnvironmentDelegate);

property [TRANSACTION]

[TRANSACTION]: Option<TransactionImpl>;

property appendOperations

protected appendOperations: GlimmerTreeConstruction;

property debugRenderTree

debugRenderTree: DebugRenderTree<object>;

property isInteractive

isInteractive: boolean;

property updateOperations

protected updateOperations?: GlimmerTreeChanges;

method begin

begin: () => void;

method commit

commit: () => void;

method didCreate

didCreate: (component: ComponentInstanceWithCreate) => void;

method didUpdate

didUpdate: (component: ComponentInstanceWithCreate) => void;

method getAppendOperations

getAppendOperations: () => GlimmerTreeConstruction;

method getDOM

getDOM: () => GlimmerTreeChanges;

method scheduleInstallModifier

scheduleInstallModifier: (modifier: ModifierInstance) => void;

method scheduleUpdateModifier

scheduleUpdateModifier: (modifier: ModifierInstance) => void;

class IDOMChanges

class DOMChangesImpl extends DOMOperations implements GlimmerTreeChanges {}

constructor

constructor(document: SimpleDocument);

property document

protected document: SimpleDocument;

property namespace

protected namespace: Option<string>;

method insertAfter

insertAfter: (
    element: SimpleElement,
    node: SimpleNode,
    reference: SimpleNode
) => void;

method removeAttribute

removeAttribute: (element: SimpleElement, name: string) => void;

method setAttribute

setAttribute: (element: SimpleElement, name: string, value: string) => void;

class LowLevelVM

class VM implements PublicVM, InternalVM {}

constructor

constructor(
    runtime: RuntimeContext,
    { pc, scope, dynamicScope, stack }: VMState,
    elementStack: ElementBuilder,
    context: CompileTimeCompilationContext
);

End of migrated.

property [ARGS]

readonly [ARGS]: VMArgumentsImpl;

property [CONSTANTS]

readonly [CONSTANTS]: any;

property [INNER_VM]

readonly [INNER_VM]: LowLevelVM;

property context

readonly context: CompileTimeCompilationContext;

property env

readonly env: Environment;

property pc

readonly pc: number;

property program

readonly program: RuntimeProgram;

property runtime

readonly runtime: RuntimeContext;

property s0

s0: {};

property s1

s1: {};

property stack

readonly stack: EvaluationStack;

property t0

t0: {};

property t1

t1: {};

property v0

v0: {};

method associateDestroyable

associateDestroyable: (child: Destroyable) => void;

method beginCacheGroup

beginCacheGroup: (name?: string) => void;

method bindDynamicScope

bindDynamicScope: (names: string[]) => void;

method call

call: (handle: number) => void;

method capture

capture: (args: number, pc?: number) => ResumableVMState;

method captureState

captureState: (args: number, pc?: number) => VMState;

method commitCacheGroup

commitCacheGroup: () => void;

method compile

compile: (block: CompilableTemplate) => number;

method dynamicScope

dynamicScope: () => DynamicScope;

method elements

elements: () => ElementBuilder;

method empty

static empty: (
    runtime: RuntimeContext,
    { handle, treeBuilder, dynamicScope, owner }: MinimalInitOptions,
    context: CompileTimeCompilationContext
) => InternalVM;

method enter

enter: (args: number) => void;

method enterItem

enterItem: ({ key, value, memo }: OpaqueIterationItem) => ListItemOpcode;

method enterList

enterList: (iterableRef: Reference<OpaqueIterator>, offset: number) => void;

method execute

execute: (initialize?: (vm: this) => void) => RenderResult;

method exit

exit: () => void;

method exitList

exitList: () => void;

method fetch

fetch: (register: SyscallRegister) => void;

method fetchValue

fetchValue: { (register: MachineRegister): number; <T>(register: Register): T };

method getOwner

getOwner: () => Owner;

method getSelf

getSelf: () => Reference<any>;

method goto

goto: (offset: number) => void;

method initial

static initial: (
    runtime: RuntimeContext,
    context: CompileTimeCompilationContext,
    { handle, self, dynamicScope, treeBuilder, numSymbols, owner }: InitOptions
) => InternalVM;

method listBlock

listBlock: () => ListBlockOpcode;

method load

load: (register: SyscallRegister) => void;

method loadValue

loadValue: <T>(register: Register | MachineRegister, value: T) => void;

method next

next: () => RichIteratorResult<null, RenderResult>;

method popDynamicScope

popDynamicScope: () => void;

method popFrame

popFrame: () => void;

method popScope

popScope: () => void;

method popUpdating

popUpdating: () => UpdatingOpcode[];

method pushChildScope

pushChildScope: () => void;

method pushDynamicScope

pushDynamicScope: () => DynamicScope;

method pushFrame

pushFrame: () => void;

Migrated to Inner

method pushRootScope

pushRootScope: (size: number, owner: Owner) => PartialScope;

method pushScope

pushScope: (scope: Scope) => void;

method pushUpdating

pushUpdating: (list?: UpdatingOpcode[]) => void;

method referenceForSymbol

referenceForSymbol: (symbol: number) => Reference;

method registerItem

registerItem: (opcode: ListItemOpcode) => void;

method return

return: () => void;

method returnTo

returnTo: (offset: number) => void;

method scope

scope: () => Scope;

method tryUpdating

tryUpdating: () => Option<UpdatingOpcode[]>;

method updateWith

updateWith: (opcode: UpdatingOpcode) => void;

method updating

updating: () => UpdatingOpcode[];

class NewElementBuilder

class NewElementBuilder implements ElementBuilder {}

constructor

constructor(
    env: Environment,
    parentNode: SimpleElement,
    nextSibling: Option<SimpleNode>
);

property [CURSOR_STACK]

[CURSOR_STACK]: Stack<Cursor>;

property constructing

constructing: Option<SimpleElement>;

property dom

dom: GlimmerTreeConstruction;

property element

readonly element: SimpleElement;

property hasBlocks

readonly hasBlocks: boolean;

property nextSibling

readonly nextSibling: Option<SimpleNode>;

property operations

operations: Option<ElementOperations>;

property updateOperations

updateOperations: GlimmerTreeChanges;

method appendComment

appendComment: (string: string) => SimpleComment;

method appendDynamicFragment

appendDynamicFragment: (value: SimpleDocumentFragment) => void;

method appendDynamicHTML

appendDynamicHTML: (value: string) => void;

method appendDynamicNode

appendDynamicNode: (value: SimpleNode) => void;

method appendDynamicText

appendDynamicText: (value: string) => SimpleText;

method appendText

appendText: (string: string) => SimpleText;

method block

protected block: () => LiveBlock;

method closeElement

closeElement: () => Option<ModifierInstance[]>;

method debugBlocks

debugBlocks: () => LiveBlock[];

method didAppendBounds

didAppendBounds: (bounds: Bounds) => Bounds;

method didAppendNode

didAppendNode: <T extends SimpleNode>(node: T) => T;

method didOpenElement

didOpenElement: (element: SimpleElement) => SimpleElement;

method flushElement

flushElement: (modifiers: Option<ModifierInstance[]>) => void;

method forInitialRender

static forInitialRender: (
    env: Environment,
    cursor: CursorImpl
) => NewElementBuilder;

method initialize

protected initialize: () => this;

method openElement

openElement: (tag: string) => SimpleElement;

method popBlock

popBlock: () => LiveBlock;

method popElement

popElement: () => void;

method popRemoteElement

popRemoteElement: () => void;

method pushBlockList

pushBlockList: (list: LiveBlock[]) => LiveBlockList;

method pushElement

protected pushElement: (
    element: SimpleElement,
    nextSibling?: Maybe<SimpleNode>
) => void;

method pushLiveBlock

protected pushLiveBlock: <T extends LiveBlock>(
    block: T,
    isRemote?: boolean
) => T;

method pushRemoteElement

pushRemoteElement: (
    element: SimpleElement,
    guid: string,
    insertBefore: Maybe<SimpleNode>
) => Option<RemoteLiveBlock>;

method pushSimpleBlock

pushSimpleBlock: () => LiveBlock;

method pushUpdatableBlock

pushUpdatableBlock: () => UpdatableBlockImpl;

method resume

static resume: (env: Environment, block: UpdatableBlock) => NewElementBuilder;

method setDynamicAttribute

setDynamicAttribute: (
    name: string,
    value: unknown,
    trusting: boolean,
    namespace: Option<AttrNamespace>
) => DynamicAttribute;

method setStaticAttribute

setStaticAttribute: (
    name: string,
    value: string,
    namespace: Option<AttrNamespace>
) => void;

method willCloseElement

willCloseElement: () => void;

class PartialScopeImpl

class PartialScopeImpl implements PartialScope {}

constructor

constructor(
    slots: ScopeSlot[],
    owner: Owner,
    callerScope: any,
    evalScope: any,
    partialMap: any
);

property owner

readonly owner: Owner;

property slots

readonly slots: ScopeSlot[];

method bind

bind: (symbol: number, value: ScopeSlot) => void;

method bindBlock

bindBlock: (symbol: number, value: Option<ScopeBlock>) => void;

method bindCallerScope

bindCallerScope: (scope: Option<Scope>) => void;

method bindEvalScope

bindEvalScope: (map: Option<Dict<ScopeSlot>>) => void;

method bindPartialMap

bindPartialMap: (map: Dict<Reference<unknown>>) => void;

method bindSelf

bindSelf: (self: Reference<unknown>) => void;

method bindSymbol

bindSymbol: (symbol: number, value: Reference<unknown>) => void;

method child

child: () => Scope;

method getBlock

getBlock: (symbol: number) => Option<ScopeBlock>;

method getCallerScope

getCallerScope: () => Option<Scope>;

method getEvalScope

getEvalScope: () => Option<Dict<ScopeSlot>>;

method getPartialMap

getPartialMap: () => Option<Dict<Reference<unknown>>>;

method getSelf

getSelf: () => Reference<unknown>;

method getSymbol

getSymbol: (symbol: number) => Reference<unknown>;

method init

init: ({ self }: { self: Reference<unknown> }) => this;

method root

static root: (
    self: Reference<unknown>,
    size: number | undefined,
    owner: Owner
) => PartialScope;

method sized

static sized: (size: number | undefined, owner: Owner) => Scope;

class RehydrateBuilder

class RehydrateBuilder extends NewElementBuilder implements ElementBuilder {}

constructor

constructor(
    env: Environment,
    parentNode: SimpleElement,
    nextSibling: Option<SimpleNode>
);

property [CURSOR_STACK]

[CURSOR_STACK]: Stack<RehydratingCursor>;

property blockDepth

blockDepth: number;

property candidate

candidate: Option<SimpleNode>;

property currentCursor

readonly currentCursor: Option<RehydratingCursor>;

property startingBlockOffset

startingBlockOffset: number;

method didAppendBounds

didAppendBounds: (bounds: Bounds) => Bounds;

method disableRehydration

disableRehydration: (nextSibling: Option<SimpleNode>) => void;

method enableRehydration

enableRehydration: (candidate: Option<SimpleNode>) => void;

method getMarker

getMarker: (element: HTMLElement, guid: string) => Option<SimpleNode>;

method pushElement

pushElement: (
    this:
        | RehydrateBuilder
        | (NewElementBuilder &
              Partial<Pick<RehydrateBuilder, 'blockDepth' | 'candidate'>>),
    element: SimpleElement,
    nextSibling?: Maybe<SimpleNode>
) => void;

method remove

protected remove: (node: SimpleNode) => Option<SimpleNode>;

method willCloseElement

willCloseElement: () => void;

class RemoteLiveBlock

class RemoteLiveBlock extends SimpleLiveBlock {}

constructor

constructor(parent: SimpleElement);

class SimpleDynamicAttribute

class SimpleDynamicAttribute extends DynamicAttribute {}

method set

set: (dom: ElementBuilder, value: unknown, _env: Environment) => void;

method update

update: (value: unknown, _env: Environment) => void;

class TemplateOnlyComponent

class TemplateOnlyComponentDefinition {}

constructor

constructor(moduleName?: string, name?: string);

property moduleName

moduleName: string;

property name

name: string;

method toString

toString: () => string;

class TemplateOnlyComponentManager

class TemplateOnlyComponentManager implements InternalComponentManager {}

method getCapabilities

getCapabilities: () => InternalComponentCapabilities;

method getDebugName

getDebugName: ({ name }: TemplateOnlyComponentDefinition) => string;

method getDestroyable

getDestroyable: () => null;

method getSelf

getSelf: () => Reference;

class UpdatableBlockImpl

class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBlock {}

method reset

reset: () => Option<SimpleNode>;

class UpdatingVM

class UpdatingVMImpl implements UpdatingVM {}

constructor

constructor(
    env: Environment,
    { alwaysRevalidate }: { alwaysRevalidate?: boolean | undefined }
);

property alwaysRevalidate

alwaysRevalidate: boolean;

property dom

dom: GlimmerTreeChanges;

property env

env: Environment;

method execute

execute: (opcodes: UpdatingOpcode[], handler: ExceptionHandler) => void;

method goto

goto: (index: number) => void;

method throw

throw: () => void;

method try

try: (ops: UpdatingOpcode[], handler: Option<ExceptionHandler>) => void;

Interfaces

interface EnvironmentDelegate

interface EnvironmentDelegate {}

property enableDebugTooling

enableDebugTooling: boolean;

Used to enable debug tooling

property isInteractive

isInteractive: boolean;

Used to determine the the environment is interactive (e.g. SSR is not interactive). Interactive environments schedule modifiers, among other things.

property onTransactionCommit

onTransactionCommit: () => void;

Callback to be called when an environment transaction commits

interface InternalVM

interface InternalVM {}

This interface is used by internal opcodes, and is more stable than the implementation of the Append VM itself.

property [ARGS]

readonly [ARGS]: VMArgumentsImpl;

property [CONSTANTS]

readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;

property context

readonly context: CompileTimeCompilationContext;

property env

readonly env: Environment;

property runtime

readonly runtime: RuntimeContext;

property stack

readonly stack: EvaluationStack;

method associateDestroyable

associateDestroyable: (d: Destroyable) => void;

method beginCacheGroup

beginCacheGroup: (name?: string) => void;

method bindDynamicScope

bindDynamicScope: (names: string[]) => void;

method call

call: (handle: number) => void;

method commitCacheGroup

commitCacheGroup: () => void;

method compile

compile: (block: CompilableTemplate) => number;

method dynamicScope

dynamicScope: () => DynamicScope;

method elements

elements: () => ElementBuilder;

method enter

enter: (args: number) => void;

method enterItem

enterItem: (item: OpaqueIterationItem) => ListItemOpcode;

method enterList

enterList: (iterableRef: Reference<OpaqueIterator>, offset: number) => void;

method execute

execute: (initialize?: (vm: this) => void) => RenderResult;

method exit

exit: () => void;

method exitList

exitList: () => void;

method fetch

fetch: (register: Register) => void;

method fetchValue

fetchValue: {
    (register: MachineRegister.ra | MachineRegister.pc): number;
    <T>(register: Register): T;
    (register: Register): unknown;
};

method getOwner

getOwner: () => Owner;

method getSelf

getSelf: () => Reference;

method goto

goto: (pc: number) => void;

method load

load: (register: Register) => void;

method loadValue

loadValue: {
    (register: MachineRegister, value: number): void;
    (register: Register, value: unknown): void;
    (register: any, value: unknown): void;
};

method next

next: () => RichIteratorResult<null, RenderResult>;

method popDynamicScope

popDynamicScope: () => void;

method popScope

popScope: () => void;

method pushChildScope

pushChildScope: () => void;

method pushDynamicScope

pushDynamicScope: () => void;

method pushFrame

pushFrame: () => void;

method pushRootScope

pushRootScope: (size: number, owner: Owner) => PartialScope;

method pushScope

pushScope: (scope: Scope) => void;

method pushUpdating

pushUpdating: (list?: UpdatingOpcode[]) => void;

method referenceForSymbol

referenceForSymbol: (symbol: number) => Reference;

method registerItem

registerItem: (item: ListItemOpcode) => void;

method scope

scope: () => Scope;

method updateWith

updateWith: (opcode: UpdatingOpcode) => void;

interface SafeString

interface SafeString {}

method toHTML

toHTML: () => string;

Type Aliases

type DebugCallback

type DebugCallback = (context: unknown, get: DebugGet) => void;

type DOMTreeConstruction

type DOMTreeConstruction = DOM.DOMTreeConstruction;

type IteratorResult

type IteratorResult<T> = RichIteratorResult<null, T>;

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@glimmer/runtime.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@glimmer/runtime)

HTML

<a href="https://www.jsdocs.io/package/@glimmer/runtime"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 months ago.
Package analyzed in 7105 ms.
Missing or incorrect documentation? Open an issue for this package.

@glimmer/runtime

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable array

variable concat

variable DOMChanges

variable DOMTreeConstruction

variable EMPTY_ARGS

variable EMPTY_NAMED

variable EMPTY_POSITIONAL

variable fn

variable get

variable hash

variable on

variable SERIALIZATION_FIRST_NODE_STRING

variable TEMPLATE_ONLY_COMPONENT_MANAGER

Functions

function clear

function clientBuilder

function createCapturedArgs

function curry

function dynamicAttribute

function inTransaction

function invokeHelper

function isSerializationFirstNode

function isWhitespace

function normalizeProperty

function rehydrationBuilder

function reifyArgs

function reifyNamed

function reifyPositional

function renderComponent

function renderMain

function renderSync

function resetDebuggerCallback

function runtimeContext

function setDebuggerCallback

function templateOnlyComponent

Parameter moduleName

Example 1

Modifiers

Classes

class ConcreteBounds

constructor

property parentNode

method firstNode

method lastNode

method parentElement

class CurriedValue

property [ARGS]

property [INNER]

property [OWNER]

property [RESOLVED]

property [TYPE]

class CursorImpl

constructor

property element

property nextSibling

class DynamicAttribute

constructor

property attribute

method set

method update

class DynamicScopeImpl

constructor

method child

method get

method set

class EnvironmentImpl

constructor

property [TRANSACTION]

property appendOperations

property debugRenderTree