@glimmer/interfaces

@glimmer/interfaces

Version 0.92.0
Published 13 days ago
81.1 kB
1 dependency
MIT license

Install

npm i @glimmer/interfaces

yarn add @glimmer/interfaces

pnpm add @glimmer/interfaces

Overview

Overview not available.

Index

Variables

variable CAPABILITIES

const CAPABILITIES: Symbol;

variable CapabilityBrand

const CapabilityBrand: Symbol;

variable CAPTURED_ARGS

const CAPTURED_ARGS: Symbol;

variable COMPUTE

const COMPUTE: Symbol;

variable CURSOR_STACK

const CURSOR_STACK: Symbol;

variable REFERENCE

const REFERENCE: Symbol;

variable TransactionSymbol

const TransactionSymbol: Symbol;

variable TYPE

const TYPE: Symbol;

Functions

function isArgumentError

isArgumentError: (arg: unknown) => arg is ArgumentError;

Interfaces

interface ArgsOptions

interface ArgsOptions extends SimpleArgsOptions {}

property blocks

blocks: NamedBlocks;

property named

named: WireFormat.Core.Hash;

interface ArgumentError

interface ArgumentError {}

property error

error: any;

interface Arguments

interface Arguments {}

property named

named: Record<string, unknown>;

property positional

positional: readonly unknown[];

interface ArgumentsDebug

interface ArgumentsDebug {}

property named

named: Record<string, unknown>;

property positional

positional: readonly unknown[];

interface AttributeCursor

interface AttributeCursor {}

property element

element: SimpleElement;

property name

name: string;

property namespace

namespace: Nullable<AttrNamespace>;

interface AttributeOperation

interface AttributeOperation {}

property attribute

attribute: AttributeCursor;

method set

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

method update

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

interface BlockArguments

interface BlockArguments {}

property length

length: number;

property names

names: readonly string[];

method capture

capture: () => CapturedBlockArguments;

method get

get: (name: string) => ScopeBlock;

method has

has: (name: string) => boolean;

interface BlockOperand

interface BlockOperand {}

property type

type: BlockOperandType;

property value

value: WireFormat.SerializedInlineBlock | WireFormat.SerializedBlock;

interface BlockSymbolTable

interface BlockSymbolTable {}

property parameters

parameters: number[];

interface BlockWithContext

interface BlockWithContext {}

property block

readonly block: SerializedInlineBlock;

property containingLayout

readonly containingLayout: LayoutWithContext;

interface Bounds

interface Bounds {}

method firstNode

firstNode: () => SimpleNode;

method lastNode

lastNode: () => SimpleNode;

method parentElement

parentElement: () => SimpleElement;

interface Capabilities

interface Capabilities {}

property [CAPABILITIES]

[CAPABILITIES]: true;

interface CapturedArguments

interface CapturedArguments {}

property [CAPTURED_ARGS]

[CAPTURED_ARGS]: true;

property named

named: CapturedNamedArguments;

property positional

positional: CapturedPositionalArguments;

interface CapturedBlockArguments

interface CapturedBlockArguments {}

property length

length: number;

property names

names: readonly string[];

method get

get: (name: string) => ScopeBlock;

method has

has: (name: string) => boolean;

interface CapturedNamedArguments

interface CapturedNamedArguments extends Record<string, Reference> {}

property [CAPTURED_ARGS]

[CAPTURED_ARGS]: true;

interface CapturedPositionalArguments

interface CapturedPositionalArguments extends Array<Reference> {}

property [CAPTURED_ARGS]

[CAPTURED_ARGS]: true;

interface CapturedRenderNode

interface CapturedRenderNode {}

property args

args: Arguments;

property bounds

bounds: null | {
    parentElement: SimpleElement;
    firstNode: SimpleNode;
    lastNode: SimpleNode;
};

property children

children: CapturedRenderNode[];

property id

id: string;

property instance

instance: unknown;

property name

name: string;

property template

template: string | null;

property type

type: RenderNodeType;

interface CombinatorTag

interface CombinatorTag extends MonomorphicTag {}

property [TYPE]

readonly [TYPE]: COMBINATOR_TAG_ID;

interface CompilableProgram

interface CompilableProgram extends CompilableTemplate<ProgramSymbolTable> {}

property moduleName

moduleName: string;

interface CompilableTemplate

interface CompilableTemplate<S extends SymbolTable = SymbolTable> {}

property symbolTable

symbolTable: S;

method compile

compile: (context: CompileTimeCompilationContext) => HandleResult;

interface CompilerArtifacts

interface CompilerArtifacts {}

property constants

constants: ConstantPool;

property heap

heap: SerializedHeap;

interface CompileTimeArtifacts

interface CompileTimeArtifacts {}

property constants

constants: CompileTimeConstants & ResolutionTimeConstants;

property heap

heap: CompileTimeHeap;

interface CompileTimeCompilationContext

interface CompileTimeCompilationContext {}

property constants

readonly constants: CompileTimeConstants & ResolutionTimeConstants;

property createOp

readonly createOp: CreateRuntimeOp;

property heap

readonly heap: CompileTimeHeap;

property resolver

readonly resolver: CompileTimeResolver;

property stdlib

readonly stdlib: STDLib;

interface CompileTimeComponent

interface CompileTimeComponent {}

property capabilities

capabilities: CapabilityMask;

property compilable

compilable: Nullable<CompilableProgram>;

property handle

handle: number;

interface CompileTimeConstants

interface CompileTimeConstants {}

Constants are interned values that are referenced as numbers in the program. The constant pool is a part of the program, and is always transmitted together with the program.

method array

array: (values: unknown[] | readonly unknown[]) => number;

method toPool

toPool: () => ConstantPool;

method value

value: (value: unknown) => number;

interface CompileTimeHeap

interface CompileTimeHeap extends OpcodeHeap {}

property offset

offset: number;

method capture

capture: (offset?: number) => SerializedHeap;

method finishMalloc

finishMalloc: (handle: number, scopeSize: number) => void;

method getaddr

getaddr: (handle: number) => number;

method getbyaddr

getbyaddr: (address: number) => number;

method malloc

malloc: () => number;

method pushMachine

pushMachine: (
    name: VmMachineOp,
    op1?: number,
    op2?: number,
    op3?: number
) => void;

method pushOp

pushOp: (name: VmOp, op1?: number, op2?: number, op3?: number) => void;

method pushRaw

pushRaw: (value: number) => void;

method setbyaddr

setbyaddr: (address: number, value: number) => void;

method sizeof

sizeof: (handle: number) => number;

interface CompileTimeResolver

interface CompileTimeResolver<O extends Owner = Owner> {}

method lookupBuiltInHelper

lookupBuiltInHelper: (name: string) => Nullable<HelperDefinitionState>;

method lookupBuiltInModifier

lookupBuiltInModifier: (name: string) => Nullable<ModifierDefinitionState>;

method lookupComponent

lookupComponent: (
    name: string,
    owner: O
) => Nullable<ResolvedComponentDefinition>;

method lookupHelper

lookupHelper: (name: string, owner: O) => Nullable<HelperDefinitionState>;

method lookupModifier

lookupModifier: (name: string, owner: O) => Nullable<ModifierDefinitionState>;

interface ComponentCapabilities

interface ComponentCapabilities extends Capabilities {}

property asyncLifeCycleCallbacks

asyncLifeCycleCallbacks: boolean;

property destructor

destructor: boolean;

property updateHook

updateHook: boolean;

interface ComponentCapabilitiesVersions

interface ComponentCapabilitiesVersions {}

property '3.13'

'3.13': {
    asyncLifecycleCallbacks?: boolean;
    destructor?: boolean;
    updateHook?: boolean;
};

property '3.4'

'3.4': {
    asyncLifecycleCallbacks?: boolean;
    destructor?: boolean;
};

interface ComponentDefinition

interface ComponentDefinition<
    D extends ComponentDefinitionState = ComponentDefinitionState,
    I = ComponentInstanceState,
    M extends InternalComponentManager<I, D> = InternalComponentManager<I, D>
> {}

property capabilities

capabilities: CapabilityMask;

property compilable

compilable: CompilableProgram | null;

property handle

handle: number;

property manager

manager: M;

property resolvedName

resolvedName: string | null;

property state

state: D;

interface ComponentInstance

interface ComponentInstance<
    D extends ComponentDefinitionState = ComponentDefinitionState,
    I = ComponentInstanceState,
    M extends InternalComponentManager<I, D> = InternalComponentManager<I, D>
> {}

property capabilities

capabilities: CapabilityMask;

property definition

definition: ComponentDefinition<D, I>;

property handle

handle: number;

property lookup

lookup: Record<string, ScopeSlot> | null;

property manager

manager: M;

property state

state: I;

property table

table: ProgramSymbolTable;

interface ComponentManager

interface ComponentManager<ComponentStateBucket> {}

property capabilities

capabilities: ComponentCapabilities;

method createComponent

createComponent: (factory: object, args: Arguments) => ComponentStateBucket;

method getContext

getContext: (instance: ComponentStateBucket) => unknown;

interface ComponentManagerWithAsyncLifeCycleCallbacks

interface ComponentManagerWithAsyncLifeCycleCallbacks<ComponentStateBucket>
    extends ComponentManager<ComponentStateBucket> {}

method didCreateComponent

didCreateComponent: (instance: ComponentStateBucket) => void;

interface ComponentManagerWithAsyncUpdateHook

interface ComponentManagerWithAsyncUpdateHook<ComponentStateBucket>
    extends ComponentManagerWithAsyncLifeCycleCallbacks<ComponentStateBucket>,
        ComponentManagerWithUpdateHook<ComponentStateBucket> {}

method didUpdateComponent

didUpdateComponent: (instance: ComponentStateBucket) => void;

interface ComponentManagerWithDestructors

interface ComponentManagerWithDestructors<ComponentStateBucket>
    extends ComponentManager<ComponentStateBucket> {}

method destroyComponent

destroyComponent: (instance: ComponentStateBucket) => void;

interface ComponentManagerWithUpdateHook

interface ComponentManagerWithUpdateHook<ComponentStateBucket>
    extends ComponentManager<ComponentStateBucket> {}

method updateComponent

updateComponent: (instance: ComponentStateBucket, args: Arguments) => void;

interface ConstantTag

interface ConstantTag extends MonomorphicTag {}

property [TYPE]

readonly [TYPE]: CONSTANT_TAG_ID;

interface ContainingMetadata

interface ContainingMetadata {}

property evalSymbols

evalSymbols: Nullable<string[]>;

property isStrictMode

isStrictMode: boolean;

property moduleName

moduleName: string;

property owner

owner: Owner | null;

property scopeValues

scopeValues: unknown[] | null;

property size

size: number;

property upvars

upvars: Nullable<string[]>;

interface Cursor

interface Cursor {}

property element

readonly element: SimpleElement;

property nextSibling

readonly nextSibling: Nullable<SimpleNode>;

interface CustomRenderNode

interface CustomRenderNode extends RenderNode {}

property bucket

bucket: object;

interface DebugRenderTree

interface DebugRenderTree<Bucket extends object = object> {}

method begin

begin: () => void;

method capture

capture: () => CapturedRenderNode[];

method commit

commit: () => void;

method create

create: (state: Bucket, node: RenderNode) => void;

method didRender

didRender: (state: Bucket, bounds: Bounds) => void;

method update

update: (state: Bucket) => void;

method willDestroy

willDestroy: (state: Bucket) => void;

interface DebugSymbolsOperand

interface DebugSymbolsOperand {}

property type

type: DebugSymbolsOperandType;

property value

value: undefined;

interface DirtyableTag

interface DirtyableTag extends MonomorphicTag {}

property [TYPE]

readonly [TYPE]: DIRTYABLE_TAG_ID;

interface DOMStack

interface DOMStack {}

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 closeElement

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

method flushElement

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

method openElement

openElement: (tag: string, _operations?: ElementOperations) => SimpleElement;

method popElement

popElement: () => void;

method popRemoteElement

popRemoteElement: () => RemoteLiveBlock;

method pushRemoteElement

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

method setDynamicAttribute

setDynamicAttribute: (
    name: string,
    value: unknown,
    isTrusting: boolean,
    namespace: Nullable<string>
) => AttributeOperation;

method setStaticAttribute

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

interface DynamicScope

interface DynamicScope {}

method child

child: () => DynamicScope;

method get

get: (key: string) => Reference<unknown>;

method set

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

interface ElementBuilder

interface ElementBuilder extends Cursor, DOMStack, TreeOperations {}

property [CURSOR_STACK]

[CURSOR_STACK]: Stack<Cursor>;

property constructing

constructing: Nullable<SimpleElement>;

property dom

dom: GlimmerTreeConstruction;

property element

element: SimpleElement;

property hasBlocks

hasBlocks: boolean;

property nextSibling

nextSibling: Nullable<SimpleNode>;

property updateOperations

updateOperations: GlimmerTreeChanges;

method debugBlocks

debugBlocks: () => LiveBlock[];

method didAppendBounds

didAppendBounds: (bounds: Bounds) => void;

method popBlock

popBlock: () => LiveBlock;

method pushBlockList

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

method pushSimpleBlock

pushSimpleBlock: () => LiveBlock;

method pushUpdatableBlock

pushUpdatableBlock: () => UpdatableBlock;

interface ElementOperations

interface ElementOperations {}

method setAttribute

setAttribute: (
    name: string,
    value: Reference,
    trusting: boolean,
    namespace: Nullable<string>
) => void;

method setStaticAttribute

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

interface Encoder

interface Encoder {}

The Encoder receives a stream of opcodes from the syntax compiler and turns them into a binary program.

method commit

commit: (size: number) => HandleResult;

Finalize the current compilation unit, add a (Return), and push the opcodes from the buffer into the program. At this point, some of the opcodes might still be placeholders, such as in the case of recursively compiled templates.
Parameter compiler
Parameter size

method error

error: (error: EncoderError) => void;

method label

label: (name: string) => void;

Mark the current position with a label name. This label name can be used by any other opcode in this label block.
Parameter name
Parameter index

method push

push: (
    constants: CompileTimeConstants,
    opcode: BuilderOpcode,
    ...args: SingleBuilderOperand[]
) => void;

Push a syscall into the program with up to three optional operands.
Parameter opcode
Parameter args
up to three operands, formatted as { type: "type", value: value }

method startLabels

startLabels: () => void;

Start a new labels block. A labels block is a scope for labels that can be referred to before they are declared. For example, when compiling an if, the JumpUnless opcode occurs before the target label. To accommodate this use-case ergonomically, the Encoder allows a syntax to create a labels block and then refer to labels that have not yet been declared. Once the block is complete, a second pass replaces the label names with offsets.
The pattern is:
encoder.reserve(Op.JumpUnless); encoder.target(encoder.pos, 'ELSE');
The reserve method creates a placeholder opcode with space for a target in the future, and the target method registers the blank operand position to be replaced with an offset to ELSE, once it's known.

method stopLabels

stopLabels: () => void;

Finish the current labels block and replace label names with offsets, now that all of the offsets are known.

interface EncoderError

interface EncoderError {}

property problem

problem: string;

property span

span: {
    start: number;
    end: number;
};

interface Environment

interface Environment {}

property [TransactionSymbol]

[TransactionSymbol]: Nullable<Transaction>;

property debugRenderTree

debugRenderTree?: DebugRenderTree | undefined;

property isArgumentCaptureError

isArgumentCaptureError?: ((error: any) => boolean) | undefined;

property isInteractive

isInteractive: boolean;

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;

interface EnvironmentOptions

interface EnvironmentOptions {}

property appendOperations

appendOperations?: GlimmerTreeConstruction;

property document

document?: SimpleDocument;

property updateOperations

updateOperations?: GlimmerTreeChanges;

interface ErrHandle

interface ErrHandle {}

property errors

errors: PresentArray<EncoderError>;

property handle

handle: number;

interface ExceptionHandler

interface ExceptionHandler {}

method handleException

handleException: () => void;

interface GlimmerDOMOperations

interface GlimmerDOMOperations {}

method createComment

createComment: (data: string) => SimpleComment;

method createElement

createElement: (tag: string, context?: SimpleElement) => SimpleElement;

method createTextNode

createTextNode: (text: string) => SimpleText;

method insertBefore

insertBefore: (
    parent: SimpleElement,
    node: SimpleNode,
    reference: SimpleNode
) => void;

method insertHTMLBefore

insertHTMLBefore: (
    parent: SimpleElement,
    nextSibling: SimpleNode,
    html: string
) => Bounds;

interface GlimmerTreeChanges

interface GlimmerTreeChanges extends GlimmerDOMOperations {}

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;

interface GlimmerTreeConstruction

interface GlimmerTreeConstruction extends GlimmerDOMOperations {}

method setAttribute

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

interface Helper

interface Helper<O extends Owner = Owner> {}

call signature

(
    args: CapturedArguments,
    owner: O | undefined,
    dynamicScope?: DynamicScope
): Reference;

interface HelperCapabilities

interface HelperCapabilities extends Capabilities {}

property hasDestroyable

hasDestroyable: boolean;

property hasScheduledEffect

hasScheduledEffect: boolean;

property hasValue

hasValue: boolean;

interface HelperCapabilitiesVersions

interface HelperCapabilitiesVersions {}

property '3.23'

'3.23': {
    hasValue?: boolean;
    hasDestroyable?: boolean;
};

interface HelperManager

interface HelperManager<HelperStateBucket> {}

property capabilities

capabilities: HelperCapabilities;

method createHelper

createHelper: (definition: object, args: Arguments) => HelperStateBucket;

method getDebugName

getDebugName: (definition: object) => string;

interface HelperManagerWithDestroyable

interface HelperManagerWithDestroyable<HelperStateBucket>
    extends HelperManager<HelperStateBucket> {}

method getDestroyable

getDestroyable: (bucket: HelperStateBucket) => object;

interface HelperManagerWithValue

interface HelperManagerWithValue<HelperStateBucket>
    extends HelperManager<HelperStateBucket> {}

method getValue

getValue: (bucket: HelperStateBucket) => unknown;

interface InstructionEncoder

interface InstructionEncoder {}

property buffer

readonly buffer: CompilerBuffer;

property size

size: number;

method encode

encode: {
    (type: VmMachineOp, machine: MACHINE_MASK, ...operands: Operand[]): void;
    (type: VmOp, machine: 0, ...operands: number[]): void;
};

method patch

patch: (position: number, target: number) => void;

interface InternalComponentCapabilities

interface InternalComponentCapabilities {}

Describes the capabilities of a particular component. The capabilities are provided to the Glimmer compiler and VM via the ComponentDefinition, which includes a ComponentCapabilities record.
Certain features in the VM come with some overhead, so the compiler and runtime use this information to skip unnecessary work for component types that don't need it.
For example, a component that is template-only (i.e., it does not have an associated JavaScript class to instantiate) can skip invoking component manager hooks related to lifecycle events by setting the elementHook capability to false.

property attributeHook

attributeHook: boolean;

Whether to call the didSplatAttributes hook on the component manager.

property createArgs

createArgs: boolean;

Whether a reified Arguments object will get passed to the component manager's create hook. If a particular component does not access passed arguments from JavaScript (via the this.args property in Glimmer.js, for example), this flag can be set to false to avoid the work of instantiating extra data structures to expose the arguments to JavaScript.

property createCaller

createCaller: boolean;

Whether the component needs the caller component

property createInstance

createInstance: boolean;

Whether there is a component instance to create. If this is false, the component is a "template only component"

property dynamicLayout

dynamicLayout: boolean;

Whether a component's template is static across all instances of that component, or can vary per instance. This should usually be false except for cases of backwards-compatibility.

property dynamicScope

dynamicScope: boolean;

Whether the component needs an additional dynamic scope frame.

property dynamicTag

dynamicTag: boolean;

Whether a "wrapped" component's root element can change after being rendered. This flag is only used by the WrappedBuilder and should be false except for cases of backwards-compatibility.

property elementHook

elementHook: boolean;

Whether to call the didCreateElement hook on the component manager.

property hasSubOwner

hasSubOwner: boolean;

Whether or not the component pushes an owner onto the owner stack. This is used for engines.

property prepareArgs

prepareArgs: boolean;

Setting the prepareArgs flag to true enables the prepareArgs hook on the component manager, which would otherwise not be called.
The component manager's prepareArgs hook allows it to programmatically add or remove positional and named arguments for a component before the component is invoked. This flag should usually be false except for cases of backwards-compatibility.

property updateHook

updateHook: boolean;

Whether the component manager has an update hook.

property willDestroy

willDestroy: boolean;

Whether or not the component has a willDestroy hook that should fire prior to the component being removed from the DOM.

property wrapped

wrapped: boolean;

interface InternalComponentManager

interface InternalComponentManager<
    TComponentStateBucket = unknown,
    TComponentDefinition = object
> {}

method getCapabilities

getCapabilities: (state: TComponentDefinition) => InternalComponentCapabilities;

method getDebugName

getDebugName: (state: TComponentDefinition) => string;

method getDestroyable

getDestroyable: (state: TComponentStateBucket) => Nullable<Destroyable>;

method getSelf

getSelf: (state: TComponentStateBucket) => Reference;

interface InternalHelperManager

interface InternalHelperManager<TOwner extends Owner> {}

method getDelegateFor

getDelegateFor: (owner: TOwner | undefined) => HelperManager<unknown>;

method getHelper

getHelper: (definition: HelperDefinitionState) => Helper;

interface InternalModifierManager

interface InternalModifierManager<
    TModifierInstanceState = ModifierInstanceState,
    TModifierDefinitionState extends ModifierDefinitionState = ModifierDefinitionState
> {}

method create

create: (
    owner: Owner,
    element: SimpleElement,
    state: TModifierDefinitionState,
    args: CapturedArguments
) => TModifierInstanceState;

method getDebugInstance

getDebugInstance: (Modifier: TModifierInstanceState) => unknown;

method getDebugName

getDebugName: (Modifier: TModifierDefinitionState) => string;

method getDestroyable

getDestroyable: (modifier: TModifierInstanceState) => Destroyable | null;

method getTag

getTag: (modifier: TModifierInstanceState) => UpdatableTag | null;

method install

install: (modifier: TModifierInstanceState) => void;

method update

update: (modifier: TModifierInstanceState) => void;

interface Invocation

interface Invocation {}

property handle

handle: number;

property symbolTable

symbolTable: ProgramSymbolTable;

interface IsStrictModeOperand

interface IsStrictModeOperand {}

property type

type: IsStrictModeOperandType;

property value

value: undefined;

interface LabelOperand

interface LabelOperand {}

property type

type: LabelOperandType;

property value

value: string;

interface LayoutOperand

interface LayoutOperand {}

property type

type: LayoutOperandType;

property value

value: CompilableTemplate;

interface LayoutWithContext

interface LayoutWithContext {}

property block

readonly block: SerializedTemplateBlock;

property id

readonly id: string;

property isStrictMode

readonly isStrictMode: boolean;

property moduleName

readonly moduleName: string;

property owner

readonly owner: Owner | null;

property scope

readonly scope: (() => unknown[]) | undefined | null;

interface LiveBlock

interface LiveBlock extends Bounds {}

method closeElement

closeElement: () => void;

method didAppendBounds

didAppendBounds: (bounds: Bounds) => void;

method didAppendNode

didAppendNode: (node: SimpleNode) => void;

method finalize

finalize: (stack: ElementBuilder) => void;

method openElement

openElement: (element: SimpleElement) => void;

interface ModifierCapabilities

interface ModifierCapabilities extends Capabilities {}

property disableAutoTracking

disableAutoTracking: boolean;

interface ModifierCapabilitiesVersions

interface ModifierCapabilitiesVersions {}

property '3.22'

'3.22': {
    disableAutoTracking?: boolean;
};

interface ModifierDefinition

interface ModifierDefinition<
    I = unknown,
    D extends ModifierDefinitionState = ModifierDefinitionState
> {}

property manager

manager: InternalModifierManager<I, D>;

property resolvedName

resolvedName: string | null;

property state

state: ModifierDefinitionState;

interface ModifierInstance

interface ModifierInstance {}

property definition

definition: ModifierDefinition;

property manager

manager: InternalModifierManager;

property state

state: ModifierInstanceState;

interface ModifierManager

interface ModifierManager<ModifierStateBucket> {}

property capabilities

capabilities: ModifierCapabilities;

method createModifier

createModifier: (factory: unknown, args: Arguments) => ModifierStateBucket;

method destroyModifier

destroyModifier: (instance: ModifierStateBucket, args: Arguments) => void;

method installModifier

installModifier: (
    instance: ModifierStateBucket,
    element: Element,
    args: Arguments
) => void;

method updateModifier

updateModifier: (instance: ModifierStateBucket, args: Arguments) => void;

interface MonomorphicTag

interface MonomorphicTag extends Tag {}

property [TYPE]

readonly [TYPE]: MonomorphicTagId;

interface NamedArguments

interface NamedArguments {}

property length

length: number;

property names

names: readonly string[];

method capture

capture: () => CapturedNamedArguments;

method get

get: (name: string) => Reference;

method has

has: (name: string) => boolean;

interface NamedBlocks

interface NamedBlocks {}

property hasAny

hasAny: boolean;

property names

names: string[];

method get

get: (name: string) => SerializedInlineBlock;

method has

has: (name: string) => boolean;

method with

with: (name: string, block: SerializedInlineBlock) => NamedBlocks;

interface NodeTokens

interface NodeTokens {}

method reify

reify: (token: NodeToken) => SimpleNode;

interface NonSmallIntOperand

interface NonSmallIntOperand {}

property type

type: NonSmallIntOperandType;

property value

value: number;

interface OpcodeHeap

interface OpcodeHeap {}

method getbyaddr

getbyaddr: (address: number) => number;

interface PartialScope

interface PartialScope extends Scope {}

method bindEvalScope

bindEvalScope: (scope: Nullable<Dict<ScopeSlot>>) => void;

interface PositionalArguments

interface PositionalArguments {}

property length

length: number;

method at

at: (position: number) => Reference;

method capture

capture: () => CapturedPositionalArguments;

interface PreparedArguments

interface PreparedArguments {}

property named

named: Dict<Reference>;

property positional

positional: ReadonlyArray<Reference>;

interface ProgramSymbolTable

interface ProgramSymbolTable {}

property hasEval

hasEval: boolean;

property symbols

symbols: string[];

interface Reference

interface Reference<T = unknown> {}

property [REFERENCE]

[REFERENCE]: ReferenceType;

property children

children: null | Map<string | Reference, Reference>;

property compute

compute: Nullable<() => T>;

property debugLabel

debugLabel?: string | undefined;

interface ReferenceTypes

interface ReferenceTypes {}

property Compute

readonly Compute: ComputeReference;

property Constant

readonly Constant: ConstantReference;

property Invokable

readonly Invokable: InvokableReference;

property Unbound

readonly Unbound: UnboundReference;

interface Reifiable

interface Reifiable {}

method reify

reify: (tokens: NodeTokens) => void;

interface RenderNode

interface RenderNode {}

property args

args: CapturedArguments;

property instance

instance: unknown;

property name

name: string;

property template

template?: string | undefined;

property type

type: RenderNodeType;

interface RenderResult

interface RenderResult extends Bounds, ExceptionHandler {}

property drop

readonly drop: object;

property env

readonly env: Environment;

method firstNode

firstNode: () => SimpleNode;

method lastNode

lastNode: () => SimpleNode;

method parentElement

parentElement: () => SimpleElement;

method rerender

rerender: (options?: { alwaysRevalidate: false }) => void;

interface ResolutionTimeConstants

interface ResolutionTimeConstants {}

Resolution happens when components are first loaded, either via the resolver or via looking them up in template scope.

property defaultTemplate

defaultTemplate: Template;

method component

component: {
    (
        definitionState: ComponentDefinitionState,
        owner: object,
        isOptional?: false
    ): ComponentDefinition;
    (
        definitionState: object,
        owner: object,
        isOptional?: boolean
    ): ComponentDefinition<
        object,
        unknown,
        InternalComponentManager<unknown, object>
    >;
};

method helper

helper: {
    (
        definitionState: HelperDefinitionState,
        resolvedName: string | null,
        isOptional: true
    ): number | null;
    (definitionState: object, resolvedName?: string): number;
};

method modifier

modifier: {
    (
        definitionState: ModifierDefinitionState,
        resolvedName: string | null,
        isOptional: true
    ): number | null;
    (definitionState: object, resolvedName?: string): number;
};

method resolvedComponent

resolvedComponent: (
    definitionState: ResolvedComponentDefinition,
    resolvedName: string
) => ComponentDefinition;

interface ResolvedComponentDefinition

interface ResolvedComponentDefinition<
    D = ComponentDefinitionState,
    I = ComponentInstanceState,
    M extends InternalComponentManager<I, D> = InternalComponentManager<I, D>
> {}

property manager

manager: M;

property state

state: D;

property template

template: Template | null;

interface ResolvedLayout

interface ResolvedLayout {}

property capabilities

capabilities: InternalComponentCapabilities;

property compilable

compilable: Nullable<CompilableProgram>;

property handle

handle: number;

interface RuntimeArtifacts

interface RuntimeArtifacts {}

property constants

readonly constants: RuntimeConstants & ResolutionTimeConstants;

property heap

readonly heap: RuntimeHeap;

interface RuntimeConstants

interface RuntimeConstants {}

method getArray

getArray: <T>(handle: number) => T[];

method getValue

getValue: <T>(handle: number) => T;

interface RuntimeContext

interface RuntimeContext {}

The Runtime is the set of static structures that contain the compiled code and any host configuration.
The contents of the Runtime do not change as the VM executes, unlike the VM state.

property env

env: Environment;

property program

program: RuntimeProgram;

property resolver

resolver: RuntimeResolver;

interface RuntimeHeap

interface RuntimeHeap extends OpcodeHeap {}

method getaddr

getaddr: (handle: number) => number;

method sizeof

sizeof: (handle: number) => number;

interface RuntimeOp

interface RuntimeOp {}

property isMachine

isMachine: 0 | 1;

property offset

offset: number;

property op1

op1: number;

property op2

op2: number;

property op3

op3: number;

property size

size: number;

property type

type: SomeVmOp;

interface RuntimeProgram

interface RuntimeProgram {}

property constants

readonly constants: RuntimeConstants & ResolutionTimeConstants;

property heap

readonly heap: RuntimeHeap;

method opcode

opcode: (offset: number) => RuntimeOp;

interface RuntimeResolver

interface RuntimeResolver<O extends Owner = Owner> {}

method lookupComponent

lookupComponent: (
    name: string,
    owner: O
) => Nullable<ResolvedComponentDefinition>;

interface Scope

interface Scope {}

property owner

readonly owner: Owner;

property slots

readonly slots: Array<ScopeSlot>;

method bind

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

method bindBlock

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

method bindEvalScope

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

method bindPartialMap

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

method bindSelf

bindSelf: (self: Reference) => void;

method bindSymbol

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

method child

child: () => Scope;

method getBlock

getBlock: (symbol: number) => ScopeBlock;

method getEvalScope

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

method getPartialMap

getPartialMap: () => Nullable<Dict<Reference>>;

method getSelf

getSelf: () => Reference;

method getSymbol

getSymbol: (symbol: number) => Reference;

interface SerializedHeap

interface SerializedHeap {}

property buffer

buffer: ArrayBuffer;

property handle

handle: number;

property table

table: number[];

interface SerializedTemplate

interface SerializedTemplate {}

A JSON object that the compiled Template was serialized into.

property block

block: SerializedTemplateBlock;

property id

id?: Nullable<string>;

property moduleName

moduleName: string;

interface SerializedTemplateWithLazyBlock

interface SerializedTemplateWithLazyBlock {}

A JSON object containing the SerializedTemplateBlock as JSON and TemplateMeta.

property block

block: SerializedTemplateBlockJSON;

property id

id?: Nullable<string>;

property isStrictMode

isStrictMode: boolean;

property moduleName

moduleName: string;

property scope

scope?: (() => unknown[]) | undefined | null;

interface SexpOpcodeMap

interface SexpOpcodeMap extends ExpressionSexpOpcodeMap, StatementSexpOpcodeMap {}

interface SimpleArgsOptions

interface SimpleArgsOptions {}

property atNames

atNames: boolean;

property named

named: Nullable<WireFormat.Core.Hash>;

property positional

positional: Nullable<WireFormat.Core.Params>;

interface SimpleLiveBlock

interface SimpleLiveBlock extends LiveBlock {}

method firstNode

firstNode: () => SimpleNode;

method lastNode

lastNode: () => SimpleNode;

method parentElement

parentElement: () => SimpleElement;

interface SpecTreeConstruction

interface SpecTreeConstruction {}

method appendComment

appendComment: (text: string) => NodeToken;

method appendText

appendText: (text: string) => NodeToken;

method appendTo

appendTo: (parent: SimpleElement | SimpleDocumentFragment) => NodeTokens;

method closeElement

closeElement: () => void;

method openElement

openElement: (name: string, ns?: Namespace) => NodeToken;

method setAttribute

setAttribute: (name: string, value: string, namespace?: Namespace) => void;

interface Stack

interface Stack<T> {}

property current

current: Nullable<T>;

property size

size: number;

method isEmpty

isEmpty: () => boolean;

method nth

nth: (from: number) => Nullable<T>;

method pop

pop: () => Nullable<T>;

method push

push: (item: T) => void;

method toArray

toArray: () => T[];

interface STDLib

interface STDLib {}

property 'cautious-append'

'cautious-append': number;

property 'cautious-non-dynamic-append'

'cautious-non-dynamic-append': number;

property 'trusting-append'

'trusting-append': number;

property 'trusting-non-dynamic-append'

'trusting-non-dynamic-append': number;

property main

main: number;

interface StdLibOperand

interface StdLibOperand {}

property type

type: StdLibOperandType;

property value

value:
    | 'main'
    | 'trusting-append'
    | 'cautious-append'
    | 'trusting-non-dynamic-append'
    | 'cautious-non-dynamic-append';

interface SymbolTableOperand

interface SymbolTableOperand {}

property type

type: SymbolTableOperandType;

property value

value: SymbolTable;

interface Tag

interface Tag {}

property [TYPE]

readonly [TYPE]: TagId;

property subtag

readonly subtag?: Tag | Tag[] | null | undefined;

method [COMPUTE]

[COMPUTE]: () => Revision;

interface TemplateCompilationContext

interface TemplateCompilationContext {}

Options for compiling a specific template. This carries along the static information associated with the entire template when compiling blocks nested inside of it.

property encoder

readonly encoder: Encoder;

property meta

readonly meta: ContainingMetadata;

property program

readonly program: CompileTimeCompilationContext;

interface TemplateError

interface TemplateError {}

property problem

problem: string;

property result

result: 'error';

property span

span: {
    start: number;
    end: number;
};

interface TemplateIterator

interface TemplateIterator {}

method next

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

method sync

sync: () => RenderResult;

interface TemplateOk

interface TemplateOk {}

Environment specific template.

property moduleName

moduleName: string;

Module name associated with the template, used for debugging purposes

property result

result: 'ok';

method asLayout

asLayout: () => CompilableProgram;

method asWrappedLayout

asWrappedLayout: () => CompilableProgram;

interface TreeOperations

interface TreeOperations {}

interface Unique

interface Unique<T> {}

property 'Unique [id=ada0f31f-27f7-4ab0-bc03-0005387c9d5f]'

'Unique [id=ada0f31f-27f7-4ab0-bc03-0005387c9d5f]': T;

interface UpdatableBlock

interface UpdatableBlock extends SimpleLiveBlock {}

method reset

reset: (env: Environment) => SimpleNode;

interface UpdatableTag

interface UpdatableTag extends MonomorphicTag {}

property [TYPE]

readonly [TYPE]: UPDATABLE_TAG_ID;

interface UpdatingOpcode

interface UpdatingOpcode {}

method evaluate

evaluate: (vm: UpdatingVM) => void;

interface UpdatingVM

interface UpdatingVM {}

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: ExceptionHandler | null) => void;

interface VM

interface VM<O extends Owner = Owner> {}

This is used in the Glimmer Embedding API. In particular, embeddings provide helpers through the CompileTimeLookup interface, and the helpers they provide implement the Helper interface, which is a function that takes a VM as a parameter.

property env

env: Environment;

method associateDestroyable

associateDestroyable: (child: Destroyable) => void;

method dynamicScope

dynamicScope: () => DynamicScope;

method getOwner

getOwner: () => O;

method getSelf

getSelf: () => Reference;

interface VMArguments

interface VMArguments {}

property length

length: number;

property named

named: NamedArguments;

property positional

positional: PositionalArguments;

method at

at: (pos: number) => Reference;

method capture

capture: () => CapturedArguments;

interface WithAttributeHook

interface WithAttributeHook<ComponentInstanceState>
    extends InternalComponentManager<ComponentInstanceState> {}

method didSplatAttributes

didSplatAttributes: (
    component: ComponentInstanceState,
    element: ComponentInstanceState,
    operations: ElementOperations
) => void;

interface WithCreateInstance

interface WithCreateInstance<
    ComponentInstanceState = unknown,
    ComponentDefinitionState = unknown,
    O extends Owner = Owner
> extends InternalComponentManager<
        ComponentInstanceState,
        ComponentDefinitionState
    > {}

method create

create: (
    owner: O,
    state: ComponentDefinitionState,
    args: Nullable<VMArguments>,
    env: Environment,
    dynamicScope: Nullable<DynamicScope>,
    caller: Nullable<Reference>,
    hasDefaultBlock: boolean
) => ComponentInstanceState;

method didCreate

didCreate: (state: ComponentInstanceState) => void;

method didRenderLayout

didRenderLayout: (state: ComponentInstanceState, bounds: Bounds) => void;

method didUpdate

didUpdate: (state: ComponentInstanceState) => void;

method didUpdateLayout

didUpdateLayout: (state: ComponentInstanceState, bounds: Bounds) => void;

interface WithCustomDebugRenderTree

interface WithCustomDebugRenderTree<
    ComponentInstanceState = unknown,
    ComponentDefinitionState = unknown
> extends InternalComponentManager<
        ComponentInstanceState,
        ComponentDefinitionState
    > {}

method getDebugCustomRenderTree

getDebugCustomRenderTree: (
    definition: ComponentDefinitionState,
    state: ComponentInstanceState,
    args: CapturedArguments,
    template?: string
) => CustomRenderNode[];

interface WithDynamicLayout

interface WithDynamicLayout<
    I = ComponentInstanceState,
    R extends RuntimeResolver = RuntimeResolver
> extends InternalComponentManager<I> {}

method getDynamicLayout

getDynamicLayout: (component: I, resolver: R) => CompilableProgram | null;

interface WithDynamicTagName

interface WithDynamicTagName<ComponentInstanceState>
    extends InternalComponentManager<ComponentInstanceState> {}

method getTagName

getTagName: (component: ComponentInstanceState) => Nullable<string>;

interface WithElementHook

interface WithElementHook<ComponentInstanceState>
    extends InternalComponentManager<ComponentInstanceState> {}

method didCreateElement

didCreateElement: (
    component: ComponentInstanceState,
    element: SimpleElement,
    operations: ElementOperations
) => void;

interface WithPrepareArgs

interface WithPrepareArgs<
    ComponentInstanceState = unknown,
    ComponentDefinitionState = unknown
> extends InternalComponentManager<
        ComponentInstanceState,
        ComponentDefinitionState
    > {}

method prepareArgs

prepareArgs: (
    state: ComponentDefinitionState,
    args: VMArguments
) => Nullable<PreparedArguments>;

interface WithSubOwner

interface WithSubOwner<
    ComponentInstanceState = unknown,
    ComponentDefinitionState = unknown
> extends InternalComponentManager<
        ComponentInstanceState,
        ComponentDefinitionState
    > {}

method getOwner

getOwner: (state: ComponentInstanceState) => Owner;

interface WithUpdateHook

interface WithUpdateHook<ComponentInstanceState = unknown>
    extends InternalComponentManager<ComponentInstanceState> {}

method update

update: (
    state: ComponentInstanceState,
    dynamicScope: Nullable<DynamicScope>
) => void;

Enums

enum ResolverContext

enum ResolverContext {
    Component,
    Modifier,
    Helper,
    HelperOrComponent,
}

member Component

Component

member Helper

Helper

member HelperOrComponent

HelperOrComponent

member Modifier

Modifier

Type Aliases

type AppendOpcode

type AppendOpcode = 1;

type ARG_SHIFT

type ARG_SHIFT = 8;

type Argument

type Argument = Statements.Argument;

type ATag

type ATag = 3;

type Attribute

type Attribute = Statements.Attribute;

type AttributeHookCapability

type AttributeHookCapability = 0b0000000010000;

type AttrOpcode

type AttrOpcode =
    | StaticAttrOpcode
    | StaticComponentAttrOpcode
    | DynamicAttrOpcode
    | TrustingDynamicAttrOpcode
    | ComponentAttrOpcode
    | TrustingComponentAttrOpcode;

type AttrSplatOpcode

type AttrSplatOpcode = 17;

type Block

type Block = CompilableBlock | number;

type BlockOpcode

type BlockOpcode = 6;

type BlockOperandType

type BlockOperandType = 4;

type BlockValue

type BlockValue = ScopeBlock[0 | 1 | 2];

type BuilderOp

type BuilderOp = [
    op: BuilderOpcode,
    op1?: SingleBuilderOperand,
    op1?: SingleBuilderOperand,
    op1?: SingleBuilderOperand
];

type BuilderOpcode

type BuilderOpcode = Op | MachineOp;

type CallOpcode

type CallOpcode = 28;

type CapabilityMask

type CapabilityMask = number & {
    [CapabilityBrand]: never;
};

type ClassAttr

type ClassAttr = 0;

type CloseElementOpcode

type CloseElementOpcode = 13;

type COMBINATOR_TAG_ID

type COMBINATOR_TAG_ID = 2;

type CommentOpcode

type CommentOpcode = 3;

type CompilableBlock

type CompilableBlock = CompilableTemplate<BlockSymbolTable>;

type CompilerBuffer

type CompilerBuffer = Array<Operand>;

type ComponentAttrOpcode

type ComponentAttrOpcode = 16;

type ComponentContent

type ComponentContent = 0;

type ComponentDefinitionState

type ComponentDefinitionState = object;

type ComponentInstanceState

type ComponentInstanceState = unknown;

type ComponentInstanceWithCreate

type ComponentInstanceWithCreate = ComponentInstance<
    ComponentDefinitionState,
    ComponentInstanceState,
    WithCreateInstance
>;

type ComponentOpcode

type ComponentOpcode = 8;

type ComputeReference

type ComputeReference = 1;

type ConcatOpcode

type ConcatOpcode = 29;

type CONSTANT_TAG_ID

type CONSTANT_TAG_ID = 3;

type ConstantPool

type ConstantPool = unknown[];

type ConstantReference

type ConstantReference = 0;

type ContentType

type ContentType =
    | ComponentContent
    | HelperContent
    | StringContent
    | EmptyContent
    | SafeStringContent
    | FragmentContent
    | NodeContent
    | OtherContent;

type CoreSyntax

type CoreSyntax = Core.Syntax;

type CreateArgsCapability

type CreateArgsCapability = 0b0000000001000;

type CreateCallerCapability

type CreateCallerCapability = 0b0000010000000;

type CreateInstanceCapability

type CreateInstanceCapability = 0b0001000000000;

type CreateRuntimeOp

type CreateRuntimeOp = (heap: CompileTimeHeap) => RuntimeOp;

type CURRENT_TAG_ID

type CURRENT_TAG_ID = 101;

type CurriedComponent

type CurriedComponent = 0;

type CurriedHelper

type CurriedHelper = 1;

type CurriedModifier

type CurriedModifier = 2;

type CurriedType

type CurriedType = CurriedComponent | CurriedHelper | CurriedModifier;

type CurryOpcode

type CurryOpcode = 50;

type CursorStackSymbol

type CursorStackSymbol = typeof CURSOR_STACK;

type DebuggerOpcode

type DebuggerOpcode = 26;

type DebugSymbolsOperandType

type DebugSymbolsOperandType = 3;

type Destroyable

type Destroyable = object;

type Destructor

type Destructor<T extends Destroyable> = (destroyable: T) => void;

type Dict

type Dict<T = unknown> = Record<string, T>;

type DictValue

type DictValue<D extends Dict> = D extends Dict<infer V> ? V : never;

type DIRTYABLE_TAG_ID

type DIRTYABLE_TAG_ID = 0;

type DivTag

type DivTag = 0;

type DynamicArgOpcode

type DynamicArgOpcode = 20;

type DynamicAttrOpcode

type DynamicAttrOpcode = 15;

type DynamicLayoutCapability

type DynamicLayoutCapability = 0b0000000000001;

type DynamicScopeCapability

type DynamicScopeCapability = 0b0000001000000;

type DynamicTagCapability

type DynamicTagCapability = 0b0000000000010;

type EachOpcode

type EachOpcode = 42;

type ElementHookCapability

type ElementHookCapability = 0b0000000100000;

type ElementParameter

type ElementParameter = Statements.ElementParameter;

type EMPTY_ARRAY

type EMPTY_ARRAY = Array<ReadonlyArray<never>>;

type EmptyCapability

type EmptyCapability = 0b0000000000000;

Enum used for bit flags version of the capabilities, used once the component has been loaded for the first time

type EmptyContent

type EmptyContent = 3;

type EncoderOperands

type EncoderOperands =
    | []
    | [Operand]
    | [Operand, Operand]
    | [Operand, Operand, Operand];

type Expand

type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;

type Expression

type Expression = Expressions.Expression;

type ExpressionSexpOpcode

type ExpressionSexpOpcode = TupleExpression[0];

type ExpressionSexpOpcodeMap

type ExpressionSexpOpcodeMap = {
    [TSexpOpcode in TupleExpression[0]]: Extract<
        TupleExpression,
        { 0: TSexpOpcode }
    >;
};

type FIXME

type FIXME<T, _S extends string> = T;

type FlushElementOpcode

type FlushElementOpcode = 12;

type FragmentContent

type FragmentContent = 5;

type Get

type Get = Expressions.GetVar;

type GetContextualFreeOpcode

type GetContextualFreeOpcode =
    | GetFreeAsComponentOrHelperHeadOpcode
    | GetFreeAsHelperHeadOpcode
    | GetFreeAsModifierHeadOpcode
    | GetFreeAsComponentHeadOpcode
    | GetStrictKeywordOpcode;

type GetDynamicVarOpcode

type GetDynamicVarOpcode = 53;

type GetEndOpcode

type GetEndOpcode = GetFreeAsComponentHeadOpcode;

type GetFreeAsComponentHeadOpcode

type GetFreeAsComponentHeadOpcode = 39;

type GetFreeAsComponentOrHelperHeadOpcode

type GetFreeAsComponentOrHelperHeadOpcode = 35;

type GetFreeAsHelperHeadOpcode

type GetFreeAsHelperHeadOpcode = 37;

type GetFreeAsModifierHeadOpcode

type GetFreeAsModifierHeadOpcode = 38;

type GetLexicalSymbolOpcode

type GetLexicalSymbolOpcode = 32;

type GetLooseFreeEndOpcode

type GetLooseFreeEndOpcode = GetFreeAsComponentHeadOpcode;

type GetStartOpcode

type GetStartOpcode = GetSymbolOpcode;

type GetStrictKeywordOpcode

type GetStrictKeywordOpcode = 31;

type GetSymbolOpcode

type GetSymbolOpcode = 30;

type HandleResult

type HandleResult = OkHandle | ErrHandle;

type HasBlockOpcode

type HasBlockOpcode = 48;

type HasBlockParamsOpcode

type HasBlockParamsOpcode = 49;

type HasSubOwnerCapability

type HasSubOwnerCapability = 0b1000000000000;

type HelperContent

type HelperContent = 1;

type HelperDefinitionState

type HelperDefinitionState = object;

type HighLevelBuilderOp

type HighLevelBuilderOp = StartLabelsOp | StopLabelsOp | LabelOp;

type HighLevelBuilderOpcode

type HighLevelBuilderOpcode =
    | HighLevelLabel
    | HighLevelStartLabels
    | HighLevelStopLabels;

type HighLevelBuilderOperand

type HighLevelBuilderOperand =
    | LabelOperand
    | IsStrictModeOperand
    | DebugSymbolsOperand
    | StdLibOperand
    | BlockOperand
    | NonSmallIntOperand
    | SymbolTableOperand
    | LayoutOperand;

type HighLevelEnd

type HighLevelEnd = HighLevelStopLabels;

type HighLevelLabel

type HighLevelLabel = 1000;

type HighLevelOp

type HighLevelOp = HighLevelBuilderOp | HighLevelResolutionOp;

type HighLevelResolutionOp

type HighLevelResolutionOp =
    | ResolveModifierOp
    | ResolveComponentOp
    | ResolveComponentOrHelperOp
    | ResolveHelperOp
    | ResolveOptionalComponentOrHelperOp
    | ResolveTemplateLocalOp
    | ResolveLocalOp;

type HighLevelResolutionOpcode

type HighLevelResolutionOpcode =
    | HighLevelResolveModifier
    | HighLevelResolveComponent
    | HighLevelResolveHelper
    | HighLevelResolveComponentOrHelper
    | HighLevelResolveOptionalComponentOrHelper
    | HighLevelResolveLocal
    | HighLevelResolveTemplateLocal;

type HighLevelResolveComponent

type HighLevelResolveComponent = 1004;

type HighLevelResolveComponentOrHelper

type HighLevelResolveComponentOrHelper = 1007;

type HighLevelResolveHelper

type HighLevelResolveHelper = 1005;

type HighLevelResolveLocal

type HighLevelResolveLocal = 1010;

type HighLevelResolveModifier

type HighLevelResolveModifier = 1003;

type HighLevelResolveOptionalComponentOrHelper

type HighLevelResolveOptionalComponentOrHelper = 1008;

type HighLevelResolveStart

type HighLevelResolveStart = HighLevelResolveModifier;

type HighLevelResolveTemplateLocal

type HighLevelResolveTemplateLocal = 1011;

type HighLevelRevolveEnd

type HighLevelRevolveEnd = HighLevelResolveTemplateLocal;

type HighLevelStart

type HighLevelStart = HighLevelLabel;

type HighLevelStartLabels

type HighLevelStartLabels = 1001;

type HighLevelStopLabels

type HighLevelStopLabels = 1002;

type HrefAttr

type HrefAttr = 6;

type IdAttr

type IdAttr = 1;

type IfInlineOpcode

type IfInlineOpcode = 52;

type IfOpcode

type IfOpcode = 41;

type InElementOpcode

type InElementOpcode = 40;

type InternalComponentCapability

type InternalComponentCapability =
    | EmptyCapability
    | DynamicLayoutCapability
    | DynamicTagCapability
    | PrepareArgsCapability
    | CreateArgsCapability
    | AttributeHookCapability
    | ElementHookCapability
    | DynamicScopeCapability
    | CreateCallerCapability
    | UpdateHookCapability
    | CreateInstanceCapability
    | WrappedCapability
    | WillDestroyCapability
    | HasSubOwnerCapability;

type InvokableReference

type InvokableReference = 3;

type InvokeComponentOpcode

type InvokeComponentOpcode = 46;

type IsStrictModeOperandType

type IsStrictModeOperandType = 2;

type LabelOp

type LabelOp = [op: HighLevelLabel, op1: string];

type LabelOperandType

type LabelOperandType = 1;

type LayoutOperandType

type LayoutOperandType = 8;

type LetOpcode

type LetOpcode = 44;

type LogOpcode

type LogOpcode = 54;

type MACHINE_MASK

type MACHINE_MASK = 0b00000000000000000000010000000000;

type MAX_SIZE

type MAX_SIZE = 0x7fffffff;

type Maybe

type Maybe<T> = Nullable<T> | Optional<T>;

type ModifierDefinitionState

type ModifierDefinitionState = object;

type ModifierInstanceState

type ModifierInstanceState = unknown;

type ModifierOpcode

type ModifierOpcode = 4;

type MonomorphicTagId

type MonomorphicTagId =
    | DIRTYABLE_TAG_ID
    | UPDATABLE_TAG_ID
    | COMBINATOR_TAG_ID
    | CONSTANT_TAG_ID;

This union represents all of the possible tag types for the monomorphic tag class. Other custom tag classes can exist, such as CurrentTag and VolatileTag, but for performance reasons, any type of tag that is meant to be used frequently should be added to the monomorphic tag.

type NameAttr

type NameAttr = 3;

type NodeContent

type NodeContent = 6;

type NodeToken

type NodeToken = number;

type NonSmallIntOperandType

type NonSmallIntOperandType = 6;

type NotOpcode

type NotOpcode = 51;

type Nullable

type Nullable<T> = T | null;

type OkHandle

type OkHandle = number;

type OpenElementOpcode

type OpenElementOpcode = 10;

type OpenElementWithSplatOpcode

type OpenElementWithSplatOpcode = 11;

type Operand

type Operand = number;

type OPERAND_LEN_MASK

type OPERAND_LEN_MASK = 0b00000000000000000000001100000000;

type OperandType

type OperandType =
    | LabelOperandType
    | IsStrictModeOperandType
    | DebugSymbolsOperandType
    | BlockOperandType
    | StdLibOperandType
    | NonSmallIntOperandType
    | SymbolTableOperandType
    | LayoutOperandType;

type Optional

type Optional<T> = T | undefined;

type OptionalArray

type OptionalArray<T> = Optional<PresentArray<T>>;

type OtherContent

type OtherContent = 8;

type Owner

type Owner = object;

type PolymorphicTagId

type PolymorphicTagId = VOLATILE_TAG_ID | CURRENT_TAG_ID;

type PrepareArgsCapability

type PrepareArgsCapability = 0b0000000000100;

type Present

type Present<T> = Exclude<T, null | undefined>;

type PresentArray

type PresentArray<T> = [T, ...T[]];

type PTag

type PTag = 2;

type Recast

type Recast<T, U> = (T & U) | U;

type ReferenceSymbol

type ReferenceSymbol = typeof REFERENCE;

type ReferenceType

type ReferenceType =
    | ConstantReference
    | ComputeReference
    | UnboundReference
    | InvokableReference;

type RemoteLiveBlock

type RemoteLiveBlock = SimpleLiveBlock;

type RenderNodeType

type RenderNodeType =
    | 'outlet'
    | 'engine'
    | 'route-template'
    | 'component'
    | 'modifier'
    | 'keyword';

type ResolveAsComponentHeadResolution

type ResolveAsComponentHeadResolution = 7;

type ResolveAsComponentOrHelperHeadResolution

type ResolveAsComponentOrHelperHeadResolution = 1;

type ResolveAsHelperHeadResolution

type ResolveAsHelperHeadResolution = 5;

type ResolveAsModifierHeadResolution

type ResolveAsModifierHeadResolution = 6;

type ResolveComponentOp

type ResolveComponentOp = [
    op: HighLevelResolveComponent,
    op1: WireFormat.Expressions.Expression,
    op2: (component: CompileTimeComponent) => void
];

type ResolveComponentOrHelperOp

type ResolveComponentOrHelperOp = [
    op: HighLevelResolveComponentOrHelper,
    op1: WireFormat.Expressions.Expression,
    op2: {
        ifComponent: (component: CompileTimeComponent) => void;
        ifHelper: (handle: number) => void;
    }
];

type ResolveHelperOp

type ResolveHelperOp = [
    op: HighLevelResolveHelper,
    op1: WireFormat.Expressions.Expression,
    op2: (handle: number) => void
];

type ResolveLocalOp

type ResolveLocalOp = [
    op: HighLevelResolveLocal,
    op1: number,
    op2: (name: string, moduleName: string) => void
];

type ResolveModifierOp

type ResolveModifierOp = [
    op: HighLevelResolveModifier,
    op1: WireFormat.Expressions.Expression,
    op2: (handle: number) => void
];

type ResolveOptionalComponentOrHelperOp

type ResolveOptionalComponentOrHelperOp = [
    op: HighLevelResolveOptionalComponentOrHelper,
    op1: WireFormat.Expressions.Expression,
    op2: {
        ifComponent: (component: CompileTimeComponent) => void;
        ifHelper: (handle: number) => void;
        ifValue: (handle: number) => void;
    }
];

type ResolveTemplateLocalOp

type ResolveTemplateLocalOp = [
    op: HighLevelResolveTemplateLocal,
    op1: number,
    op2: (handle: number) => void
];

type Revision

type Revision = number;

type RichIteratorResult

type RichIteratorResult<Tick, Return> =
    | {
          done: false;
          value: Tick;
      }
    | {
          done: true;
          value: Return;
      };

This is needed because the normal IteratorResult in the TypeScript standard library is generic over the value in each tick and not over the return value. It represents a standard ECMAScript IteratorResult.

type SafeStringContent

type SafeStringContent = 4;

type ScopeBlock

type ScopeBlock = [CompilableBlock, Scope, BlockSymbolTable];

type ScopeSlot

type ScopeSlot = Reference | ScopeBlock | null;

type SerializedBlock

type SerializedBlock = [statements: Statements.Statement[]];

A JSON object that the Block was serialized into.

type SerializedInlineBlock

type SerializedInlineBlock = [
    statements: Statements.Statement[],
    parameters: number[]
];

type SerializedStdlib

type SerializedStdlib = [number, number, number];

type SerializedTemplateBlock

type SerializedTemplateBlock = [
    // statements
    Statements.Statement[],
    // symbols
    string[],
    // hasDebug
    boolean,
    // upvars
    string[]
];

A JSON object that the compiled TemplateBlock was serialized into.

type SerializedTemplateBlockJSON

type SerializedTemplateBlockJSON = string;

A string of JSON containing a SerializedTemplateBlock

type SexpOpcode

type SexpOpcode = keyof SexpOpcodeMap;

type SexpSyntax

type SexpSyntax = Statement | TupleExpression;

type SingleBuilderOperand

type SingleBuilderOperand =
    | HighLevelBuilderOperand
    | number
    | string
    | boolean
    | undefined
    | null
    | number[]
    | string[];

type SomeVmOp

type SomeVmOp = VmOp | VmMachineOp;

type SpanTag

type SpanTag = 1;

type StartLabelsOp

type StartLabelsOp = [op: HighLevelStartLabels];

type Statement

type Statement = Statements.Statement;

A Handlebars statement

type StatementSexpOpcode

type StatementSexpOpcode = Statement[0];

type StatementSexpOpcodeMap

type StatementSexpOpcodeMap = {
    [TSexpOpcode in Statement[0]]: Extract<Statement, { 0: TSexpOpcode }>;
};

type StaticArgOpcode

type StaticArgOpcode = 21;

type StaticAttrOpcode

type StaticAttrOpcode = 14;

type StaticComponentAttrOpcode

type StaticComponentAttrOpcode = 24;

type STDLibName

type STDLibName = keyof STDLib;

type StdLibOperandType

type StdLibOperandType = 5;

type StopLabelsOp

type StopLabelsOp = [op: HighLevelStopLabels];

type StrictBlockOpcode

type StrictBlockOpcode = 7;

type StrictModifierOpcode

type StrictModifierOpcode = 5;

type StrictResolution

type StrictResolution = 0;

A VariableResolutionContext explains how a variable name should be resolved.

type StringContent

type StringContent = 2;

type StyleAttr

type StyleAttr = 5;

type SymbolTable

type SymbolTable = ProgramSymbolTable | BlockSymbolTable;

type SymbolTableOperandType

type SymbolTableOperandType = 7;

type Syntax

type Syntax = SexpSyntax | Expressions.Value | undefined;

type SyntaxWithInternal

type SyntaxWithInternal =
    | Syntax
    | CoreSyntax
    | SerializedTemplateBlock
    | Core.CallArgs
    | Core.NamedBlock
    | Core.ElementParameters;

type TagComputeSymbol

type TagComputeSymbol = typeof COMPUTE;

type TagId

type TagId = MonomorphicTagId | PolymorphicTagId;

type TagTypeSymbol

type TagTypeSymbol = typeof TYPE;

type Template

type Template = TemplateOk | TemplateError;

type TemplateFactory

type TemplateFactory = (owner?: Owner) => Template;

type TemplateJavascript

type TemplateJavascript = string;

A string of Javascript containing a SerializedTemplateWithLazyBlock to be concatenated into a Javascript module.

type TemplateReference

type TemplateReference = Nullable<SerializedBlock>;

type Transaction

type Transaction = object;

type TransactionSymbol

type TransactionSymbol = typeof TransactionSymbol;

type TrustingAppendOpcode

type TrustingAppendOpcode = 2;

type TrustingComponentAttrOpcode

type TrustingComponentAttrOpcode = 23;

type TrustingDynamicAttrOpcode

type TrustingDynamicAttrOpcode = 22;

type TupleExpression

type TupleExpression = Expressions.TupleExpression;

type TupleSyntax

type TupleSyntax = Statement | TupleExpression;

type TYPE_MASK

type TYPE_MASK = 0b00000000000000000000000011111111;

type TYPE_SIZE

type TYPE_SIZE = 0b11111111;

type TypeAttr

type TypeAttr = 4;

type UnboundReference

type UnboundReference = 2;

type UndefinedOpcode

type UndefinedOpcode = 27;

type UPDATABLE_TAG_ID

type UPDATABLE_TAG_ID = 1;

type UpdateHookCapability

type UpdateHookCapability = 0b0000100000000;

type ValueAttr

type ValueAttr = 2;

type VmAppendDocumentFragment

type VmAppendDocumentFragment = 45;

type VmAppendHTML

type VmAppendHTML = 43;

type VmAppendNode

type VmAppendNode = 46;

type VmAppendSafeHTML

type VmAppendSafeHTML = 44;

type VmAppendText

type VmAppendText = 47;

type VmAssertSame

type VmAssertSame = 68;

type VmBeginComponentTransaction

type VmBeginComponentTransaction = 97;

type VmBindDynamicScope

type VmBindDynamicScope = 58;

type VmBindEvalScope

type VmBindEvalScope = 93;

type VmCaptureArgs

type VmCaptureArgs = 86;

type VmChildScope

type VmChildScope = 39;

type VmCloseElement

type VmCloseElement = 55;

type VmComment

type VmComment = 42;

type VmCommitComponentTransaction

type VmCommitComponentTransaction = 98;

type VmCompileBlock

type VmCompileBlock = 61;

type VmComponentAttr

type VmComponentAttr = 53;

type VmConcat

type VmConcat = 27;

type VmConstant

type VmConstant = 28;

type VmConstantReference

type VmConstantReference = 29;

type VmContentType

type VmContentType = 76;

type VmCreateComponent

type VmCreateComponent = 87;

type VmCurry

type VmCurry = 77;

type VmDebugger

type VmDebugger = 103;

type VmDidCreateElement

type VmDidCreateElement = 99;

type VmDidRenderLayout

type VmDidRenderLayout = 100;

type VmDup

type VmDup = 33;

type VmDynamicAttr

type VmDynamicAttr = 52;

type VmDynamicContentType

type VmDynamicContentType = 106;

type VmDynamicHelper

type VmDynamicHelper = 107;

type VmDynamicModifier

type VmDynamicModifier = 108;

type VmEnter

type VmEnter = 69;

type VmEnterList

type VmEnterList = 72;

type VmExit

type VmExit = 70;

type VmExitList

type VmExitList = 73;

type VmFetch

type VmFetch = 36;

type VmFlushElement

type VmFlushElement = 54;

type VmGetBlock

type VmGetBlock = 23;

type VmGetComponentLayout

type VmGetComponentLayout = 92;

type VmGetComponentSelf

type VmGetComponentSelf = 90;

type VmGetComponentTagName

type VmGetComponentTagName = 91;

type VmGetDynamicVar

type VmGetDynamicVar = 111;

type VmGetProperty

type VmGetProperty = 22;

type VmGetVariable

type VmGetVariable = 21;

type VmHasBlock

type VmHasBlock = 25;

type VmHasBlockParams

type VmHasBlockParams = 26;

type VmHelper

type VmHelper = 16;

type VmIfInline

type VmIfInline = 109;

type VmInvokeComponentLayout

type VmInvokeComponentLayout = 96;

type VmInvokeYield

type VmInvokeYield = 64;

type VmIterate

type VmIterate = 74;

type VmJumpEq

type VmJumpEq = 67;

type VmJumpIf

type VmJumpIf = 65;

type VmJumpUnless

type VmJumpUnless = 66;

type VmLoad

type VmLoad = 35;

type VmLog

type VmLog = 112;

type VmMachineInvokeStatic

type VmMachineInvokeStatic = 3;

type VmMachineInvokeVirtual

type VmMachineInvokeVirtual = 2;

type VmMachineJump

type VmMachineJump = 4;

type VmMachineOp

type VmMachineOp =
    | VmMachinePushFrame
    | VmMachinePopFrame
    | VmMachineInvokeVirtual
    | VmMachineInvokeStatic
    | VmMachineJump
    | VmMachineReturn
    | VmMachineReturnTo
    | VmMachineSize;

type VmMachinePopFrame

type VmMachinePopFrame = 1;

type VmMachinePushFrame

type VmMachinePushFrame = 0;

type VmMachineReturn

type VmMachineReturn = 5;

type VmMachineReturnTo

type VmMachineReturnTo = 6;

type VmMachineSize

type VmMachineSize = 7;

type VmMain

type VmMain = 75;

type VmModifier

type VmModifier = 57;

type VmNot

type VmNot = 110;

type VmOp

type VmOp =
    | VmHelper
    | VmSetNamedVariables
    | VmSetBlocks
    | VmSetVariable
    | VmSetBlock
    | VmGetVariable
    | VmGetProperty
    | VmGetBlock
    | VmSpreadBlock
    | VmHasBlock
    | VmHasBlockParams
    | VmConcat
    | VmConstant
    | VmConstantReference
    | VmPrimitive
    | VmPrimitiveReference
    | VmReifyU32
    | VmDup
    | VmPop
    | VmLoad
    | VmFetch
    | VmRootScope
    | VmVirtualRootScope
    | VmChildScope
    | VmPopScope
    | VmText
    | VmComment
    | VmAppendHTML
    | VmAppendSafeHTML
    | VmAppendDocumentFragment
    | VmAppendNode
    | VmAppendText
    | VmOpenElement
    | VmOpenDynamicElement
    | VmPushRemoteElement
    | VmStaticAttr
    | VmDynamicAttr
    | VmComponentAttr
    | VmFlushElement
    | VmCloseElement
    | VmPopRemoteElement
    | VmModifier
    | VmBindDynamicScope
    | VmPushDynamicScope
    | VmPopDynamicScope
    | VmCompileBlock
    | VmPushBlockScope
    | VmPushSymbolTable
    | VmInvokeYield
    | VmJumpIf
    | VmJumpUnless
    | VmJumpEq
    | VmAssertSame
    | VmEnter
    | VmExit
    | VmToBoolean
    | VmEnterList
    | VmExitList
    | VmIterate
    | VmMain
    | VmContentType
    | VmCurry
    | VmPushComponentDefinition
    | VmPushDynamicComponentInstance
    | VmResolveDynamicComponent
    | VmResolveCurriedComponent
    | VmPushArgs
    | VmPushEmptyArgs
    | VmPopArgs
    | VmPrepareArgs
    | VmCaptureArgs
    | VmCreateComponent
    | VmRegisterComponentDestructor
    | VmPutComponentOperations
    | VmGetComponentSelf
    | VmGetComponentTagName
    | VmGetComponentLayout
    | VmBindEvalScope
    | VmSetupForEval
    | VmPopulateLayout
    | VmInvokeComponentLayout
    | VmBeginComponentTransaction
    | VmCommitComponentTransaction
    | VmDidCreateElement
    | VmDidRenderLayout
    | VmResolveMaybeLocal
    | VmDebugger
    | VmSize
    | VmStaticComponentAttr
    | VmDynamicContentType
    | VmDynamicHelper
    | VmDynamicModifier
    | VmIfInline
    | VmNot
    | VmGetDynamicVar
    | VmLog;

type VmOpenDynamicElement

type VmOpenDynamicElement = 49;

type VmOpenElement

type VmOpenElement = 48;

type VmPop

type VmPop = 34;

type VmPopArgs

type VmPopArgs = 84;

type VmPopDynamicScope

type VmPopDynamicScope = 60;

type VmPopRemoteElement

type VmPopRemoteElement = 56;

type VmPopScope

type VmPopScope = 40;

type VmPopulateLayout

type VmPopulateLayout = 95;

type VmPrepareArgs

type VmPrepareArgs = 85;

type VmPrimitive

type VmPrimitive = 30;

type VmPrimitiveReference

type VmPrimitiveReference = 31;

type VmPushArgs

type VmPushArgs = 82;

type VmPushBlockScope

type VmPushBlockScope = 62;

type VmPushComponentDefinition

type VmPushComponentDefinition = 78;

type VmPushDynamicComponentInstance

type VmPushDynamicComponentInstance = 79;

type VmPushDynamicScope

type VmPushDynamicScope = 59;

type VmPushEmptyArgs

type VmPushEmptyArgs = 83;

type VmPushRemoteElement

type VmPushRemoteElement = 50;

type VmPushSymbolTable

type VmPushSymbolTable = 63;

type VmPutComponentOperations

type VmPutComponentOperations = 89;

type VmRegisterComponentDestructor

type VmRegisterComponentDestructor = 88;

type VmReifyU32

type VmReifyU32 = 32;

type VmResolveCurriedComponent

type VmResolveCurriedComponent = 81;

type VmResolveDynamicComponent

type VmResolveDynamicComponent = 80;

type VmResolveMaybeLocal

type VmResolveMaybeLocal = 102;

type VmRootScope

type VmRootScope = 37;

type VmSetBlock

type VmSetBlock = 20;

type VmSetBlocks

type VmSetBlocks = 18;

type VmSetNamedVariables

type VmSetNamedVariables = 17;

type VmSetupForEval

type VmSetupForEval = 94;

type VmSetVariable

type VmSetVariable = 19;

type VmSize

type VmSize = 104;

type VmSpreadBlock

type VmSpreadBlock = 24;

type VmStaticAttr

type VmStaticAttr = 51;

type VmStaticComponentAttr

type VmStaticComponentAttr = 105;

type VmText

type VmText = 41;

type VmToBoolean

type VmToBoolean = 71;

type VmVirtualRootScope

type VmVirtualRootScope = 38;

type VOLATILE_TAG_ID

type VOLATILE_TAG_ID = 100;

type WellKnownAttrName

type WellKnownAttrName =
    | ClassAttr
    | IdAttr
    | ValueAttr
    | NameAttr
    | TypeAttr
    | StyleAttr
    | HrefAttr;

type WellKnownTagName

type WellKnownTagName = DivTag | SpanTag | PTag | ATag;

type WillDestroyCapability

type WillDestroyCapability = 0b0100000000000;

type WithDynamicVarsOpcode

type WithDynamicVarsOpcode = 45;

type WrappedCapability

type WrappedCapability = 0b0010000000000;

type YieldOpcode

type YieldOpcode = 18;

type YieldTo

type YieldTo = number;

Namespaces

namespace Core

namespace Core {}

type Args

type Args = [Params, Hash];

type Blocks

type Blocks = Nullable<[string[], SerializedInlineBlock[]]>;

type CallArgs

type CallArgs = [Params, Hash];

type ConcatParams

type ConcatParams = PresentArray<Expression>;

type DebugInfo

type DebugInfo = number[];

type ElementParameters

type ElementParameters = Nullable<PresentArray<ElementParameter>>;

type Expression

type Expression = Expressions.Expression;

type Hash

type Hash = Nullable<[PresentArray<string>, PresentArray<Expression>]>;

type NamedBlock

type NamedBlock = [string, SerializedInlineBlock];

type Params

type Params = Nullable<ConcatParams>;

type Path

type Path = [string, ...string[]];

type Syntax

type Syntax = Path | Params | ConcatParams | Hash | Blocks | Args | DebugInfo;

namespace Expressions

namespace Expressions {}

type BooleanValue

type BooleanValue = boolean;

type Concat

type Concat = [ConcatOpcode, Core.ConcatParams];

type Curry

type Curry = [CurryOpcode, Expression, CurriedType, Params, Hash];

type Expression

type Expression = TupleExpression | Value | undefined;

type Get

type Get = GetVar | GetPath;

type GetContextualFree

type GetContextualFree =
    | GetFreeAsComponentOrHelperHead
    | GetFreeAsHelperHead
    | GetFreeAsModifierHead
    | GetFreeAsComponentHead;

type GetDynamicVar

type GetDynamicVar = [op: GetDynamicVarOpcode, value: Expression];

type GetFree

type GetFree = GetStrictFree | GetContextualFree;

type GetFreeAsComponentHead

type GetFreeAsComponentHead = [GetFreeAsComponentHeadOpcode, number];

type GetFreeAsComponentOrHelperHead

type GetFreeAsComponentOrHelperHead = [GetFreeAsComponentOrHelperHeadOpcode, number];

type GetFreeAsHelperHead

type GetFreeAsHelperHead = [GetFreeAsHelperHeadOpcode, number];

type GetFreeAsModifierHead

type GetFreeAsModifierHead = [GetFreeAsModifierHeadOpcode, number];

type GetLexicalSymbol

type GetLexicalSymbol = [GetLexicalSymbolOpcode, number];

type GetPath

type GetPath = GetPathSymbol | GetPathTemplateSymbol | GetPathContextualFree;

type GetPathContextualFree

type GetPathContextualFree =
    | GetPathFreeAsComponentOrHelperHead
    | GetPathFreeAsHelperHead
    | GetPathFreeAsModifierHead
    | GetPathFreeAsComponentHead;

type GetPathFreeAsComponentHead

type GetPathFreeAsComponentHead = [GetFreeAsComponentHeadOpcode, number, Path];

type GetPathFreeAsComponentOrHelperHead

type GetPathFreeAsComponentOrHelperHead = [
    GetFreeAsComponentOrHelperHeadOpcode,
    number,
    Path
];

type GetPathFreeAsHelperHead

type GetPathFreeAsHelperHead = [GetFreeAsHelperHeadOpcode, number, Path];

type GetPathFreeAsModifierHead

type GetPathFreeAsModifierHead = [GetFreeAsModifierHeadOpcode, number, Path];

type GetPathSymbol

type GetPathSymbol = [GetSymbolOpcode, number, Path];

type GetPathTemplateSymbol

type GetPathTemplateSymbol = [GetLexicalSymbolOpcode, number, Path];

type GetStrictFree

type GetStrictFree = [GetStrictKeywordOpcode, number];

type GetSymbol

type GetSymbol = [GetSymbolOpcode, number];

type GetVar

type GetVar = GetSymbol | GetLexicalSymbol | GetFree;

type HasBlock

type HasBlock = [HasBlockOpcode, Expression];

type HasBlockParams

type HasBlockParams = [HasBlockParamsOpcode, Expression];

type Hash

type Hash = Core.Hash;

type Helper

type Helper = [CallOpcode, Expression, Nullable<Params>, Hash];

type IfInline

type IfInline = [
    op: IfInlineOpcode,
    condition: Expression,
    truthyValue: Expression,
    falsyValue?: Nullable<Expression>
];

type Log

type Log = [op: LogOpcode, positional: Params];

type Not

type Not = [op: NotOpcode, value: Expression];

type NullValue

type NullValue = null;

type NumberValue

type NumberValue = number;

type Params

type Params = Core.Params;

type Path

type Path = Core.Path;

type StringValue

type StringValue = string;

type TupleExpression

type TupleExpression =
    | Get
    | GetDynamicVar
    | Concat
    | HasBlock
    | HasBlockParams
    | Curry
    | Helper
    | Undefined
    | IfInline
    | Not
    | Log;

type Undefined

type Undefined = [UndefinedOpcode];

type Value

type Value = StringValue | NumberValue | BooleanValue | NullValue;

namespace Statements

namespace Statements {}

type AnyDynamicAttr

type AnyDynamicAttr =
    | DynamicAttr
    | ComponentAttr
    | TrustingDynamicAttr
    | TrustingComponentAttr;

type AnyStaticAttr

type AnyStaticAttr = StaticAttr | StaticComponentAttr;

type Append

type Append = [AppendOpcode, Expression];

type Argument

type Argument = StaticArg | DynamicArg;

type Attr

type Attr<Op extends AttrOpcode> = [
    op: Op,
    name: string | WellKnownAttrName,
    value: Expression,
    namespace?: string | undefined
];

type Attribute

type Attribute =
    | StaticAttr
    | StaticComponentAttr
    | DynamicAttr
    | TrustingDynamicAttr
    | ComponentAttr
    | TrustingComponentAttr;

type AttrSplat

type AttrSplat = [AttrSplatOpcode, YieldTo];

type Block

type Block = [BlockOpcode, Expression, Params, Hash, Blocks];

type Blocks

type Blocks = Core.Blocks;

type CloseElement

type CloseElement = [CloseElementOpcode];

type Comment

type Comment = [CommentOpcode, string];

type Component

type Component = [
    op: ComponentOpcode,
    tag: Expression,
    parameters: Core.ElementParameters,
    args: Hash,
    blocks: Blocks
];

type ComponentAttr

type ComponentAttr = Attr<ComponentAttrOpcode>;

type ComponentFeature

type ComponentFeature = Modifier | AttrSplat;

type Debugger

type Debugger = [DebuggerOpcode, Core.DebugInfo];

type DynamicArg

type DynamicArg = [DynamicArgOpcode, string, Expression];

type DynamicAttr

type DynamicAttr = Attr<DynamicAttrOpcode>;

type Each

type Each = [
    op: EachOpcode,
    condition: Expression,
    key: Nullable<Expression>,
    block: SerializedInlineBlock,
    inverse: Nullable<SerializedInlineBlock>
];

type ElementParameter

type ElementParameter = Attribute | Argument | ComponentFeature;

type Expression

type Expression = Expressions.Expression | undefined;

type FlushElement

type FlushElement = [FlushElementOpcode];

type Hash

type Hash = Core.Hash;

type If

type If = [
    op: IfOpcode,
    condition: Expression,
    block: SerializedInlineBlock,
    inverse: Nullable<SerializedInlineBlock>
];

type InElement

type InElement = [
    op: InElementOpcode,
    block: SerializedInlineBlock,
    guid: string,
    destination: Expression,
    insertBefore?: Expression
];

type InvokeComponent

type InvokeComponent = [
    op: InvokeComponentOpcode,
    definition: Expression,
    positional: Core.Params,
    named: Core.Hash,
    blocks: Blocks | null
];

type Let

type Let = [op: LetOpcode, positional: Core.Params, block: SerializedInlineBlock];

type Modifier

type Modifier = [ModifierOpcode, Expression, Params, Hash];

type OpenElement

type OpenElement = [OpenElementOpcode, string | WellKnownTagName];

type OpenElementWithSplat

type OpenElementWithSplat = [OpenElementWithSplatOpcode, string | WellKnownTagName];

type Params

type Params = Core.Params;

type Path

type Path = Core.Path;

type Statement

type Statement =
    | Append
    | TrustingAppend
    | Comment
    | Modifier
    | Block
    | Component
    | OpenElement
    | OpenElementWithSplat
    | FlushElement
    | CloseElement
    | Attribute
    | AttrSplat
    | Yield
    | StaticArg
    | DynamicArg
    | Debugger
    | InElement
    | If
    | Each
    | Let
    | WithDynamicVars
    | InvokeComponent;

A Handlebars statement

type StaticArg

type StaticArg = [StaticArgOpcode, string, Expression];

type StaticAttr

type StaticAttr = Attr<StaticAttrOpcode>;

type StaticComponentAttr

type StaticComponentAttr = Attr<StaticComponentAttrOpcode>;

type TrustingAppend

type TrustingAppend = [TrustingAppendOpcode, Expression];

type TrustingComponentAttr

type TrustingComponentAttr = Attr<TrustingComponentAttrOpcode>;

type TrustingDynamicAttr

type TrustingDynamicAttr = Attr<TrustingDynamicAttrOpcode>;

type WithDynamicVars

type WithDynamicVars = [
    op: WithDynamicVarsOpcode,
    args: Core.Hash,
    block: SerializedInlineBlock
];

type Yield

type Yield = [YieldOpcode, YieldTo, Nullable<Params>];

namespace WireFormat

module 'lib/compile/wire-format/api.d.ts' {}

A Handlebars statement

interface SerializedTemplate

interface SerializedTemplate {}

A JSON object that the compiled Template was serialized into.

property block

block: SerializedTemplateBlock;

property id

id?: Nullable<string>;

property moduleName

moduleName: string;

interface SerializedTemplateWithLazyBlock

interface SerializedTemplateWithLazyBlock {}

A JSON object containing the SerializedTemplateBlock as JSON and TemplateMeta.

property block

block: SerializedTemplateBlockJSON;

property id

id?: Nullable<string>;

property isStrictMode

isStrictMode: boolean;

property moduleName

moduleName: string;

property scope

scope?: (() => unknown[]) | undefined | null;

interface SexpOpcodeMap

interface SexpOpcodeMap extends ExpressionSexpOpcodeMap, StatementSexpOpcodeMap {}

type AppendOpcode

type AppendOpcode = 1;

type Argument

type Argument = Statements.Argument;

type ATag

type ATag = 3;

type Attribute

type Attribute = Statements.Attribute;

type AttrOpcode

type AttrOpcode =
    | StaticAttrOpcode
    | StaticComponentAttrOpcode
    | DynamicAttrOpcode
    | TrustingDynamicAttrOpcode
    | ComponentAttrOpcode
    | TrustingComponentAttrOpcode;

type AttrSplatOpcode

type AttrSplatOpcode = 17;

type BlockOpcode

type BlockOpcode = 6;

type CallOpcode

type CallOpcode = 28;

type ClassAttr

type ClassAttr = 0;

type CloseElementOpcode

type CloseElementOpcode = 13;

type CommentOpcode

type CommentOpcode = 3;

type ComponentAttrOpcode

type ComponentAttrOpcode = 16;

type ComponentOpcode

type ComponentOpcode = 8;

type ConcatOpcode

type ConcatOpcode = 29;

type CoreSyntax

type CoreSyntax = Core.Syntax;

type CurryOpcode

type CurryOpcode = 50;

type DebuggerOpcode

type DebuggerOpcode = 26;

type DivTag

type DivTag = 0;

type DynamicArgOpcode

type DynamicArgOpcode = 20;

type DynamicAttrOpcode

type DynamicAttrOpcode = 15;

type EachOpcode

type EachOpcode = 42;

type ElementParameter

type ElementParameter = Statements.ElementParameter;

type Expression

type Expression = Expressions.Expression;

type ExpressionSexpOpcode

type ExpressionSexpOpcode = TupleExpression[0];

type ExpressionSexpOpcodeMap

type ExpressionSexpOpcodeMap = {
    [TSexpOpcode in TupleExpression[0]]: Extract<
        TupleExpression,
        { 0: TSexpOpcode }
    >;
};

type FlushElementOpcode

type FlushElementOpcode = 12;

type Get

type Get = Expressions.GetVar;

type GetContextualFreeOpcode

type GetContextualFreeOpcode =
    | GetFreeAsComponentOrHelperHeadOpcode
    | GetFreeAsHelperHeadOpcode
    | GetFreeAsModifierHeadOpcode
    | GetFreeAsComponentHeadOpcode
    | GetStrictKeywordOpcode;

type GetDynamicVarOpcode

type GetDynamicVarOpcode = 53;

type GetEndOpcode

type GetEndOpcode = GetFreeAsComponentHeadOpcode;

type GetFreeAsComponentHeadOpcode

type GetFreeAsComponentHeadOpcode = 39;

type GetFreeAsComponentOrHelperHeadOpcode

type GetFreeAsComponentOrHelperHeadOpcode = 35;

type GetFreeAsHelperHeadOpcode

type GetFreeAsHelperHeadOpcode = 37;

type GetFreeAsModifierHeadOpcode

type GetFreeAsModifierHeadOpcode = 38;

type GetLexicalSymbolOpcode

type GetLexicalSymbolOpcode = 32;

type GetLooseFreeEndOpcode

type GetLooseFreeEndOpcode = GetFreeAsComponentHeadOpcode;

type GetStartOpcode

type GetStartOpcode = GetSymbolOpcode;

type GetStrictKeywordOpcode

type GetStrictKeywordOpcode = 31;

type GetSymbolOpcode

type GetSymbolOpcode = 30;

type HasBlockOpcode

type HasBlockOpcode = 48;

type HasBlockParamsOpcode

type HasBlockParamsOpcode = 49;

type HrefAttr

type HrefAttr = 6;

type IdAttr

type IdAttr = 1;

type IfInlineOpcode

type IfInlineOpcode = 52;

type IfOpcode

type IfOpcode = 41;

type InElementOpcode

type InElementOpcode = 40;

type InvokeComponentOpcode

type InvokeComponentOpcode = 46;

type LetOpcode

type LetOpcode = 44;

type LogOpcode

type LogOpcode = 54;

type ModifierOpcode

type ModifierOpcode = 4;

type NameAttr

type NameAttr = 3;

type NotOpcode

type NotOpcode = 51;

type OpenElementOpcode

type OpenElementOpcode = 10;

type OpenElementWithSplatOpcode

type OpenElementWithSplatOpcode = 11;

type PTag

type PTag = 2;

type ResolveAsComponentHeadResolution

type ResolveAsComponentHeadResolution = 7;

type ResolveAsComponentOrHelperHeadResolution

type ResolveAsComponentOrHelperHeadResolution = 1;

type ResolveAsHelperHeadResolution

type ResolveAsHelperHeadResolution = 5;

type ResolveAsModifierHeadResolution

type ResolveAsModifierHeadResolution = 6;

type SerializedBlock

type SerializedBlock = [statements: Statements.Statement[]];

A JSON object that the Block was serialized into.

type SerializedInlineBlock

type SerializedInlineBlock = [
    statements: Statements.Statement[],
    parameters: number[]
];

type SerializedTemplateBlock

type SerializedTemplateBlock = [
    // statements
    Statements.Statement[],
    // symbols
    string[],
    // hasDebug
    boolean,
    // upvars
    string[]
];

A JSON object that the compiled TemplateBlock was serialized into.

type SerializedTemplateBlockJSON

type SerializedTemplateBlockJSON = string;

A string of JSON containing a SerializedTemplateBlock

type SexpOpcode

type SexpOpcode = keyof SexpOpcodeMap;

type SexpSyntax

type SexpSyntax = Statement | TupleExpression;

type SpanTag

type SpanTag = 1;

type Statement

type Statement = Statements.Statement;

A Handlebars statement

type StatementSexpOpcode

type StatementSexpOpcode = Statement[0];

type StatementSexpOpcodeMap

type StatementSexpOpcodeMap = {
    [TSexpOpcode in Statement[0]]: Extract<Statement, { 0: TSexpOpcode }>;
};

type StaticArgOpcode

type StaticArgOpcode = 21;

type StaticAttrOpcode

type StaticAttrOpcode = 14;

type StaticComponentAttrOpcode

type StaticComponentAttrOpcode = 24;

type StrictBlockOpcode

type StrictBlockOpcode = 7;

type StrictModifierOpcode

type StrictModifierOpcode = 5;

type StrictResolution

type StrictResolution = 0;

A VariableResolutionContext explains how a variable name should be resolved.

type StyleAttr

type StyleAttr = 5;

type Syntax

type Syntax = SexpSyntax | Expressions.Value | undefined;

type SyntaxWithInternal

type SyntaxWithInternal =
    | Syntax
    | CoreSyntax
    | SerializedTemplateBlock
    | Core.CallArgs
    | Core.NamedBlock
    | Core.ElementParameters;

type TemplateJavascript

type TemplateJavascript = string;

A string of Javascript containing a SerializedTemplateWithLazyBlock to be concatenated into a Javascript module.

type TemplateReference

type TemplateReference = Nullable<SerializedBlock>;

type TrustingAppendOpcode

type TrustingAppendOpcode = 2;

type TrustingComponentAttrOpcode

type TrustingComponentAttrOpcode = 23;

type TrustingDynamicAttrOpcode

type TrustingDynamicAttrOpcode = 22;

type TupleExpression

type TupleExpression = Expressions.TupleExpression;

type TupleSyntax

type TupleSyntax = Statement | TupleExpression;

type TypeAttr

type TypeAttr = 4;

type UndefinedOpcode

type UndefinedOpcode = 27;

type ValueAttr

type ValueAttr = 2;

type WellKnownAttrName

type WellKnownAttrName =
    | ClassAttr
    | IdAttr
    | ValueAttr
    | NameAttr
    | TypeAttr
    | StyleAttr
    | HrefAttr;

type WellKnownTagName

type WellKnownTagName = DivTag | SpanTag | PTag | ATag;

type WithDynamicVarsOpcode

type WithDynamicVarsOpcode = 45;

type YieldOpcode

type YieldOpcode = 18;

type YieldTo

type YieldTo = number;

namespace WireFormat.Core

namespace WireFormat.Core {}

type Args

type Args = [Params, Hash];

type Blocks

type Blocks = Nullable<[string[], SerializedInlineBlock[]]>;

type CallArgs

type CallArgs = [Params, Hash];

type ConcatParams

type ConcatParams = PresentArray<Expression>;

type DebugInfo

type DebugInfo = number[];

type ElementParameters

type ElementParameters = Nullable<PresentArray<ElementParameter>>;

type Expression

type Expression = Expressions.Expression;

type Hash

type Hash = Nullable<[PresentArray<string>, PresentArray<Expression>]>;

type NamedBlock

type NamedBlock = [string, SerializedInlineBlock];

type Params

type Params = Nullable<ConcatParams>;

type Path

type Path = [string, ...string[]];

type Syntax

type Syntax = Path | Params | ConcatParams | Hash | Blocks | Args | DebugInfo;

namespace WireFormat.Expressions

namespace WireFormat.Expressions {}

type BooleanValue

type BooleanValue = boolean;

type Concat

type Concat = [ConcatOpcode, Core.ConcatParams];

type Curry

type Curry = [CurryOpcode, Expression, CurriedType, Params, Hash];

type Expression

type Expression = TupleExpression | Value | undefined;

type Get

type Get = GetVar | GetPath;

type GetContextualFree

type GetContextualFree =
    | GetFreeAsComponentOrHelperHead
    | GetFreeAsHelperHead
    | GetFreeAsModifierHead
    | GetFreeAsComponentHead;

type GetDynamicVar

type GetDynamicVar = [op: GetDynamicVarOpcode, value: Expression];

type GetFree

type GetFree = GetStrictFree | GetContextualFree;

type GetFreeAsComponentHead

type GetFreeAsComponentHead = [GetFreeAsComponentHeadOpcode, number];

type GetFreeAsComponentOrHelperHead

type GetFreeAsComponentOrHelperHead = [GetFreeAsComponentOrHelperHeadOpcode, number];

type GetFreeAsHelperHead

type GetFreeAsHelperHead = [GetFreeAsHelperHeadOpcode, number];

type GetFreeAsModifierHead

type GetFreeAsModifierHead = [GetFreeAsModifierHeadOpcode, number];

type GetLexicalSymbol

type GetLexicalSymbol = [GetLexicalSymbolOpcode, number];

type GetPath

type GetPath = GetPathSymbol | GetPathTemplateSymbol | GetPathContextualFree;

type GetPathContextualFree

type GetPathContextualFree =
    | GetPathFreeAsComponentOrHelperHead
    | GetPathFreeAsHelperHead
    | GetPathFreeAsModifierHead
    | GetPathFreeAsComponentHead;

type GetPathFreeAsComponentHead

type GetPathFreeAsComponentHead = [GetFreeAsComponentHeadOpcode, number, Path];

type GetPathFreeAsComponentOrHelperHead

type GetPathFreeAsComponentOrHelperHead = [
    GetFreeAsComponentOrHelperHeadOpcode,
    number,
    Path
];

type GetPathFreeAsHelperHead

type GetPathFreeAsHelperHead = [GetFreeAsHelperHeadOpcode, number, Path];

type GetPathFreeAsModifierHead

type GetPathFreeAsModifierHead = [GetFreeAsModifierHeadOpcode, number, Path];

type GetPathSymbol

type GetPathSymbol = [GetSymbolOpcode, number, Path];

type GetPathTemplateSymbol

type GetPathTemplateSymbol = [GetLexicalSymbolOpcode, number, Path];

type GetStrictFree

type GetStrictFree = [GetStrictKeywordOpcode, number];

type GetSymbol

type GetSymbol = [GetSymbolOpcode, number];

type GetVar

type GetVar = GetSymbol | GetLexicalSymbol | GetFree;

type HasBlock

type HasBlock = [HasBlockOpcode, Expression];

type HasBlockParams

type HasBlockParams = [HasBlockParamsOpcode, Expression];

type Hash

type Hash = Core.Hash;

type Helper

type Helper = [CallOpcode, Expression, Nullable<Params>, Hash];

type IfInline

type IfInline = [
    op: IfInlineOpcode,
    condition: Expression,
    truthyValue: Expression,
    falsyValue?: Nullable<Expression>
];

type Log

type Log = [op: LogOpcode, positional: Params];

type Not

type Not = [op: NotOpcode, value: Expression];

type NullValue

type NullValue = null;

type NumberValue

type NumberValue = number;

type Params

type Params = Core.Params;

type Path

type Path = Core.Path;

type StringValue

type StringValue = string;

type TupleExpression

type TupleExpression =
    | Get
    | GetDynamicVar
    | Concat
    | HasBlock
    | HasBlockParams
    | Curry
    | Helper
    | Undefined
    | IfInline
    | Not
    | Log;

type Undefined

type Undefined = [UndefinedOpcode];

type Value

type Value = StringValue | NumberValue | BooleanValue | NullValue;

namespace WireFormat.Statements

namespace WireFormat.Statements {}

type AnyDynamicAttr

type AnyDynamicAttr =
    | DynamicAttr
    | ComponentAttr
    | TrustingDynamicAttr
    | TrustingComponentAttr;

type AnyStaticAttr

type AnyStaticAttr = StaticAttr | StaticComponentAttr;

type Append

type Append = [AppendOpcode, Expression];

type Argument

type Argument = StaticArg | DynamicArg;

type Attr

type Attr<Op extends AttrOpcode> = [
    op: Op,
    name: string | WellKnownAttrName,
    value: Expression,
    namespace?: string | undefined
];

type Attribute

type Attribute =
    | StaticAttr
    | StaticComponentAttr
    | DynamicAttr
    | TrustingDynamicAttr
    | ComponentAttr
    | TrustingComponentAttr;

type AttrSplat

type AttrSplat = [AttrSplatOpcode, YieldTo];

type Block

type Block = [BlockOpcode, Expression, Params, Hash, Blocks];

type Blocks

type Blocks = Core.Blocks;

type CloseElement

type CloseElement = [CloseElementOpcode];

type Comment

type Comment = [CommentOpcode, string];

type Component

type Component = [
    op: ComponentOpcode,
    tag: Expression,
    parameters: Core.ElementParameters,
    args: Hash,
    blocks: Blocks
];

type ComponentAttr

type ComponentAttr = Attr<ComponentAttrOpcode>;

type ComponentFeature

type ComponentFeature = Modifier | AttrSplat;

type Debugger

type Debugger = [DebuggerOpcode, Core.DebugInfo];

type DynamicArg

type DynamicArg = [DynamicArgOpcode, string, Expression];

type DynamicAttr

type DynamicAttr = Attr<DynamicAttrOpcode>;

type Each

type Each = [
    op: EachOpcode,
    condition: Expression,
    key: Nullable<Expression>,
    block: SerializedInlineBlock,
    inverse: Nullable<SerializedInlineBlock>
];

type ElementParameter

type ElementParameter = Attribute | Argument | ComponentFeature;

type Expression

type Expression = Expressions.Expression | undefined;

type FlushElement

type FlushElement = [FlushElementOpcode];

type Hash

type Hash = Core.Hash;

type If

type If = [
    op: IfOpcode,
    condition: Expression,
    block: SerializedInlineBlock,
    inverse: Nullable<SerializedInlineBlock>
];

type InElement

type InElement = [
    op: InElementOpcode,
    block: SerializedInlineBlock,
    guid: string,
    destination: Expression,
    insertBefore?: Expression
];

type InvokeComponent

type InvokeComponent = [
    op: InvokeComponentOpcode,
    definition: Expression,
    positional: Core.Params,
    named: Core.Hash,
    blocks: Blocks | null
];

type Let

type Let = [op: LetOpcode, positional: Core.Params, block: SerializedInlineBlock];

type Modifier

type Modifier = [ModifierOpcode, Expression, Params, Hash];

type OpenElement

type OpenElement = [OpenElementOpcode, string | WellKnownTagName];

type OpenElementWithSplat

type OpenElementWithSplat = [OpenElementWithSplatOpcode, string | WellKnownTagName];

type Params

type Params = Core.Params;

type Path

type Path = Core.Path;

type Statement

type Statement =
    | Append
    | TrustingAppend
    | Comment
    | Modifier
    | Block
    | Component
    | OpenElement
    | OpenElementWithSplat
    | FlushElement
    | CloseElement
    | Attribute
    | AttrSplat
    | Yield
    | StaticArg
    | DynamicArg
    | Debugger
    | InElement
    | If
    | Each
    | Let
    | WithDynamicVars
    | InvokeComponent;

A Handlebars statement

type StaticArg

type StaticArg = [StaticArgOpcode, string, Expression];

type StaticAttr

type StaticAttr = Attr<StaticAttrOpcode>;

type StaticComponentAttr

type StaticComponentAttr = Attr<StaticComponentAttrOpcode>;

type TrustingAppend

type TrustingAppend = [TrustingAppendOpcode, Expression];

type TrustingComponentAttr

type TrustingComponentAttr = Attr<TrustingComponentAttrOpcode>;

type TrustingDynamicAttr

type TrustingDynamicAttr = Attr<TrustingDynamicAttrOpcode>;

type WithDynamicVars

type WithDynamicVars = [
    op: WithDynamicVarsOpcode,
    args: Core.Hash,
    block: SerializedInlineBlock
];

type Yield

type Yield = [YieldOpcode, YieldTo, Nullable<Params>];

Package Files (43)

Dependencies (1)

@simple-dom/interface

Dev Dependencies (5)

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/interfaces.

Markdown

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

HTML

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

Updated 11 days ago.
Package analyzed in 9056 ms.
Missing or incorrect documentation? Open an issue for this package.