New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →

@aurelia/runtime

Package Overview

Dependencies

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

@aurelia/runtime - npm Package Compare versions

Comparing version 0.2.0 to 0.3.0-dev.20181013

dist/binding/connectable.d.ts

dist/binding/connectable.d.ts.map

dist/binding/interfaces.d.ts

dist/binding/interfaces.d.ts.map

dist/binding/interpolation-binding.d.ts

dist/binding/interpolation-binding.d.ts.map

dist/templating/resources/composition-coordinator.d.ts

dist/templating/resources/composition-coordinator.d.ts.map

src/aurelia.ts

src/binding/array-observer.ts

src/binding/ast.ts

src/binding/binding-behavior.ts

src/binding/binding-context.ts

src/binding/binding-flags.ts

src/binding/binding-mode.ts

src/binding/binding.ts

src/binding/call.ts

src/binding/change-set.ts

src/binding/collection-observer.ts

src/binding/computed-observer.ts

src/binding/connectable.ts

src/binding/dirty-checker.ts

src/binding/element-observation.ts

src/binding/event-manager.ts

src/binding/expression-parser.ts

src/binding/index.ts

src/binding/interfaces.ts

src/binding/interpolation-binding.ts

src/binding/let-binding.ts

src/binding/listener.ts

src/binding/map-observer.ts

src/binding/observation.ts

src/binding/observer-locator.ts

src/binding/property-observation.ts

src/binding/property-observer.ts

src/binding/ref.ts

src/binding/resources/attr-binding-behavior.ts

src/binding/resources/binding-mode-behaviors.ts

src/binding/resources/debounce-binding-behavior.ts

src/binding/resources/index.ts

src/binding/resources/sanitize.ts

src/binding/resources/self-binding-behavior.ts

src/binding/resources/signals.ts

src/binding/resources/throttle-binding-behavior.ts

src/binding/resources/update-trigger-binding-behavior.ts

src/binding/set-observer.ts

src/binding/signaler.ts

src/binding/subscriber-collection.ts

src/binding/svg-analyzer.ts

src/binding/target-accessors.ts

src/binding/target-observer.ts

src/binding/value-converter.ts

src/dom.ts

src/index.ts

src/resource.ts

src/templating/bindable.ts

src/templating/create-element.ts

src/templating/custom-attribute.ts

src/templating/custom-element.ts

src/templating/index.ts

src/templating/instructions.ts

src/templating/lifecycle.ts

src/templating/render-context.ts

src/templating/render-strategy.ts

src/templating/renderable.ts

src/templating/renderer.ts

src/templating/rendering-engine.ts

src/templating/resources/compose.ts

src/templating/resources/composition-coordinator.ts

src/templating/resources/if.ts

src/templating/resources/index.ts

src/templating/resources/repeat.ts

src/templating/resources/replaceable.ts

src/templating/resources/with.ts

src/templating/runtime-behavior.ts

src/templating/template-compiler.ts

src/templating/template.ts

src/templating/view-compile-flags.ts

src/templating/view.ts

334

CHANGELOG.md

		@@ -6,25 +6,327 @@ # Change Log

		<a name="0.3.0"></a>
		# 0.3.0 (2018-10-12)

		### Features:

		* binding: improve AST $kind classifying and other small tweaks/fixes (#213) ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* ast: add additional $kind classifications and eager initialize literals if they are pure ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* all: implement InterpolationBinding ([1e804a0](https://github.com/aurelia/aurelia/commit/1e804a0))
		* binding-context: improve error reporting ([1e804a0](https://github.com/aurelia/aurelia/commit/1e804a0))
		* kernel: add decoratable interface to support strongly typed decorators ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* binding: add @connectable decorator back in (strongly typed) ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* all: implement InterpolationBinding ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* unparser: implement interpolation unparsing ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* kernel: add unwrap interface ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* ast: add visitor interface and implement accept methods on AST ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* expression-parser: allow member expressions on numeric literals ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* potential-renderable: autodetect when build is required ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* render-context: throw more informative errors when the context is not prepared yet ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* Aurelia: self register to container ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* lifecycle: new callbacks, async tasks, and updated template controllers (#171) ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: minimal add/remove of nodes ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: enable detach tasks ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: enable attach tasks ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: stub out lifecycle flags ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: introduce child lifecycles ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: make detach/attach lifecycle symetric ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: add flags ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: overhaul ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: auto unbind after node removal ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: introduce lifecycle task ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* template-compiler: handle semicolon-separated bindings in attributes ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* jit: decouple attribute/element parsing from template compiler ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: add initial implementation of semantic model ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* renderer: throw specific error codes on target/instruction count mismatch ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* expression-parser: map empty attribute value to empty string for bound properties ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))


		### Bug Fixes:

		* subscriber-collection: remove circular dependency ([c3e3779](https://github.com/aurelia/aurelia/commit/c3e3779))
		* ast: do not eager initialize pure literals ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* ast: fix a few issues with $kind and define static properties last ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* self-binding-behavior: fix event.path and type defs ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* expression-parser: fix differentation for caching of expressions/interpolations ([1e804a0](https://github.com/aurelia/aurelia/commit/1e804a0))
		* iterator-binding: correctly compile and render ForOfStatement ([1e804a0](https://github.com/aurelia/aurelia/commit/1e804a0))
		* signaler: make addSignalListener idempotent ([1e804a0](https://github.com/aurelia/aurelia/commit/1e804a0))
		* kernel: fix decorated interface ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* binding: wrap updatetarget/updatesource so vCurrent BBs work again ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* expression-parser: fix differentation for caching of expressions/interpolations ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* iterator-binding: correctly compile and render ForOfStatement ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* SelectObserver: complete implementation, adjust tests ([ffdf01d](https://github.com/aurelia/aurelia/commit/ffdf01d))
		* SelectObserver: simplify flow, remove debugger, add test ([ffdf01d](https://github.com/aurelia/aurelia/commit/ffdf01d))
		* debug: correct / update unparser and debug mode ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* expression-parser: fix parsing error with trailing elision ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* expression-parser: allow AccessThis as the last element of an array ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* expression-parser: allow AccessThis as the condition in a conditional ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* expression-parser: allow AccessThis as left-hand side of binary expressions ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* expression-parser: reset access after parsing non-identifiers ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* unparser: explicitly reconstruct precedence ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* repeat: properly hook into attach/detach lifecycles ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* repeat: synchronously bind child views ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* repeat: use the correct lifecycle api for attach/detach ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* lifecycle: fix task variable shadowing issue ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* view: check nextSibling instead of previousSibling in mount() ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* view: validate renderLocation and ensure $nodes.lastChild exists on mount ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* RuntimeCompilationResources: do not auto register ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* Observer: use identity instead of noop ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* test: remove .only ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* CustomElement: flush at startup ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* CustomElement: remove unnecessary flush ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* Observer: revert to noop ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* Renderer: remove unnecessary checks ([5971d36](https://github.com/aurelia/aurelia/commit/5971d36))
		* lifecycle: remove unused code ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* lifecycle: improve types and resolve style issues ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* runtime: fix template controller tests ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* runtime: get remaining tests working again ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* template-compiler: make non-bindable customElement instructions siblings of the element instruction ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: properly resolve bindable customElement instructions by the registered attribute name ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* scope: add bindingContext to overrideContext ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* binding: lazy initialize slotNames based on need ([57c07e8](https://github.com/aurelia/aurelia/commit/57c07e8))
		* observation: make property-accessor synchronous ([57c07e8](https://github.com/aurelia/aurelia/commit/57c07e8))
		* observation: keep dom target accessors batched ([57c07e8](https://github.com/aurelia/aurelia/commit/57c07e8))
		* resources: ensure null is returned for non-existing resources ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))
		* template-compiler: correct a few edge cases in target and bindingMode resolution ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))
		* template-compiler: correct handling of kebab-cased custom attributes ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))
		* repeat.for: add missing instruction properties ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))


		### Performance Improvements:

		* ast: predefine keyword literals and AccessThis, and reuse them ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* expression-parser: remove unreachable branch ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* expression-parser: use explicit numeric comparisons for bitwise operators ([197235c](https://github.com/aurelia/aurelia/commit/197235c))
		* repeat: basic utilization for indexMap to reduce unnecessary processing ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* element-parser: use PLATFORM.emptyArray where possible and remove redundant property ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: convert parseAttribute to class instance with cache ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* semantic-model: use PLATFORM.emptyArray when possible ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* element-parser: use PLATFORM.emptyArray when possible ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: index the inspect/resolve buffers directly instead of destructuring ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))


		### Refactorings:

		* binding-context: explicitly model scope, context and observer lookup (#216) ([c3e3779](https://github.com/aurelia/aurelia/commit/c3e3779))
		* binding: explicitly model scope, override/bindingctx and observerlookup ([c3e3779](https://github.com/aurelia/aurelia/commit/c3e3779))
		* observer-locator: use direct lookup from bindingContext if available ([c3e3779](https://github.com/aurelia/aurelia/commit/c3e3779))
		* binding: use more precise types ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* ast: move common properties back to static declaration ([7267165](https://github.com/aurelia/aurelia/commit/7267165))
		* template-compiler: cleanup/inline instruction classes ([1e804a0](https://github.com/aurelia/aurelia/commit/1e804a0))
		* binding: cleanup/shuffle some interfaces accordingly ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* template-compiler: cleanup/inline instruction classes ([f67a414](https://github.com/aurelia/aurelia/commit/f67a414))
		* view-factory: use static maxCacheSize property ([eff5bb7](https://github.com/aurelia/aurelia/commit/eff5bb7))
		* SelectObserver: adjust SelectValueObserver synchronization (#208) ([ffdf01d](https://github.com/aurelia/aurelia/commit/ffdf01d))
		* repeat: use templateController decorator and clean everything up ([f296d04](https://github.com/aurelia/aurelia/commit/f296d04))
		* lifecycle: better naming and types for task api ([7a9a635](https://github.com/aurelia/aurelia/commit/7a9a635))
		* jit: improve parser registration and attribute testing ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* attribute-parser: store raw attribute values in syntax ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: decouple entrypoint from internal recursion point ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: first step to integrate the semantic model ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: initial migration steps to semantic model ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: more small tweaks, enable a few more tests ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: recognize single value attribute as bindable ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix plain attribute compilation ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix template controller / repeater compilation ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix semicolon-separated attribute bindings ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix let and textNodes ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix as-element ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix surrogates ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix let.dest ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix as-element / resourceKey ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix bindable precedence ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix slots ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix nested+sibling template controllers and cleanup the api a bit ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* template-compiler: fix let ([ad6eeb4](https://github.com/aurelia/aurelia/commit/ad6eeb4))
		* call: deprecate confusing $event property ([57c07e8](https://github.com/aurelia/aurelia/commit/57c07e8))
		* binding-command: reuse specific binding command prototype methods on the default binding command ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))
		* template-compiler: destructure with reused object ([7a92cd8](https://github.com/aurelia/aurelia/commit/7a92cd8))

		<a name="0.2.0"></a>
		# 0.2.0 (2018-09-18)

		### Features:

		### Bug Fixes
		* create-element: experimenting with supporting JSX ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* compose: incrementally working towards implementation ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* view: remove animations apis from view ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* renderable: enable dynamically added children ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* custom-element: enable better handling of containerless scenarios ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* compose: enable composing of loose views ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* compose: support rendering more types ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* createElement: support text nodes and targeted instructions ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* di: recurse through static registrations to find register methods in more edge cases ([6bc2d4d](https://github.com/aurelia/aurelia/commit/6bc2d4d))
		* Let: let binding (#132) ([c2a8324](https://github.com/aurelia/aurelia/commit/c2a8324))
		* runtime: Let binding, priorityInstructions ([c2a8324](https://github.com/aurelia/aurelia/commit/c2a8324))
		* jit: implement instruction-compiler decorator ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* runtime: implement render-strategy decorator ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* JIT: template compiler ([d584528](https://github.com/aurelia/aurelia/commit/d584528))
		* TemplateCompiler: surrogate behavior ([d584528](https://github.com/aurelia/aurelia/commit/d584528))
		* kernel: add fast camelCase and kebabCase functions with caching ([8debe4f](https://github.com/aurelia/aurelia/commit/8debe4f))
		* binding-context: add helper for creating a basic scope ([5577a53](https://github.com/aurelia/aurelia/commit/5577a53))
		* dbmonster: make dbmonster aot example work again (#101) ([9e1eb5a](https://github.com/aurelia/aurelia/commit/9e1eb5a))
		* dbmonster: make dbmonster aot example work again ([9e1eb5a](https://github.com/aurelia/aurelia/commit/9e1eb5a))
		* jit: move/extend attribute value parsing to the expression parser (#98) ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* observers: auto-enable collection observers and make the toggles idempotent ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* runtime: convert with attribute to use render location (#64) ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* runtime: convert with attribute to use render location ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* runtime: improvements to attribute and element bindable control and common interfaces ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* templating: convert replaceable to use render location (#59) ([7d1f8d4](https://github.com/aurelia/aurelia/commit/7d1f8d4))
		* templating: generalize attribute and element attachable child ([7d1f8d4](https://github.com/aurelia/aurelia/commit/7d1f8d4))
		* templating: switch replaceable to use render location ([7d1f8d4](https://github.com/aurelia/aurelia/commit/7d1f8d4))
		* binding: implement ChangeSet (#58) ([144b1c6](https://github.com/aurelia/aurelia/commit/144b1c6))
		* binding: implement ChangeSet ([144b1c6](https://github.com/aurelia/aurelia/commit/144b1c6))
		* templating: add the low-level render location abstraction (#57) ([3c9735e](https://github.com/aurelia/aurelia/commit/3c9735e))
		* templating: add the low-level render location abstraction ([3c9735e](https://github.com/aurelia/aurelia/commit/3c9735e))
		* custom-elements: define basic abstraction for element projection ([0a17b16](https://github.com/aurelia/aurelia/commit/0a17b16))
		* runtime: enable getting the custom element behavior... ([0a17b16](https://github.com/aurelia/aurelia/commit/0a17b16))
		* jit: implement interpolation & iterator (with destructuring) parsing ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* ast: initial implementation of ForOfStatement for iterating different collection types ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* ast: add metadata to the AST for ExpressionKind ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* jit: initial skeleton for customizeable binding commands ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* jit: simple first implementation for template-compiler ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))

		* dom: append nodes to the correct thing (doh) ([#66](https://github.com/aurelia/aurelia/issues/66)) ([c7a8285](https://github.com/aurelia/aurelia/commit/c7a8285))
		* observer-locator: add collection length back in, fix precedence, add tests ([#139](https://github.com/aurelia/aurelia/issues/139)) ([581a680](https://github.com/aurelia/aurelia/commit/581a680))
		* runtime: convert if/else to use render location ([#96](https://github.com/aurelia/aurelia/issues/96)) ([22b32b5](https://github.com/aurelia/aurelia/commit/22b32b5))
		* runtime: dry up bindable callback behavior ([#71](https://github.com/aurelia/aurelia/issues/71)) ([11b26a5](https://github.com/aurelia/aurelia/commit/11b26a5))
		* runtime: interface clarity ([#61](https://github.com/aurelia/aurelia/issues/61)) ([c4e26d3](https://github.com/aurelia/aurelia/commit/c4e26d3))
		* runtime: remove lazy bindable location and encapsulate observer ([#90](https://github.com/aurelia/aurelia/issues/90)) ([6607a14](https://github.com/aurelia/aurelia/commit/6607a14))
		* value-attribute-observer: don't notify subscribers if value hasn't changed ([#95](https://github.com/aurelia/aurelia/issues/95)) ([30e1099](https://github.com/aurelia/aurelia/commit/30e1099))

		### Bug Fixes:

		### Features
		* custom-element: address typo in method check ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* custom-element: remove special $child prop ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* compose: correct inject metadata ([66504c8](https://github.com/aurelia/aurelia/commit/66504c8))
		* di: invoke correct method on array strategy resolver ([6bc2d4d](https://github.com/aurelia/aurelia/commit/6bc2d4d))
		* di: invalidate Object keys to help diagnose invalid design:paramTypes ([6bc2d4d](https://github.com/aurelia/aurelia/commit/6bc2d4d))
		* di: add a non-any type alternative to the InterfaceSymbol<T> so that container.get() returns correctly typed instances ([6bc2d4d](https://github.com/aurelia/aurelia/commit/6bc2d4d))
		* let: cleanup ([c2a8324](https://github.com/aurelia/aurelia/commit/c2a8324))
		* template compiler: slot signal ([c2a8324](https://github.com/aurelia/aurelia/commit/c2a8324))
		* observer-locator: add collection length back in, fix precedence, add tests (#139) ([581a680](https://github.com/aurelia/aurelia/commit/581a680))
		* observer-locator: add collection length back in, fix precedence, add tests ([581a680](https://github.com/aurelia/aurelia/commit/581a680))
		* length-observer: add subscribe method ([581a680](https://github.com/aurelia/aurelia/commit/581a680))
		* runtime-behavior: pass target flags to getterSetter observer ([cf8390b](https://github.com/aurelia/aurelia/commit/cf8390b))
		* binding: report flags instead of nonexistent context ([cf8390b](https://github.com/aurelia/aurelia/commit/cf8390b))
		* examples: correct versions ([1b7c764](https://github.com/aurelia/aurelia/commit/1b7c764))
		* template-compiler: workaround for DI issue ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* binding-command: rename file ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* binding-command: pass correct bindingType to parser ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* observer: store obj and propertyKey ([d584528](https://github.com/aurelia/aurelia/commit/d584528))
		* template-compiler: merge camel-kebab changes and reuse platform functions ([d584528](https://github.com/aurelia/aurelia/commit/d584528))
		* template-compiler: fix slip-up with attribute name ([d584528](https://github.com/aurelia/aurelia/commit/d584528))
		* event-manager: use spec-compliant composedPath for shadowdom / fix linting ([6381c5b](https://github.com/aurelia/aurelia/commit/6381c5b))
		* event-manager: fix .delegate and .capture, and add unit tests ([6381c5b](https://github.com/aurelia/aurelia/commit/6381c5b))
		* typings: export event subscribers ([6381c5b](https://github.com/aurelia/aurelia/commit/6381c5b))
		* event-manager: export listener tracker to resolve typing issues ([6381c5b](https://github.com/aurelia/aurelia/commit/6381c5b))
		* tsconfig: correct extends path ([797674f](https://github.com/aurelia/aurelia/commit/797674f))
		* e2e-benchmark: simplify markers and use setTimeout to include render time ([8a8b619](https://github.com/aurelia/aurelia/commit/8a8b619))
		* binding-resources: lift register methods ([5577a53](https://github.com/aurelia/aurelia/commit/5577a53))
		* custom-attribute: life lifecycle methods ([5577a53](https://github.com/aurelia/aurelia/commit/5577a53))
		* custom-element: lift lifecycle methods ([5577a53](https://github.com/aurelia/aurelia/commit/5577a53))
		* runtime: convert if/else to use render location (#96) ([22b32b5](https://github.com/aurelia/aurelia/commit/22b32b5))
		* runtime: convert if/else to use render location ([22b32b5](https://github.com/aurelia/aurelia/commit/22b32b5))
		* if/else: set default value ([22b32b5](https://github.com/aurelia/aurelia/commit/22b32b5))
		* binding-behavior: fix BindingModeBehavior ([bb32291](https://github.com/aurelia/aurelia/commit/bb32291))
		* binding-behavior: fix debounce, add unit tests ([bb32291](https://github.com/aurelia/aurelia/commit/bb32291))
		* repeat: reuse views when re-binding and allow null observer for non-collection iterables ([9e1eb5a](https://github.com/aurelia/aurelia/commit/9e1eb5a))
		* expression-parser: use a separate lookup for non-interpolation attribute values ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* template-compiler: use the target name instead of full name + fix tests ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* template-compiler: add dest to one-time instruction ([1ddff95](https://github.com/aurelia/aurelia/commit/1ddff95))
		* value-attribute-observer: don't notify subscribers if value hasn't changed (#95) ([30e1099](https://github.com/aurelia/aurelia/commit/30e1099))
		* element-observation: fix binding flags ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* checked-observer: fix fromValue updates / add unit tests ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* element-observation: remove error-causing notify ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* runtime: remove lazy bindable location and encapsulate observer (#90) ([6607a14](https://github.com/aurelia/aurelia/commit/6607a14))
		* runtime: remove lazy bindable location and encapsulate observer ([6607a14](https://github.com/aurelia/aurelia/commit/6607a14))
		* event-manager: use uppercase tagname ([08d4bac](https://github.com/aurelia/aurelia/commit/08d4bac))
		* jit-parcel: remove else for now, fix instructions ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* template-compiler: wrap the nodes in a fragment ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* jit-parcel: remove path mappings from tsconfig ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* template-compiler: use firstElementChild instead of wrapper ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* template-compiler: various small tweaks and fixes, make example work ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* jit-parcel: make the example work with something simple ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* aurelia: set isStarted=true after tasks have finished ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* e2e: move publish into e2e job ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* ci: fix typo ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* ci: set the correct path before each cmd ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* ci: try a different approach for the workspaces ([d6a10b5](https://github.com/aurelia/aurelia/commit/d6a10b5))
		* runtime: dry up bindable callback behavior (#71) ([11b26a5](https://github.com/aurelia/aurelia/commit/11b26a5))
		* runtime: correct observer current value update and callback ordering ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* runtime: ensure all bindable callback slots are initialized ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* runtime-behavior: remove use of Toggle in favor of simple boolean ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* dom: append nodes to the correct thing (doh) (#66) ([c7a8285](https://github.com/aurelia/aurelia/commit/c7a8285))
		* repeat: adjust repeater logic + tests to new mutation batching mechanism ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* runtime: interface clarity (#61) ([c4e26d3](https://github.com/aurelia/aurelia/commit/c4e26d3))
		* runtime: correct kernel import ([c4e26d3](https://github.com/aurelia/aurelia/commit/c4e26d3))
		* runtime: make renderable and view factories interfaces have no default ([c4e26d3](https://github.com/aurelia/aurelia/commit/c4e26d3))
		* observation: fix subscriber typing ([144b1c6](https://github.com/aurelia/aurelia/commit/144b1c6))
		* dom: correct TS error ([3c9735e](https://github.com/aurelia/aurelia/commit/3c9735e))
		* templating: address trivial errors when removing emulation ([0a17b16](https://github.com/aurelia/aurelia/commit/0a17b16))
		* templating: remove shadow dom from compose element ([0a17b16](https://github.com/aurelia/aurelia/commit/0a17b16))
		* all: last few corrections from the merge ([0a17b16](https://github.com/aurelia/aurelia/commit/0a17b16))
		* runtime: various fixes related to compose ([0a17b16](https://github.com/aurelia/aurelia/commit/0a17b16))
		* all: correct types/properties and fix unit tests ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* template-compiler: small fixes, setup first simple integration tests ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* kernel: scripts working ([9302580](https://github.com/aurelia/aurelia/commit/9302580))
		* all: lots of path fixes and a few typing fixes, make sure everything builds correctly ([9302580](https://github.com/aurelia/aurelia/commit/9302580))
		* test: make all the tests run via lerna ([9302580](https://github.com/aurelia/aurelia/commit/9302580))

		* binding: implement ChangeSet ([#58](https://github.com/aurelia/aurelia/issues/58)) ([144b1c6](https://github.com/aurelia/aurelia/commit/144b1c6))
		* dbmonster: make dbmonster aot example work again ([#101](https://github.com/aurelia/aurelia/issues/101)) ([9e1eb5a](https://github.com/aurelia/aurelia/commit/9e1eb5a))
		* jit: move/extend attribute value parsing to the expression parser ([#98](https://github.com/aurelia/aurelia/issues/98)) ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* Let: let binding ([#132](https://github.com/aurelia/aurelia/issues/132)) ([c2a8324](https://github.com/aurelia/aurelia/commit/c2a8324))
		* runtime: convert with attribute to use render location ([#64](https://github.com/aurelia/aurelia/issues/64)) ([5830a36](https://github.com/aurelia/aurelia/commit/5830a36))
		* templating: add the low-level render location abstraction ([#57](https://github.com/aurelia/aurelia/issues/57)) ([3c9735e](https://github.com/aurelia/aurelia/commit/3c9735e))
		* templating: convert replaceable to use render location ([#59](https://github.com/aurelia/aurelia/issues/59)) ([7d1f8d4](https://github.com/aurelia/aurelia/commit/7d1f8d4))

		### Performance Improvements:

		* ast: various small perf tweaks / cleanup redundancies ([acf9ebc](https://github.com/aurelia/aurelia/commit/acf9ebc))
		* ast: first evaluate, then connect ([acf9ebc](https://github.com/aurelia/aurelia/commit/acf9ebc))
		* binding: remove unnecessary work / cleanup ([8a8b619](https://github.com/aurelia/aurelia/commit/8a8b619))


		### Refactorings:

		* di: append new resolvers on existing keys to a single array strategy resolver instead of nesting them ([6bc2d4d](https://github.com/aurelia/aurelia/commit/6bc2d4d))
		* Let: add LetElementInstruction ([c2a8324](https://github.com/aurelia/aurelia/commit/c2a8324))
		* template-compiler: move stuff around / fix various edge cases (#134) ([5920299](https://github.com/aurelia/aurelia/commit/5920299))
		* template-compiler: move stuff around / fix various edge cases ([5920299](https://github.com/aurelia/aurelia/commit/5920299))
		* template-compiler: hoist attribute inspection array / fix tests ([5920299](https://github.com/aurelia/aurelia/commit/5920299))
		* template-compiler: various fixes and cleanups ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* template-compiler: move binding commands to decorators ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* binding-command: add handles method ([1067e03](https://github.com/aurelia/aurelia/commit/1067e03))
		* all: remove viewslot (#123) ([fc9cbff](https://github.com/aurelia/aurelia/commit/fc9cbff))
		* bindable: use platform.kebabCase ([8debe4f](https://github.com/aurelia/aurelia/commit/8debe4f))
		* ast: switch while loops to for loops (same perf, more readable) ([acf9ebc](https://github.com/aurelia/aurelia/commit/acf9ebc))
		* binding: convert subscriber-collection to decorator for sync and async ([8a8b619](https://github.com/aurelia/aurelia/commit/8a8b619))
		* view: increase cohesion of view code (#111) ([2ccc770](https://github.com/aurelia/aurelia/commit/2ccc770))
		* runtime: lift resource methods (#107) ([5577a53](https://github.com/aurelia/aurelia/commit/5577a53))
		* if/else: some internal refactoring ([22b32b5](https://github.com/aurelia/aurelia/commit/22b32b5))
		* if/else: remove some more duplication ([22b32b5](https://github.com/aurelia/aurelia/commit/22b32b5))
		* parser: extract template/object/array literal parsing into functions ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* jit: move interpolation parsing to the expression parser ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* expression-parser: make bindingType mandatory and pass the correct types to the parser everywhere ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* template-compiler: make compiler flow a bit more logical ([53864a1](https://github.com/aurelia/aurelia/commit/53864a1))
		* instructions: change number type to string (#97) ([1ddff95](https://github.com/aurelia/aurelia/commit/1ddff95))
		* instructions: change number type to string, make const enum ([1ddff95](https://github.com/aurelia/aurelia/commit/1ddff95))
		* binding: decouple BindingFlags.context from subscribers ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* binding-flags: cleanup unused flags ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* binding-flags: add fromFlushChanges to reduce batching redundancy, and expand the zeroes ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* binding-flags: rename binding-flags ([4dc6cb8](https://github.com/aurelia/aurelia/commit/4dc6cb8))
		* property-observation: improve parameter naming ([6607a14](https://github.com/aurelia/aurelia/commit/6607a14))
		* dom: use uppercase tag names (#88) ([08d4bac](https://github.com/aurelia/aurelia/commit/08d4bac))
		* dom: use uppercase tag names ([08d4bac](https://github.com/aurelia/aurelia/commit/08d4bac))
		* dom: remove normalizedTagName ([08d4bac](https://github.com/aurelia/aurelia/commit/08d4bac))
		* all: improving a couple of method names related to resources (#70) ([49484e3](https://github.com/aurelia/aurelia/commit/49484e3))
		* all: more flags (#69) ([9e29f42](https://github.com/aurelia/aurelia/commit/9e29f42))
		* all: more flags ([9e29f42](https://github.com/aurelia/aurelia/commit/9e29f42))
		* binding-flags: rename and add clarifying comments ([9e29f42](https://github.com/aurelia/aurelia/commit/9e29f42))
		* binding-flags: change context to origin ([9e29f42](https://github.com/aurelia/aurelia/commit/9e29f42))
		* repeater: use render-location instead of view-slot / general cleanup ([6889328](https://github.com/aurelia/aurelia/commit/6889328))
		* repeater: first implementation step for ForOfStatement ([6889328](https://github.com/aurelia/aurelia/commit/6889328))
		* binding: move the responsibility of batching target mutations to the target observers ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* observation: move all element observers to element-observation ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* class-observer: update class-observer to the new mutation batching mechanism ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* checked-observer: update checked-observer to the new mutation batching mechanism ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* select-value-observer: update select-value-observer to the new mutation batching mechanism ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* observers: rename/move target accessors, cleanup typings, fix linting errors ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* target-accessors: remove redundant previousValue ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* observers: move from 'hasChanges' to 'this.oldValue !== currentValue' ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* observers: extract common logic out into a decorator / cleanup select-value-observer ([c2a5e82](https://github.com/aurelia/aurelia/commit/c2a5e82))
		* runtime: renaming core interfaces for clarity ([c4e26d3](https://github.com/aurelia/aurelia/commit/c4e26d3))
		* runtime: move test fakes to a shareable location ([7d1f8d4](https://github.com/aurelia/aurelia/commit/7d1f8d4))
		* binding: use ChangeSet instead of TaskQueue ([144b1c6](https://github.com/aurelia/aurelia/commit/144b1c6))
		* property-observer: make reusable decorator for setter/observer ([144b1c6](https://github.com/aurelia/aurelia/commit/144b1c6))
		* runtime: use "render location" terminology throughout ([3c9735e](https://github.com/aurelia/aurelia/commit/3c9735e))
		* all: remove vCurrent repeater and collection observers (#55) ([70b6696](https://github.com/aurelia/aurelia/commit/70b6696))
		* jit: merge attribute name/value parsers into template-compiler ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))
		* jit: use IResourceDescriptions for looking up resources ([8ab2173](https://github.com/aurelia/aurelia/commit/8ab2173))

dist/aurelia.d.ts

		import { IContainer, IRegistry } from '@aurelia/kernel';
		import { ICustomElement } from './templating/custom-element';
		export interface ISinglePageApp {
		@@ -12,5 +13,7 @@ host: any;
		private isStarted;
		private _root;
		constructor(container?: IContainer);
		register(...params: (IRegistry \| Record<string, Partial<IRegistry>>)[]): this;
		app(config: ISinglePageApp): this;
		root(): ICustomElement \| null;
		start(): this;
		@@ -17,0 +20,0 @@ stop(): this;

511

dist/binding/ast.d.ts

		@@ -1,10 +0,25 @@
		import { IServiceLocator } from '@aurelia/kernel';
		import { IIndexable, IServiceLocator } from '@aurelia/kernel';
		import { IBinding } from './binding';
		import { IScope } from './binding-context';
		import { BindingFlags } from './binding-flags';
		import { Collection } from './observation';
		import { IConnectableBinding } from './connectable';
		import { Collection, ObservedCollection } from './observation';
		export declare type StrictPrimitive = string \| number \| boolean \| null \| undefined;
		/**
		* StrictAny is a somewhat strongly typed alternative to 'any', in an effort to try to get rid of all 'any''s
		* It's not even remotely foolproof however, and this can largely be attributed to the fact that TypeScript imposes
		* far more constraints on what arithmic is allowed than vanilla JS does.
		* We don't necessarily want to impose the same constraints on users (e.g. by performing auto conversions or throwing),
		* because even though that behavior would technically be "better", it could also be experienced as unpredictable.
		* We'd generally not want to ask more of users than to simply understand how vanilla JS works, and let them account for its quirks themselves.
		* This gives end users less framework-specific things to learn.
		* Consequently, it's impossible to achieve any kind of strict type checking in the AST and generally in the observers.
		* We're trying to achieve some middle ground by applying some explicit type casts where TypeScript would otherwise not allow compilation.
		*/
		export declare type StrictAny = StrictPrimitive \| IIndexable \| Function;
		export declare type IsPrimary = AccessThis \| AccessScope \| ArrayLiteral \| ObjectLiteral \| PrimitiveLiteral \| Template;
		export declare type IsUnary = IsPrimary \| Unary;
		export declare type IsLeftHandSide = IsUnary \| CallFunction \| CallMember \| CallScope \| AccessMember \| AccessKeyed \| TaggedTemplate;
		export declare type IsBinary = IsLeftHandSide \| Binary;
		export declare type IsLiteral = ArrayLiteral \| ObjectLiteral \| PrimitiveLiteral \| Template;
		export declare type IsLeftHandSide = IsPrimary \| CallFunction \| CallMember \| CallScope \| AccessMember \| AccessKeyed \| TaggedTemplate;
		export declare type IsUnary = IsLeftHandSide \| Unary;
		export declare type IsBinary = IsUnary \| Binary;
		export declare type IsConditional = IsBinary \| Conditional;
		@@ -14,8 +29,44 @@ export declare type IsAssign = IsConditional \| Assign;
		export declare type IsBindingBehavior = IsValueConverter \| BindingBehavior;
		export declare type IsAssignable = AccessScope \| AccessKeyed \| AccessMember;
		export declare type IsAssignable = AccessScope \| AccessKeyed \| AccessMember \| Assign;
		export declare type IsExpression = IsBindingBehavior \| Interpolation;
		export declare type IsExpressionOrStatement = IsExpression \| ForOfStatement \| BindingIdentifierOrPattern \| HtmlLiteral;
		export declare type Connects = AccessScope \| ArrayLiteral \| ObjectLiteral \| Template \| Unary \| CallScope \| AccessMember \| AccessKeyed \| TaggedTemplate \| Binary \| Conditional \| ValueConverter \| BindingBehavior \| ForOfStatement;
		export declare type Observes = AccessScope \| AccessKeyed \| AccessMember;
		export declare type CallsFunction = CallFunction \| CallScope \| CallMember \| TaggedTemplate;
		export declare type IsResource = ValueConverter \| BindingBehavior;
		export declare type HasBind = BindingBehavior;
		export declare type HasUnbind = ValueConverter \| BindingBehavior;
		export declare type HasAncestor = AccessThis \| AccessScope \| CallScope;
		export interface IVisitor<T = any> {
		visitAccessKeyed(expr: AccessKeyed): T;
		visitAccessMember(expr: AccessMember): T;
		visitAccessScope(expr: AccessScope): T;
		visitAccessThis(expr: AccessThis): T;
		visitArrayBindingPattern(expr: ArrayBindingPattern): T;
		visitArrayLiteral(expr: ArrayLiteral): T;
		visitAssign(expr: Assign): T;
		visitBinary(expr: Binary): T;
		visitBindingBehavior(expr: BindingBehavior): T;
		visitBindingIdentifier(expr: BindingIdentifier): T;
		visitCallFunction(expr: CallFunction): T;
		visitCallMember(expr: CallMember): T;
		visitCallScope(expr: CallScope): T;
		visitConditional(expr: Conditional): T;
		visitForOfStatement(expr: ForOfStatement): T;
		visitHtmlLiteral(expr: HtmlLiteral): T;
		visitInterpolation(expr: Interpolation): T;
		visitObjectBindingPattern(expr: ObjectBindingPattern): T;
		visitObjectLiteral(expr: ObjectLiteral): T;
		visitPrimitiveLiteral(expr: PrimitiveLiteral): T;
		visitTaggedTemplate(expr: TaggedTemplate): T;
		visitTemplate(expr: Template): T;
		visitUnary(expr: Unary): T;
		visitValueConverter(expr: ValueConverter): T;
		}
		export interface IExpression {
		readonly $kind: ExpressionKind;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator \| null): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): any;
		assign?(flags: BindingFlags, scope: IScope, locator: IServiceLocator \| null, value: any): any;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator \| null): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		assign?(flags: BindingFlags, scope: IScope, locator: IServiceLocator \| null, value: StrictAny): StrictAny;
		bind?(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		@@ -25,155 +76,186 @@ unbind?(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		export declare const enum ExpressionKind {
		IsPrimary = 32,
		IsLeftHandSide = 64,
		IsAssignable = 128,
		IsExpression = 256,
		IsResource = 512,
		IsStatement = 1024,
		IsDestructuring = 2048,
		IsForDeclaration = 4096,
		Connects = 32,
		Observes = 64,
		CallsFunction = 128,
		HasAncestor = 256,
		IsPrimary = 512,
		IsLeftHandSide = 1024,
		HasBind = 2048,
		HasUnbind = 4096,
		IsAssignable = 8192,
		IsLiteral = 16384,
		IsResource = 32768,
		IsForDeclaration = 65536,
		Type = 31,
		AccessThis = 289,
		AccessScope = 418,
		ArrayLiteral = 291,
		ObjectLiteral = 292,
		PrimitiveLiteral = 293,
		Template = 294,
		Unary = 263,
		CallScope = 328,
		CallMember = 329,
		CallFunction = 330,
		AccessMember = 459,
		AccessKeyed = 460,
		TaggedTemplate = 333,
		Binary = 270,
		Conditional = 287,
		Assign = 272,
		ValueConverter = 529,
		BindingBehavior = 530,
		HtmlLiteral = 19,
		ArrayBindingPattern = 6164,
		ObjectBindingPattern = 6165,
		BindingIdentifier = 4118,
		ForOfStatement = 1047,
		Interpolation = 280
		AccessThis = 1793,
		AccessScope = 10082,
		ArrayLiteral = 17955,
		ObjectLiteral = 17956,
		PrimitiveLiteral = 17925,
		Template = 17958,
		Unary = 39,
		CallScope = 1448,
		CallMember = 1161,
		CallFunction = 1162,
		AccessMember = 9323,
		AccessKeyed = 9324,
		TaggedTemplate = 1197,
		Binary = 46,
		Conditional = 63,
		Assign = 8208,
		ValueConverter = 36913,
		BindingBehavior = 38962,
		HtmlLiteral = 51,
		ArrayBindingPattern = 65556,
		ObjectBindingPattern = 65557,
		BindingIdentifier = 65558,
		ForOfStatement = 55,
		Interpolation = 24
		}
		export declare function connects(expr: IsExpressionOrStatement): expr is Connects;
		export declare function observes(expr: IsExpressionOrStatement): expr is Observes;
		export declare function callsFunction(expr: IsExpressionOrStatement): expr is CallsFunction;
		export declare function hasAncestor(expr: IsExpressionOrStatement): expr is HasAncestor;
		export declare function isAssignable(expr: IsExpressionOrStatement): expr is IsAssignable;
		export declare function isLeftHandSide(expr: IsExpressionOrStatement): expr is IsLeftHandSide;
		export declare function isPrimary(expr: IsExpressionOrStatement): expr is IsPrimary;
		export declare function isResource(expr: IsExpressionOrStatement): expr is IsResource;
		export declare function hasBind(expr: IsExpressionOrStatement): expr is HasBind;
		export declare function hasUnbind(expr: IsExpressionOrStatement): expr is HasUnbind;
		export declare function isLiteral(expr: IsExpressionOrStatement): expr is IsLiteral;
		export declare function arePureLiterals(expressions: ReadonlyArray<IsExpressionOrStatement>): expressions is IsLiteral[];
		export declare function isPureLiteral(expr: IsExpressionOrStatement): expr is IsLiteral;
		export declare class BindingBehavior implements IExpression {
		expression: IsBindingBehavior;
		name: string;
		args: IsAssign[];
		$kind: ExpressionKind;
		private behaviorKey;
		private expressionHasBind;
		private expressionHasUnbind;
		constructor(expression: IsBindingBehavior, name: string, args: IsAssign[]);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		bind(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		unbind(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		readonly expression: IsBindingBehavior;
		readonly name: string;
		readonly args: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.BindingBehavior;
		readonly behaviorKey: string;
		private readonly expressionHasBind;
		private readonly expressionHasUnbind;
		constructor(expression: IsBindingBehavior, name: string, args: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: StrictAny): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		bind(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		unbind(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class ValueConverter implements IExpression {
		expression: IsValueConverter;
		name: string;
		args: IsAssign[];
		$kind: ExpressionKind;
		private converterKey;
		constructor(expression: IsValueConverter, name: string, args: IsAssign[]);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		unbind(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		readonly expression: IsValueConverter;
		readonly name: string;
		readonly args: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.ValueConverter;
		readonly converterKey: string;
		constructor(expression: IsValueConverter, name: string, args: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: StrictAny): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		unbind(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class Assign implements IExpression {
		target: IsAssignable;
		value: IsAssign;
		$kind: ExpressionKind;
		readonly target: IsAssignable;
		readonly value: IsAssign;
		$kind: ExpressionKind.Assign;
		constructor(target: IsAssignable, value: IsAssign);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any): any;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: StrictAny): StrictAny;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class Conditional implements IExpression {
		condition: IExpression;
		yes: IExpression;
		no: IExpression;
		$kind: ExpressionKind;
		readonly condition: IsBinary;
		readonly yes: IsAssign;
		readonly no: IsAssign;
		$kind: ExpressionKind.Conditional;
		assign: IExpression['assign'];
		constructor(condition: IExpression, yes: IExpression, no: IExpression);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(condition: IsBinary, yes: IsAssign, no: IsAssign);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class AccessThis implements IExpression {
		ancestor: number;
		$kind: ExpressionKind;
		readonly ancestor: number;
		static readonly $this: AccessThis;
		static readonly $parent: AccessThis;
		$kind: ExpressionKind.AccessThis;
		assign: IExpression['assign'];
		connect: IExpression['connect'];
		constructor(ancestor?: number);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class AccessScope implements IExpression {
		name: string;
		ancestor: number;
		$kind: ExpressionKind;
		readonly name: string;
		readonly ancestor: number;
		$kind: ExpressionKind.AccessScope;
		constructor(name: string, ancestor?: number);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: StrictAny): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class AccessMember implements IExpression {
		object: IExpression;
		name: string;
		$kind: ExpressionKind;
		constructor(object: IExpression, name: string);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		readonly object: IsLeftHandSide;
		readonly name: string;
		$kind: ExpressionKind.AccessMember;
		constructor(object: IsLeftHandSide, name: string);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: StrictAny): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class AccessKeyed implements IExpression {
		object: IExpression;
		key: IExpression;
		$kind: ExpressionKind;
		constructor(object: IExpression, key: IExpression);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any \| null): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		readonly object: IsLeftHandSide;
		readonly key: IsAssign;
		$kind: ExpressionKind.AccessKeyed;
		constructor(object: IsLeftHandSide, key: IsAssign);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: StrictAny): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class CallScope implements IExpression {
		name: string;
		args: ReadonlyArray<IExpression>;
		ancestor: number;
		$kind: ExpressionKind;
		readonly name: string;
		readonly args: ReadonlyArray<IsAssign>;
		readonly ancestor: number;
		$kind: ExpressionKind.CallScope;
		assign: IExpression['assign'];
		constructor(name: string, args: ReadonlyArray<IExpression>, ancestor?: number);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator \| null): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(name: string, args: ReadonlyArray<IsAssign>, ancestor?: number);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator \| null): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class CallMember implements IExpression {
		object: IExpression;
		name: string;
		args: ReadonlyArray<IExpression>;
		$kind: ExpressionKind;
		readonly object: IsLeftHandSide;
		readonly name: string;
		readonly args: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.CallMember;
		assign: IExpression['assign'];
		constructor(object: IExpression, name: string, args: ReadonlyArray<IExpression>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(object: IsLeftHandSide, name: string, args: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class CallFunction implements IExpression {
		func: IExpression;
		args: IExpression[];
		$kind: ExpressionKind;
		readonly func: IsLeftHandSide;
		readonly args: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.CallFunction;
		assign: IExpression['assign'];
		constructor(func: IExpression, args: IExpression[]);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(func: IsLeftHandSide, args: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare type BinaryOperator = '&&' \| '\|\|' \| '==' \| '===' \| '!=' \| '!==' \| 'instanceof' \| 'in' \| '+' \| '-' \| '*' \| '/' \| '%' \| '<' \| '>' \| '<=' \| '>=';
		export declare class Binary implements IExpression {
		operation: string;
		left: IExpression;
		right: IExpression;
		$kind: ExpressionKind;
		readonly operation: BinaryOperator;
		readonly left: IsBinary;
		readonly right: IsBinary;
		$kind: ExpressionKind.Binary;
		assign: IExpression['assign'];
		constructor(operation: string, left: IExpression, right: IExpression);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(operation: BinaryOperator, left: IsBinary, right: IsBinary);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		private ['&&'];
		@@ -196,117 +278,142 @@ private ['\|\|'];
		private ['>='];
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class Unary {
		operation: 'void' \| 'typeof' \| '!' \| '-' \| '+';
		expression: IsLeftHandSide;
		$kind: ExpressionKind;
		constructor(operation: 'void' \| 'typeof' \| '!' \| '-' \| '+', expression: IsLeftHandSide);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, value: any): any;
		private ['void'];
		private ['typeof'];
		private ['!'];
		private ['-'];
		private ['+'];
		export declare type UnaryOperator = 'void' \| 'typeof' \| '!' \| '-' \| '+';
		export declare class Unary implements IExpression {
		readonly operation: UnaryOperator;
		readonly expression: IsLeftHandSide;
		$kind: ExpressionKind.Unary;
		assign: IExpression['assign'];
		constructor(operation: UnaryOperator, expression: IsLeftHandSide);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		['void'](f: BindingFlags, s: IScope, l: IServiceLocator): undefined;
		['typeof'](f: BindingFlags, s: IScope, l: IServiceLocator): string;
		['!'](f: BindingFlags, s: IScope, l: IServiceLocator): boolean;
		['-'](f: BindingFlags, s: IScope, l: IServiceLocator): number;
		['+'](f: BindingFlags, s: IScope, l: IServiceLocator): number;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class PrimitiveLiteral implements IExpression {
		value: any;
		$kind: ExpressionKind;
		export declare class PrimitiveLiteral<TValue extends StrictPrimitive = StrictPrimitive> implements IExpression {
		readonly value: TValue;
		static readonly $undefined: PrimitiveLiteral<undefined>;
		static readonly $null: PrimitiveLiteral<null>;
		static readonly $true: PrimitiveLiteral<true>;
		static readonly $false: PrimitiveLiteral<false>;
		static readonly $empty: PrimitiveLiteral<string>;
		$kind: ExpressionKind.PrimitiveLiteral;
		connect: IExpression['connect'];
		assign: IExpression['assign'];
		constructor(value: any);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		constructor(value: TValue);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): TValue;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class HtmlLiteral implements IExpression {
		parts: IExpression[];
		$kind: ExpressionKind;
		readonly parts: ReadonlyArray<HtmlLiteral>;
		$kind: ExpressionKind.HtmlLiteral;
		assign: IExpression['assign'];
		constructor(parts: IExpression[]);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(parts: ReadonlyArray<HtmlLiteral>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): string;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class ArrayLiteral implements IExpression {
		elements: IExpression[];
		$kind: ExpressionKind;
		readonly elements: ReadonlyArray<IsAssign>;
		static readonly $empty: ArrayLiteral;
		$kind: ExpressionKind.ArrayLiteral;
		assign: IExpression['assign'];
		constructor(elements: IExpression[]);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any[];
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(elements: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): ReadonlyArray<StrictAny>;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class ObjectLiteral implements IExpression {
		keys: (number \| string)[];
		values: IExpression[];
		$kind: ExpressionKind;
		readonly keys: ReadonlyArray<number \| string>;
		readonly values: ReadonlyArray<IsAssign>;
		static readonly $empty: ObjectLiteral;
		$kind: ExpressionKind.ObjectLiteral;
		assign: IExpression['assign'];
		constructor(keys: (number \| string)[], values: IExpression[]);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		constructor(keys: ReadonlyArray<number \| string>, values: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): Record<string, StrictAny>;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class Template implements IExpression {
		cooked: string[];
		expressions?: IsAssign[];
		$kind: ExpressionKind;
		readonly cooked: ReadonlyArray<string>;
		readonly expressions?: ReadonlyArray<IsAssign>;
		static readonly $empty: Template;
		$kind: ExpressionKind.Template;
		assign: IExpression['assign'];
		constructor(cooked: string[], expressions?: IsAssign[]);
		constructor(cooked: ReadonlyArray<string>, expressions?: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): string;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class TaggedTemplate implements IExpression {
		cooked: string[] & {
		raw?: string[];
		readonly cooked: ReadonlyArray<string> & {
		raw?: ReadonlyArray<string>;
		};
		func: IsLeftHandSide;
		expressions?: IsAssign[];
		$kind: ExpressionKind;
		readonly func: IsLeftHandSide;
		readonly expressions?: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.TaggedTemplate;
		assign: IExpression['assign'];
		constructor(cooked: string[] & {
		raw?: string[];
		}, raw: string[], func: IsLeftHandSide, expressions?: IsAssign[]);
		constructor(cooked: ReadonlyArray<string> & {
		raw?: ReadonlyArray<string>;
		}, raw: ReadonlyArray<string>, func: IsLeftHandSide, expressions?: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): string;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class ArrayBindingPattern implements IExpression {
		elements: IsAssign[];
		$kind: ExpressionKind;
		constructor(elements: IsAssign[]);
		readonly elements: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.ArrayBindingPattern;
		constructor(elements: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, obj: any): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, obj: IIndexable): any;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class ObjectBindingPattern implements IExpression {
		keys: (string \| number)[];
		values: IsAssign[];
		$kind: ExpressionKind;
		constructor(keys: (string \| number)[], values: IsAssign[]);
		readonly keys: ReadonlyArray<string \| number>;
		readonly values: ReadonlyArray<IsAssign>;
		$kind: ExpressionKind.ObjectBindingPattern;
		constructor(keys: ReadonlyArray<string \| number>, values: ReadonlyArray<IsAssign>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, obj: any): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		assign(flags: BindingFlags, scope: IScope, locator: IServiceLocator, obj: IIndexable): any;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class BindingIdentifier implements IExpression {
		$kind: ExpressionKind;
		name: string;
		readonly name: string;
		$kind: ExpressionKind.BindingIdentifier;
		constructor(name: string);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare type BindingIdentifierOrPattern = BindingIdentifier \| ArrayBindingPattern \| ObjectBindingPattern;
		export declare class ForOfStatement implements IExpression {
		$kind: ExpressionKind;
		declaration: BindingIdentifierOrPattern;
		iterable: IsBindingBehavior;
		readonly declaration: BindingIdentifierOrPattern;
		readonly iterable: IsBindingBehavior;
		$kind: ExpressionKind.ForOfStatement;
		assign: IExpression['assign'];
		constructor(declaration: BindingIdentifierOrPattern, iterable: IsBindingBehavior);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): any;
		count(result: any): number;
		iterate(result: any, func: (arr: Collection, index: number, item: any) => void): void;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): StrictAny;
		count(result: ObservedCollection \| number \| null \| undefined): number;
		iterate(result: ObservedCollection \| number \| null \| undefined, func: (arr: Collection, index: number, item: any) => void): void;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		export declare class Interpolation implements IExpression {
		parts: string[];
		expressions: IExpression[];
		$kind: ExpressionKind;
		readonly parts: ReadonlyArray<string>;
		readonly expressions: ReadonlyArray<IsBindingBehavior>;
		$kind: ExpressionKind.Interpolation;
		assign: IExpression['assign'];
		constructor(parts: string[], expressions: IExpression[]);
		readonly isMulti: boolean;
		readonly firstExpression: IsBindingBehavior;
		constructor(parts: ReadonlyArray<string>, expressions: ReadonlyArray<IsBindingBehavior>);
		evaluate(flags: BindingFlags, scope: IScope, locator: IServiceLocator): string;
		connect(flags: BindingFlags, scope: IScope, binding: IBinding): void;
		connect(flags: BindingFlags, scope: IScope, binding: IConnectableBinding): void;
		accept<T>(visitor: IVisitor<T>): T;
		}
		//# sourceMappingURL=ast.d.ts.map

dist/binding/binding-context.d.ts

 @@ -0,16 +1,56 @@
 import { IIndexable } from '@aurelia/kernel';
 import { StrictPrimitive } from './ast';
 import { IBindScope, ObservedCollection, PropertyObserver } from './observation';
 export interface IObserversLookup<TObj extends IIndexable = IIndexable, TKey extends keyof TObj = Exclude<keyof TObj, '$synthetic' | '$observers' | 'bindingContext' | 'overrideContext' | 'parentOverrideContext'>> {
 export declare type ObserversLookup<TObj extends IIndexable = IIndexable, TKey extends keyof TObj = Exclude<keyof TObj, '$synthetic' | '$observers' | 'bindingContext' | 'overrideContext' | 'parentOverrideContext'>> = {
     [P in TKey]: PropertyObserver;
 } & {
     getOrCreate(obj: IBindingContext | IOverrideContext, key: string): PropertyObserver;
 };
 export interface IBindingContext {
     [key: string]: ObservedCollection | StrictPrimitive | IIndexable;
     readonly $synthetic?: true;
     readonly $observers?: ObserversLookup<IOverrideContext>;
     getObservers(): ObserversLookup<IOverrideContext>;
 export interface IOverrideContext {
     parentOverrideContext: IOverrideContext;
     bindingContext: any;
     [key: string]: ObservedCollection | StrictPrimitive | IIndexable;
     readonly $synthetic?: true;
     readonly $observers?: ObserversLookup<IOverrideContext>;
     readonly bindingContext: IBindingContext | IBindScope;
     readonly parentOverrideContext: IOverrideContext | null;
     getObservers(): ObserversLookup<IOverrideContext>;
 export interface IScope {
     bindingContext: any;
     overrideContext: IOverrideContext;
     readonly bindingContext: IBindingContext | IBindScope;
     readonly overrideContext: IOverrideContext;
 export declare const BindingContext: {
     createScope(bindingContext: any, overrideContext?: IOverrideContext): IScope;
     createScopeFromOverride(overrideContext: IOverrideContext): IScope;
     createScopeFromParent(parentScope: IScope, bindingContext: any): IScope;
     createOverride(bindingContext?: any, parentOverrideContext?: IOverrideContext): IOverrideContext;
     get(scope: IScope, name: string, ancestor: number): any;
 };
 export declare class BindingContext implements IBindingContext {
     [key: string]: ObservedCollection | StrictPrimitive | IIndexable;
     readonly $synthetic: true;
     $observers: ObserversLookup<IOverrideContext>;
     private constructor();
     static create(obj?: IIndexable): BindingContext;
     static create(key: string, value: ObservedCollection | StrictPrimitive | IIndexable): BindingContext;
     static get(scope: IScope, name: string, ancestor: number): IBindingContext | IOverrideContext | IBindScope;
     getObservers(): ObserversLookup<IOverrideContext>;
 export declare class Scope implements IScope {
     readonly bindingContext: IBindingContext | IBindScope;
     readonly overrideContext: IOverrideContext;
     private constructor();
     static create(bc: IBindingContext | IBindScope, oc: IOverrideContext | null): Scope;
     static fromOverride(oc: IOverrideContext): Scope;
     static fromParent(ps: IScope, bc: IBindingContext | IBindScope): Scope;
 export declare class OverrideContext implements IOverrideContext {
     readonly bindingContext: IBindingContext | IBindScope;
     readonly parentOverrideContext: IOverrideContext | null;
     [key: string]: ObservedCollection | StrictPrimitive | IIndexable;
     readonly $synthetic: true;
     private constructor();
     static create(bc: IBindingContext | IBindScope, poc: IOverrideContext | null): OverrideContext;
     getObservers(): ObserversLookup<IOverrideContext>;
 //# sourceMappingURL=binding-context.d.ts.map

dist/binding/binding.d.ts

		import { IServiceLocator } from '@aurelia/kernel';
		import { IExpression } from './ast';
		import { ForOfStatement, IsBindingBehavior } from './ast';
		import { IScope } from './binding-context';
		import { BindingFlags } from './binding-flags';
		import { BindingMode } from './binding-mode';
		import { AccessorOrObserver, IBindingTargetObserver, IBindScope, IPropertySubscriber } from './observation';
		import { IConnectableBinding, IPartialConnectableBinding } from './connectable';
		import { AccessorOrObserver, IBindScope } from './observation';
		import { IObserverLocator } from './observer-locator';
		export interface IBinding extends IBindScope {
		locator: IServiceLocator;
		observeProperty(obj: any, name: string): void;
		readonly locator: IServiceLocator;
		readonly $scope: IScope;
		}
		export declare type IBindingTarget = any;
		export declare class Binding implements IBinding, IPropertySubscriber {
		sourceExpression: IExpression;
		export interface Binding extends IConnectableBinding {
		}
		export declare class Binding implements IPartialConnectableBinding {
		sourceExpression: IsBindingBehavior \| ForOfStatement;
		target: IBindingTarget;
		targetProperty: string;
		mode: BindingMode;
		protected observerLocator: IObserverLocator;
		observerLocator: IObserverLocator;
		locator: IServiceLocator;
		$isBound: boolean;
		$scope: IScope;
		targetObserver: AccessorOrObserver;
		protected observerSlots: number;
		protected version: number;
		protected $scope: IScope;
		constructor(sourceExpression: IExpression, target: IBindingTarget, targetProperty: string, mode: BindingMode, observerLocator: IObserverLocator, locator: IServiceLocator);
		updateTarget(value: any): void;
		updateSource(value: any): void;
		constructor(sourceExpression: IsBindingBehavior \| ForOfStatement, target: IBindingTarget, targetProperty: string, mode: BindingMode, observerLocator: IObserverLocator, locator: IServiceLocator);
		updateTarget(value: any, flags: BindingFlags): void;
		updateSource(value: any, flags: BindingFlags): void;
		handleChange(newValue: any, previousValue: any, flags: BindingFlags): void;
		$bind(flags: BindingFlags, scope: IScope): void;
		$unbind(flags: BindingFlags): void;
		connect(flags: BindingFlags): void;
		addObserver(observer: IBindingTargetObserver): void;
		observeProperty(obj: any, propertyName: string): void;
		unobserve(all?: boolean): void;
		}
		//# sourceMappingURL=binding.d.ts.map

dist/binding/call.d.ts

		@@ -1,21 +0,24 @@
		import { IServiceLocator } from '@aurelia/kernel';
		import { IIndexable, IServiceLocator, Primitive } from '@aurelia/kernel';
		import { INode } from '../dom';
		import { IExpression } from './ast';
		import { IBinding } from './binding';
		import { IsBindingBehavior, StrictAny } from './ast';
		import { IScope } from './binding-context';
		import { BindingFlags } from './binding-flags';
		import { IConnectableBinding } from './connectable';
		import { IAccessor } from './observation';
		import { IObserverLocator } from './observer-locator';
		export declare class Call implements IBinding {
		sourceExpression: IExpression;
		export interface Call extends IConnectableBinding {
		}
		export declare class Call {
		sourceExpression: IsBindingBehavior;
		locator: IServiceLocator;
		$isBound: boolean;
		$scope: IScope;
		targetObserver: IAccessor;
		private $scope;
		constructor(sourceExpression: IExpression, target: INode, targetProperty: string, observerLocator: IObserverLocator, locator: IServiceLocator);
		callSource($event: any): any;
		constructor(sourceExpression: IsBindingBehavior, target: INode, targetProperty: string, observerLocator: IObserverLocator, locator: IServiceLocator);
		callSource(args: IIndexable): Primitive \| IIndexable;
		$bind(flags: BindingFlags, scope: IScope): void;
		$unbind(flags: BindingFlags): void;
		observeProperty(): void;
		observeProperty(obj: StrictAny, propertyName: StrictAny): void;
		handleChange(newValue: any, previousValue: any, flags: BindingFlags): void;
		}
		//# sourceMappingURL=call.d.ts.map

dist/binding/element-observation.d.ts

		@@ -66,3 +66,3 @@ import { IIndexable, Primitive } from '@aurelia/kernel';
		matcher?: typeof defaultMatcher;
		}, string, Primitive \| UntypedArray>, IBatchedCollectionSubscriber, IPropertySubscriber {
		}, string, Primitive \| IIndexable \| UntypedArray>, IBatchedCollectionSubscriber, IPropertySubscriber {
		}
		@@ -76,5 +76,5 @@ export declare class SelectValueObserver implements SelectValueObserver {
		observerLocator: IObserverLocator;
		currentValue: Primitive \| UntypedArray;
		currentValue: Primitive \| IIndexable \| UntypedArray;
		currentFlags: BindingFlags;
		oldValue: Primitive \| UntypedArray;
		oldValue: Primitive \| IIndexable \| UntypedArray;
		defaultValue: Primitive \| UntypedArray;
		@@ -87,3 +87,3 @@ flushChanges: () => void;
		}, handler: IEventSubscriber, observerLocator: IObserverLocator);
		getValue(): Primitive \| UntypedArray;
		getValue(): Primitive \| IIndexable \| UntypedArray;
		setValueCore(newValue: Primitive \| UntypedArray, flags: BindingFlags): void;
		@@ -95,3 +95,3 @@ handleBatchedChange(indexMap: number[]): void;
		synchronizeOptions(indexMap?: IndexMap): void;
		synchronizeValue(): void;
		synchronizeValue(): boolean;
		subscribe(subscriber: IPropertySubscriber): void;
		@@ -101,4 +101,5 @@ unsubscribe(subscriber: IPropertySubscriber): void;
		unbind(): void;
		handleNodeChange(): void;
		}
		export {};
		//# sourceMappingURL=element-observation.d.ts.map

dist/binding/expression-parser.d.ts

		@@ -1,5 +0,8 @@
		import { IExpression } from './ast';
		import { ForOfStatement, Interpolation, IsBindingBehavior } from './ast';
		export interface IExpressionParser {
		cache(expressions: Record<string, IExpression>): void;
		parse(expression: string, bindingType: BindingType): IExpression;
		cache(expressions: Record<string, Interpolation \| ForOfStatement \| IsBindingBehavior>): void;
		parse(expression: string, bindingType: BindingType.ForCommand): ForOfStatement;
		parse(expression: string, bindingType: BindingType.Interpolation): Interpolation;
		parse(expression: string, bindingType: Exclude<BindingType, BindingType.ForCommand \| BindingType.Interpolation>): IsBindingBehavior;
		parse(expression: string, bindingType: BindingType): Interpolation \| ForOfStatement \| IsBindingBehavior;
		}
		@@ -6,0 +9,0 @@ export declare const IExpressionParser: import("@aurelia/kernel/dist/di").InterfaceSymbol<IExpressionParser>;

dist/binding/let-binding.d.ts

		import { IServiceLocator } from '@aurelia/kernel';
		import { IExpression } from './ast';
		import { Binding } from './binding';
		import { IBindingTarget } from './binding';
		import { IScope } from './binding-context';
		import { BindingFlags } from './binding-flags';
		import { IConnectableBinding, IPartialConnectableBinding } from './connectable';
		import { IObserverLocator } from './observer-locator';
		export declare class LetBinding extends Binding {
		export interface LetBinding extends IConnectableBinding {
		}
		export declare class LetBinding implements IPartialConnectableBinding {
		sourceExpression: IExpression;
		targetProperty: string;
		observerLocator: IObserverLocator;
		locator: IServiceLocator;
		private toViewModel;
		$isBound: boolean;
		$scope: IScope;
		target: IBindingTarget;
		constructor(sourceExpression: IExpression, targetProperty: string, observerLocator: IObserverLocator, locator: IServiceLocator, toViewModel?: boolean);
		updateTarget(value: any): void;
		updateSource(value: any): void;
		handleChange(newValue: any, previousValue: any, flags: BindingFlags): void;
		$bind(flags: BindingFlags, scope: IScope): void;
		$unbind(flags: BindingFlags): void;
		connect(flags: BindingFlags): void;
		}
		//# sourceMappingURL=let-binding.d.ts.map

dist/binding/listener.d.ts

		import { IServiceLocator } from '@aurelia/kernel';
		import { INode } from '../dom';
		import { IExpression } from './ast';
		import { IsBindingBehavior, StrictAny } from './ast';
		import { IBinding } from './binding';
		import { IScope } from './binding-context';
		import { BindingFlags } from './binding-flags';
		import { IConnectableBinding } from './connectable';
		import { DelegationStrategy, IEventManager } from './event-manager';
		export interface Listener extends IConnectableBinding {
		}
		export declare class Listener implements IBinding {
		targetEvent: string;
		delegationStrategy: DelegationStrategy;
		sourceExpression: IExpression;
		sourceExpression: IsBindingBehavior;
		target: INode;
		@@ -17,11 +20,12 @@ preventDefault: boolean;
		$isBound: boolean;
		private source;
		$scope: IScope;
		private handler;
		constructor(targetEvent: string, delegationStrategy: DelegationStrategy, sourceExpression: IExpression, target: INode, preventDefault: boolean, eventManager: IEventManager, locator: IServiceLocator);
		callSource(event: Event): any;
		constructor(targetEvent: string, delegationStrategy: DelegationStrategy, sourceExpression: IsBindingBehavior, target: INode, preventDefault: boolean, eventManager: IEventManager, locator: IServiceLocator);
		callSource(event: Event): ReturnType<IsBindingBehavior['evaluate']>;
		handleEvent(event: Event): void;
		$bind(flags: BindingFlags, source: IScope): void;
		$bind(flags: BindingFlags, scope: IScope): void;
		$unbind(flags: BindingFlags): void;
		observeProperty(): void;
		observeProperty(obj: StrictAny, propertyName: StrictAny): void;
		handleChange(newValue: any, previousValue: any, flags: BindingFlags): void;
		}
		//# sourceMappingURL=listener.d.ts.map

dist/binding/observation.d.ts

		@@ -31,2 +31,3 @@ import { IDisposable, IIndexable } from '@aurelia/kernel';
		export declare type IObservable = (IIndexable \| string \| Node \| INode \| Collection) & {
		readonly $synthetic?: false;
		$observers?: Record<string, AccessorOrObserver>;
		@@ -183,3 +184,3 @@ };
		interface IObservedCollection {
		$observer: CollectionObserver;
		$observer?: CollectionObserver;
		}
		@@ -212,5 +213,6 @@ /**
		}
		declare type LengthPropertyName<T> = T extends any[] ? 'length' : T extends Set<any> ? 'size' : T extends Map<any, any> ? 'size' : never;
		declare type CollectionKindToType<T> = T extends CollectionKind.array ? any[] : T extends CollectionKind.indexed ? any[] : T extends CollectionKind.map ? Map<any, any> : T extends CollectionKind.set ? Set<any> : T extends CollectionKind.keyed ? Set<any> \| Map<any, any> : never;
		declare type ObservedCollectionKindToType<T> = T extends CollectionKind.array ? IObservedArray : T extends CollectionKind.indexed ? IObservedArray : T extends CollectionKind.map ? IObservedMap : T extends CollectionKind.set ? IObservedSet : T extends CollectionKind.keyed ? IObservedSet \| IObservedMap : never;
		export declare type LengthPropertyName<T> = T extends any[] ? 'length' : T extends Set<any> ? 'size' : T extends Map<any, any> ? 'size' : never;
		export declare type CollectionTypeToKind<T> = T extends any[] ? CollectionKind.array \| CollectionKind.indexed : T extends Set<any> ? CollectionKind.set \| CollectionKind.keyed : T extends Map<any, any> ? CollectionKind.map \| CollectionKind.keyed : never;
		export declare type CollectionKindToType<T> = T extends CollectionKind.array ? any[] : T extends CollectionKind.indexed ? any[] : T extends CollectionKind.map ? Map<any, any> : T extends CollectionKind.set ? Set<any> : T extends CollectionKind.keyed ? Set<any> \| Map<any, any> : never;
		export declare type ObservedCollectionKindToType<T> = T extends CollectionKind.array ? IObservedArray : T extends CollectionKind.indexed ? IObservedArray : T extends CollectionKind.map ? IObservedMap : T extends CollectionKind.set ? IObservedSet : T extends CollectionKind.keyed ? IObservedSet \| IObservedMap : never;
		/**
		@@ -217,0 +219,0 @@ * An observer that tracks collection mutations and notifies subscribers (either directly or in batches)

dist/binding/observer-locator.d.ts

		import { IIndexable, Primitive } from '@aurelia/kernel';
		import { IBindingContext, IOverrideContext } from './binding-context';
		import { IChangeSet } from './change-set';
		import { IDirtyChecker } from './dirty-checker';
		import { IEventManager } from './event-manager';
		import { AccessorOrObserver, CollectionKind, IBindingTargetAccessor, IBindingTargetObserver, ICollectionObserver, IObservable, IObservedArray, IObservedMap, IObservedSet } from './observation';
		import { AccessorOrObserver, CollectionKind, CollectionObserver, IBindingTargetAccessor, IBindingTargetObserver, ICollectionObserver, IObservable, IObservedArray, IObservedMap, IObservedSet } from './observation';
		import { ISVGAnalyzer } from './svg-analyzer';
		@@ -26,3 +27,3 @@ export interface IObjectObservationAdapter {
		constructor(changeSet: IChangeSet, eventManager: IEventManager, dirtyChecker: IDirtyChecker, svgAnalyzer: ISVGAnalyzer);
		getObserver(obj: IObservable, propertyName: string): AccessorOrObserver;
		getObserver(obj: IObservable \| IBindingContext \| IOverrideContext, propertyName: string): AccessorOrObserver;
		addAdapter(adapter: IObjectObservationAdapter): void;
		@@ -38,2 +39,3 @@ getAccessor(obj: IObservable, propertyName: string): IBindingTargetAccessor;
		}
		export declare function getCollectionObserver(changeSet: IChangeSet, collection: IObservedMap \| IObservedSet \| IObservedArray): CollectionObserver;
		//# sourceMappingURL=observer-locator.d.ts.map

dist/binding/ref.d.ts

		import { IServiceLocator } from '@aurelia/kernel';
		import { IExpression } from './ast';
		import { IsBindingBehavior, StrictAny } from './ast';
		import { IBinding, IBindingTarget } from './binding';
		import { IScope } from './binding-context';
		import { BindingFlags } from './binding-flags';
		import { IConnectableBinding } from './connectable';
		export interface Ref extends IConnectableBinding {
		}
		export declare class Ref implements IBinding {
		sourceExpression: IExpression;
		sourceExpression: IsBindingBehavior;
		target: IBindingTarget;
		locator: IServiceLocator;
		$isBound: boolean;
		private $scope;
		constructor(sourceExpression: IExpression, target: IBindingTarget, locator: IServiceLocator);
		$scope: IScope;
		constructor(sourceExpression: IsBindingBehavior, target: IBindingTarget, locator: IServiceLocator);
		$bind(flags: BindingFlags, scope: IScope): void;
		$unbind(flags: BindingFlags): void;
		observeProperty(context: any, name: any): void;
		observeProperty(obj: StrictAny, propertyName: StrictAny): void;
		handleChange(newValue: any, previousValue: any, flags: BindingFlags): void;
		}
		//# sourceMappingURL=ref.d.ts.map

dist/binding/resources/self-binding-behavior.d.ts

		@@ -5,3 +5,3 @@ import { IScope } from '../binding-context';
		export declare type SelfableBinding = Listener & {
		selfEventCallSource: (event: Event) => any;
		selfEventCallSource: Listener['callSource'];
		};
		@@ -8,0 +8,0 @@ export declare class SelfBindingBehavior {

dist/binding/signaler.d.ts

		@@ -0,5 +1,8 @@
		import { Immutable } from '@aurelia/kernel';
		import { BindingFlags } from './binding-flags';
		import { IPropertySubscriber } from './observation';
		declare type Signal = string;
		export interface ISignaler {
		dispatchSignal(name: Signal): void;
		signals: Immutable<Record<string, Set<IPropertySubscriber>>>;
		dispatchSignal(name: Signal, flags?: BindingFlags): void;
		addSignalListener(name: Signal, listener: IPropertySubscriber): void;
		@@ -6,0 +9,0 @@ removeSignalListener(name: Signal, listener: IPropertySubscriber): void;

dist/binding/target-accessors.d.ts

		@@ -63,11 +63,8 @@ import { IIndexable, Primitive } from '@aurelia/kernel';
		}
		export interface PropertyAccessor extends IBindingTargetAccessor<IIndexable, string, Primitive \| IIndexable> {
		export interface ElementPropertyAccessor extends IBindingTargetAccessor<IIndexable, string, Primitive \| IIndexable> {
		}
		export declare class PropertyAccessor implements PropertyAccessor {
		export declare class ElementPropertyAccessor implements ElementPropertyAccessor {
		changeSet: IChangeSet;
		obj: IIndexable;
		propertyKey: string;
		currentValue: string;
		oldValue: string;
		defaultValue: string;
		constructor(changeSet: IChangeSet, obj: IIndexable, propertyKey: string);
		@@ -77,2 +74,11 @@ getValue(): Primitive \| IIndexable;
		}
		export interface PropertyAccessor extends IBindingTargetAccessor<IIndexable, string, Primitive \| IIndexable> {
		}
		export declare class PropertyAccessor implements PropertyAccessor {
		obj: IIndexable;
		propertyKey: string;
		constructor(obj: IIndexable, propertyKey: string);
		getValue(): Primitive \| IIndexable;
		setValue(value: Primitive \| IIndexable): void;
		}
		//# sourceMappingURL=target-accessors.d.ts.map

dist/dom.d.ts

		import { IContainer, IResolver } from '@aurelia/kernel';
		import { ICustomElement } from '.';
		export interface INodeLike {
		@@ -12,4 +13,7 @@ readonly firstChild: INode \| null;
		}
		export interface ICustomElementHost extends INode {
		$customElement?: ICustomElement;
		}
		export declare const INode: import("@aurelia/kernel/dist/di").InterfaceSymbol<INode>;
		export interface IRenderLocation extends INode {
		export interface IRenderLocation extends ICustomElementHost {
		}
		@@ -76,4 +80,3 @@ export declare const IRenderLocation: import("@aurelia/kernel/dist/di").InterfaceSymbol<IRenderLocation>;
		empty: INodeSequence;
		fromNode(node: INode): INodeSequence;
		};
		//# sourceMappingURL=dom.d.ts.map

dist/index.d.ts

		@@ -6,3 +6,2 @@ export * from './binding/index';
		export * from './resource';
		export * from './task-queue';
		//# sourceMappingURL=index.d.ts.map

dist/templating/custom-attribute.d.ts

		@@ -1,2 +0,2 @@
		import { Constructable, Omit, Immutable } from '@aurelia/kernel';
		import { Constructable, Immutable, Omit } from '@aurelia/kernel';
		import { IScope } from '../binding/binding-context';
		@@ -3,0 +3,0 @@ import { BindingMode } from '../binding/binding-mode';

dist/templating/custom-element.d.ts

		@@ -1,13 +0,19 @@
		import { Constructable, Immutable } from '@aurelia/kernel';
		import { INode, INodeSequence, IRenderLocation } from '../dom';
		import { Immutable, Omit } from '@aurelia/kernel';
		import { BindingFlags } from '../binding/binding-flags';
		import { ICustomElementHost, INode, INodeSequence, IRenderLocation } from '../dom';
		import { IResourceKind, IResourceType } from '../resource';
		import { IHydrateElementInstruction, ITemplateSource, TemplateDefinition } from './instructions';
		import { IAttach, IBindSelf } from './lifecycle';
		import { IAttach, ILifecycleHooks } from './lifecycle';
		import { IRenderable } from './renderable';
		import { IRenderingEngine } from './rendering-engine';
		export interface ICustomElementType extends IResourceType<ITemplateSource, ICustomElement> {
		export interface ICustomElementType extends IResourceType<ITemplateSource, ICustomElement>, Immutable<Pick<Partial<ITemplateSource>, 'containerless' \| 'shadowOptions' \| 'bindables'>> {
		}
		export declare type IElementHydrationOptions = Immutable<Pick<IHydrateElementInstruction, 'parts'>>;
		export interface ICustomElement extends IBindSelf, IAttach, Readonly<IRenderable> {
		readonly $projector: IViewProjector;
		export interface IBindSelf {
		readonly $isBound: boolean;
		$bind(flags: BindingFlags): void;
		$unbind(flags: BindingFlags): void;
		}
		export interface ICustomElement extends IBindSelf, IAttach, Omit<ILifecycleHooks, Exclude<keyof IRenderable, '$addNodes' \| '$removeNodes'>>, Readonly<IRenderable> {
		readonly $projector: IElementProjector;
		$hydrate(renderingEngine: IRenderingEngine, host: INode, options?: IElementHydrationOptions): void;
		@@ -19,3 +25,3 @@ }
		*/
		export declare function customElement(nameOrSource: string \| ITemplateSource): <T extends Constructable<{}>>(target: T) => T & ICustomElementType;
		export declare function customElement(nameOrSource: string \| ITemplateSource): any;
		/**
		@@ -30,3 +36,3 @@ * Decorator: Indicates that the custom element should render its view in Shadow
		*/
		export declare function containerless(target?: any): any;
		export declare function containerless(maybeTarget?: any): any;
		export interface ICustomElementResource extends IResourceKind<ITemplateSource, ICustomElementType> {
		@@ -36,35 +42,40 @@ behaviorFor(node: INode): ICustomElement \| null;
		export declare const CustomElementResource: ICustomElementResource;
		export interface IViewProjector {
		readonly host: INode;
		readonly children: ArrayLike<INode>;
		onChildrenChanged(callback: () => void): void;
		provideEncapsulationSource(parentEncapsulationSource: INode): INode;
		export interface IElementProjector {
		readonly host: ICustomElementHost;
		readonly children: ArrayLike<ICustomElementHost>;
		provideEncapsulationSource(parentEncapsulationSource: ICustomElementHost): ICustomElementHost;
		project(nodes: INodeSequence): void;
		subscribeToChildrenChange(callback: () => void): void;
		}
		export declare class ShadowDOMProjector implements IViewProjector {
		host: INode;
		shadowRoot: INode;
		constructor(customElement: ICustomElement, host: INode, definition: TemplateDefinition);
		export declare class ShadowDOMProjector implements IElementProjector {
		host: ICustomElementHost;
		shadowRoot: ICustomElementHost;
		constructor($customElement: ICustomElement, host: ICustomElementHost, definition: TemplateDefinition);
		readonly children: ArrayLike<INode>;
		onChildrenChanged(callback: () => void): void;
		subscribeToChildrenChange(callback: () => void): void;
		provideEncapsulationSource(parentEncapsulationSource: INode): INode;
		project(nodes: INodeSequence): void;
		onElementRemoved(): void;
		}
		export declare class ContainerlessProjector implements IViewProjector {
		export declare class ContainerlessProjector implements IElementProjector {
		private $customElement;
		host: IRenderLocation;
		private childNodes;
		constructor(customElement: ICustomElement, host: INode);
		private requiresMount;
		constructor($customElement: ICustomElement, host: ICustomElementHost);
		readonly children: ArrayLike<INode>;
		onChildrenChanged(callback: () => void): void;
		subscribeToChildrenChange(callback: () => void): void;
		provideEncapsulationSource(parentEncapsulationSource: INode): INode;
		project(nodes: INodeSequence): void;
		onElementRemoved(): void;
		}
		export declare class HostProjector implements IViewProjector {
		host: INode;
		constructor(customElement: ICustomElement, host: INode);
		export declare class HostProjector implements IElementProjector {
		host: ICustomElementHost;
		constructor($customElement: ICustomElement, host: ICustomElementHost);
		readonly children: ArrayLike<INode>;
		onChildrenChanged(callback: () => void): void;
		subscribeToChildrenChange(callback: () => void): void;
		provideEncapsulationSource(parentEncapsulationSource: INode): INode;
		project(nodes: INodeSequence): void;
		onElementRemoved(): void;
		}
		//# sourceMappingURL=custom-element.d.ts.map

dist/templating/index.d.ts

		export * from './resources';
		export * from './animator';
		export * from './bindable';
		@@ -4,0 +3,0 @@ export * from './custom-attribute';

dist/templating/instructions.d.ts

		import { Immutable } from '@aurelia/kernel';
		import { IExpression } from '../binding/ast';
		import { ForOfStatement, Interpolation, IsBindingBehavior } from '../binding/ast';
		import { BindingMode } from '../binding/binding-mode';
		@@ -10,15 +10,17 @@ import { DelegationStrategy } from '../binding/event-manager';
		textBinding = "a",
		propertyBinding = "b",
		listenerBinding = "c",
		callBinding = "d",
		refBinding = "e",
		stylePropertyBinding = "f",
		setProperty = "g",
		setAttribute = "h",
		hydrateElement = "i",
		hydrateAttribute = "j",
		hydrateTemplateController = "k",
		letElement = "l",
		letBinding = "m",
		renderStrategy = "n"
		interpolation = "b",
		propertyBinding = "c",
		iteratorBinding = "d",
		listenerBinding = "e",
		callBinding = "f",
		refBinding = "g",
		stylePropertyBinding = "h",
		setProperty = "i",
		setAttribute = "j",
		hydrateElement = "k",
		hydrateAttribute = "l",
		hydrateTemplateController = "m",
		letElement = "n",
		letBinding = "o",
		renderStrategy = "z"
		}
		@@ -49,18 +51,33 @@ export interface IBuildInstruction {
		}
		export declare type TargetedInstruction = ITextBindingInstruction \| IPropertyBindingInstruction \| IListenerBindingInstruction \| ICallBindingInstruction \| IRefBindingInstruction \| IStylePropertyBindingInstruction \| ISetPropertyInstruction \| ISetAttributeInstruction \| IHydrateElementInstruction \| IHydrateAttributeInstruction \| IHydrateTemplateController \| IRenderStrategyInstruction \| ILetElementInstruction;
		export declare type TargetedInstruction = ITextBindingInstruction \| IInterpolationInstruction \| IPropertyBindingInstruction \| IIteratorBindingInstruction \| IListenerBindingInstruction \| ICallBindingInstruction \| IRefBindingInstruction \| IStylePropertyBindingInstruction \| ISetPropertyInstruction \| ISetAttributeInstruction \| IHydrateElementInstruction \| IHydrateAttributeInstruction \| IHydrateTemplateController \| IRenderStrategyInstruction \| ILetElementInstruction;
		export declare function isTargetedInstruction(value: any): value is TargetedInstruction;
		export interface ITextBindingInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.textBinding;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| Interpolation;
		}
		export interface IInterpolationInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.interpolation;
		srcOrExpr: string \| Interpolation;
		dest: string;
		}
		export interface IInterpolationInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.interpolation;
		srcOrExpr: string \| Interpolation;
		dest: string;
		}
		export interface IPropertyBindingInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.propertyBinding;
		mode: BindingMode;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| IsBindingBehavior;
		dest: string;
		oneTime?: boolean;
		}
		export interface IIteratorBindingInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.iteratorBinding;
		srcOrExpr: string \| ForOfStatement;
		dest: string;
		}
		export interface IListenerBindingInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.listenerBinding;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| IsBindingBehavior;
		dest: string;
		@@ -72,3 +89,3 @@ strategy: DelegationStrategy;
		type: TargetedInstructionType.callBinding;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| IsBindingBehavior;
		dest: string;
		@@ -78,7 +95,7 @@ }
		type: TargetedInstructionType.refBinding;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| IsBindingBehavior;
		}
		export interface IStylePropertyBindingInstruction extends ITargetedInstruction {
		type: TargetedInstructionType.stylePropertyBinding;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| IsBindingBehavior;
		dest: string;
		@@ -125,5 +142,5 @@ }
		type: TargetedInstructionType.letBinding;
		srcOrExpr: string \| IExpression;
		srcOrExpr: string \| IsBindingBehavior \| Interpolation;
		dest: string;
		}
		//# sourceMappingURL=instructions.d.ts.map

297

dist/templating/lifecycle.d.ts

		@@ -1,41 +0,268 @@
		import { BindingFlags } from '../binding/binding-flags';
		import { INode } from '../dom';
		import { IRenderable } from './renderable';
		export declare class AttachLifecycle {
		private owner;
		private tail;
		private head;
		private $nextAttached;
		private constructor();
		static start(owner: any, existingLifecycle?: AttachLifecycle): AttachLifecycle;
		queueAttachedCallback(requestor: IAttach): void;
		end(owner: any): void;
		private attached;
		import { Immutable, Omit } from '@aurelia/kernel';
		import { ICustomElementType, IHydrateElementInstruction, IRenderable, IRenderingEngine, ITemplate } from '.';
		import { BindingFlags } from '../binding';
		import { INode, INodeSequence } from '../dom';
		export declare enum LifecycleFlags {
		none = 1,
		noTasks = 2,
		unbindAfterDetached = 4
		}
		export declare class DetachLifecycle {
		private owner;
		private detachedHead;
		private detachedTail;
		private viewRemoveHead;
		private viewRemoveTail;
		private $nextDetached;
		private $nextRemoveView;
		private $nodes;
		private constructor();
		static start(owner: any, existingLifecycle?: DetachLifecycle): DetachLifecycle;
		queueViewRemoval(requestor: IRenderable): void;
		queueDetachedCallback(requestor: IAttach): void;
		end(owner: any): void;
		private detached;
		}
		export interface IAttach {
		readonly $isAttached: boolean;
		$attach(encapsulationSource: INode, lifecycle?: AttachLifecycle): void;
		$detach(lifecycle?: DetachLifecycle): void;
		$attach(encapsulationSource: INode, lifecycle: IAttachLifecycle): void;
		$detach(lifecycle: IDetachLifecycle): void;
		$cache(): void;
		}
		export interface IBindSelf {
		readonly $isBound: boolean;
		$bind(flags: BindingFlags): void;
		$unbind(flags: BindingFlags): void;
		export interface IElementTemplateProvider {
		getElementTemplate(renderingEngine: IRenderingEngine, customElementType: ICustomElementType): ITemplate;
		}
		/**
		* Defines optional lifecycle hooks that will be called only when they are implemented.
		*/
		export interface ILifecycleHooks extends Partial<Omit<IRenderable, '$addNodes' \| '$removeNodes'>> {
		/**
		* Only applies to `@customElement`. This hook is not invoked for `@customAttribute`s
		*
		* Called during `$hydrate`, after `this.$scope` and `this.$projector` are set.
		*
		* If this hook is implemented, it will be used instead of `renderingEngine.getElementTemplate`.
		* This allows you to completely override the default rendering behavior.
		*
		* In addition to providing the return value, it is the responsibility of the implementer to:
		* - Populate `this.$bindables` with any Bindings, child Views, custom elements and custom attributes
		* - Populate `this.$attachables` with any child Views, custom elements and custom attributes
		*
		* @param host The DOM node that declares this custom element
		* @param parts Replaceable parts, if any
		*
		* @returns Either an instance of `INodeSequence` with the nodes that need to be appended to the host,
		* or an implementation of `IElementTemplateProvider`
		*
		* @description
		* This is the first "hydrate" lifecycle hook. It happens only once per instance (contrary to bind/attach
		* which can happen many times per instance), though it can happen many times per type (once for each instance)
		*/
		render?(host: INode, parts: Immutable<Pick<IHydrateElementInstruction, 'parts'>>): IElementTemplateProvider \| INodeSequence;
		/**
		* Called at the end of `$hydrate`.
		*
		* The following key properties are now assigned and initialized (see `IRenderable` for more detail):
		* - `this.$bindables`
		* - `this.$attachables`
		* - `this.$scope` (null if this is a custom attribute, or contains the view model if this is a custom element)
		* - `this.$nodes`
		*
		* @description
		* This is the second and last "hydrate" lifecycle hook (after `render`). It happens only once per instance (contrary to bind/attach
		* which can happen many times per instance), though it can happen many times per type (once for each instance)
		*
		* This hook is called right before the `$bind` lifecycle starts, making this the last opportunity
		* for any high-level post processing on initialized properties.
		*/
		created?(): void;
		/**
		* Called at the start of `$bind`, before this instance and its children (if any) are bound.
		*
		* - `this.$isBound` is false.
		* - `this.$scope` is initialized.
		*
		* @param flags Contextual information about the lifecycle, such as what triggered it.
		* Some uses for this hook:
		* - `flags & BindingFlags.fromStartTask`: the Aurelia app is starting (this is the initial bind)
		* - `flags & BindingFlags.fromBind`: this is a normal `$bind` lifecycle
		* - `flags & BindingFlags.updateTargetInstance`: this `$bind` was triggered by some upstream observer and is not a real `$bind` lifecycle
		* - `flags & BindingFlags.fromFlushChanges` (only occurs in conjunction with updateTargetInstance): the update was queued to a `ChangeSet` which is now being flushed
		*
		* @description
		* This is the first "create" lifecycle hook of the hooks that can occur multiple times per instance,
		* and the third lifecycle hook (after `render` and `created`) of the very first lifecycle.
		*/
		binding?(flags: BindingFlags): void;
		/**
		* Called at the end of `$bind`, after this instance and its children (if any) are bound.
		*
		* - `$isBound` is true.
		* - `this.$scope` is initialized.
		*
		* @param flags Contextual information about the lifecycle, such as what triggered it.
		* Some uses for this hook:
		* - `flags & BindingFlags.fromStartTask`: the Aurelia app is starting (this is the initial bind)
		* - `flags & BindingFlags.fromBind`: this is a normal `$bind` lifecycle
		* - `flags & BindingFlags.updateTargetInstance`: this `$bind` was triggered by some upstream observer and is not a real `$bind` lifecycle
		* - `flags & BindingFlags.fromFlushChanges` (only occurs in conjunction with updateTargetInstance): the update was queued to a `ChangeSet` which is now being flushed
		*
		* @description
		* This is the second "create" lifecycle hook (after `binding`) of the hooks that can occur multiple times per instance,
		* and the fourth lifecycle hook (after `render`, `created` and `binding`) of the very first lifecycle.
		*/
		bound?(flags: BindingFlags): void;
		/**
		* Called at the start of `$attach`, before this instance and its children (if any) are attached.
		*
		* `$isAttached` is false.
		*
		* @param encapsulationSource Ask Rob.
		* @param lifecycle Utility that encapsulates the attach sequence for a hierarchy of attachables and guarantees the correct attach order.
		*
		* @description
		* This is the third "create" lifecycle hook (after `binding` and `bound`) of the hooks that can occur multiple times per instance,
		* and the fifth lifecycle hook (after `render`, `created`, `binding` and `bound`) of the very first lifecycle
		*
		* This is the time to add any (sync or async) tasks (e.g. animations) to the lifecycle that need to happen before
		* the nodes are added to the DOM.
		*/
		attaching?(encapsulationSource: INode, lifecycle: IAttachLifecycle): void;
		/**
		* Called at the end of `$attach`, after this instance and its children (if any) are attached.
		*
		* - `$isAttached` is true.
		*
		* @description
		* This is the fourth (and last) "create" lifecycle hook (after `binding`, `bound` and `attaching`) of the hooks that can occur
		* multiple times per instance, and the sixth lifecycle hook (after `render`, `created`, `binding`, `bound` and `attaching`)
		* of the very first lifecycle
		*
		* This instance and its children (if any) can be assumed
		* to be fully initialized, bound, rendered, added to the DOM and ready for use.
		*/
		attached?(): void;
		/**
		* Called at the start of `$detach`, before this instance and its children (if any) are detached.
		*
		* - `$isAttached` is true.
		*
		* @param lifecycle Utility that encapsulates the detach sequence for a hierarchy of attachables and guarantees the correct detach order.
		*
		* @description
		* This is the first "cleanup" lifecycle hook.
		*
		* This is the time to add any (sync or async) tasks (e.g. animations) to the lifecycle that need to happen before
		* the nodes are removed from the DOM.
		*/
		detaching?(lifecycle: IDetachLifecycle): void;
		/**
		* Called during `$removeNodes` (which happens during `$detach`), specifically after the
		* `$nodes` are removed from the DOM, but before the view is actually added to the cache.
		*
		* @description
		* This is the second "cleanup" lifecycle hook.
		*
		* This lifecycle is invoked if and only if the `ViewFactory` that created the `View` allows the view to be cached.
		*
		* Usually this hook is not invoked unless you explicitly set the cache size to to something greater than zero
		* on the resource description.
		*/
		caching?(): void;
		/**
		* Called at the end of `$detach`, after this instance and its children (if any) are detached.
		*
		* - `$isAttached` is false.
		*
		* @description
		* This is the third "cleanup" lifecycle hook (after `detaching` and `caching`).
		*
		* The `$nodes` are now removed from the DOM and the `View` (if possible) is returned to cache.
		*
		* If no `$unbind` lifecycle is queued, this is the last opportunity to make state changes before the lifecycle ends.
		*/
		detached?(): void;
		/**
		* Called at the start of `$unbind`, before this instance and its children (if any) are unbound.
		*
		* - `this.$isBound` is true.
		* - `this.$scope` is still available.
		*
		* @param flags Contextual information about the lifecycle, such as what triggered it.
		* Some uses for this hook:
		* - `flags & BindingFlags.fromBind`: the component is just switching scope
		* - `flags & BindingFlags.fromUnbind`: the component is really disposing
		* - `flags & BindingFlags.fromStopTask`: the Aurelia app is stopping
		*
		* @description
		* This is the fourth "cleanup" lifecycle hook (after `detaching`, `caching` and `detached`)
		*
		* Last opportunity to perform any source or target updates before the bindings are disconnected.
		*
		*/
		unbinding?(flags: BindingFlags): void;
		/**
		* Called at the end of `$unbind`, after this instance and its children (if any) are unbound.
		*
		* - `this.$isBound` is false at this point.
		*
		* - `this.$scope` may not be available anymore (unless it's a `@customElement`)
		*
		* @param flags Contextual information about the lifecycle, such as what triggered it.
		* Some uses for this hook:
		* - `flags & BindingFlags.fromBind`: the component is just switching scope
		* - `flags & BindingFlags.fromUnbind`: the component is really disposing
		* - `flags & BindingFlags.fromStopTask`: the Aurelia app is stopping
		*
		* @description
		* This is the fifth (and last) "cleanup" lifecycle hook (after `detaching`, `caching`, `detached`
		* and `unbinding`).
		*
		* The lifecycle either ends here, or starts at `$bind` again.
		*/
		unbound?(flags: BindingFlags): void;
		}
		export interface ILifecycleTask {
		readonly done: boolean;
		canCancel(): boolean;
		cancel(): void;
		wait(): Promise<void>;
		}
		export interface IAttachLifecycleController {
		attach(requestor: IAttach): IAttachLifecycleController;
		end(): ILifecycleTask;
		}
		declare type LifecycleAttachable = {
		attached(): void;
		};
		declare type LifecycleNodeAddable = Pick<IRenderable, '$addNodes'> & {};
		export interface IAttachLifecycle {
		readonly flags: LifecycleFlags;
		registerTask(task: ILifecycleTask): void;
		createChild(): IAttachLifecycle;
		queueAddNodes(requestor: LifecycleNodeAddable): void;
		queueAttachedCallback(requestor: LifecycleAttachable): void;
		}
		export interface IDetachLifecycleController {
		detach(requestor: IAttach): IDetachLifecycleController;
		end(): ILifecycleTask;
		}
		declare type LifecycleDetachable = {
		detached(): void;
		};
		declare type LifecycleNodeRemovable = Pick<IRenderable, '$removeNodes'> & {};
		export declare class AggregateLifecycleTask implements ILifecycleTask {
		done: boolean;
		private tasks;
		private waiter;
		private resolve;
		addTask(task: ILifecycleTask): void;
		canCancel(): boolean;
		cancel(): void;
		wait(): Promise<void>;
		private tryComplete;
		private complete;
		}
		export interface IDetachLifecycle {
		readonly flags: LifecycleFlags;
		registerTask(task: ILifecycleTask): void;
		createChild(): IDetachLifecycle;
		queueRemoveNodes(requestor: LifecycleNodeRemovable): void;
		queueDetachedCallback(requestor: LifecycleDetachable): void;
		}
		export declare const Lifecycle: {
		beginAttach(encapsulationSource: INode, flags: LifecycleFlags): IAttachLifecycleController;
		beginDetach(flags: LifecycleFlags): IDetachLifecycleController;
		done: {
		done: boolean;
		canCancel(): boolean;
		cancel(): void;
		wait(): Promise<void>;
		};
		};
		export {};
		//# sourceMappingURL=lifecycle.d.ts.map

dist/templating/renderable.d.ts

		import { IScope } from '../binding/binding-context';
		import { BindingFlags } from '../binding/binding-flags';
		import { IBindScope } from '../binding/observation';
		@@ -8,13 +7,49 @@ import { INodeSequence } from '../dom';
		export declare const IRenderable: import("@aurelia/kernel/dist/di").InterfaceSymbol<IRenderable>;
		/**
		* An object containing the necessary information to render something for display.
		*/
		export interface IRenderable {
		/**
		* The (dependency) context of this instance.
		*
		* Contains any dependencies required by this instance or its children.
		*/
		readonly $context: IRenderContext;
		/**
		* The nodes that represent the visible aspect of this instance.
		*
		* Typically this will be a sequence of `DOM` nodes contained in a `DocumentFragment`
		*/
		readonly $nodes: INodeSequence;
		/**
		* The binding scope that the `$bindables` of this instance will be bound to.
		*
		* This includes the `BindingContext` which can be either a user-defined view model instance, or a synthetic view model instantiated by a `templateController`
		*/
		readonly $scope: IScope;
		/**
		* Indicates whether the `$scope` is bound to the `$bindables`
		*/
		readonly $isBound: boolean;
		/**
		* The Bindings, Views, CustomElements, CustomAttributes and other bindable components that belong to this instance.
		*/
		readonly $bindables: IBindScope[];
		/**
		* Indicates whether the `$attachables` are currently attached to the `DOM`.
		*/
		readonly $isAttached: boolean;
		/**
		* The Views, CustomElements, CustomAttributes and other attachable components that belong to this instance.
		*/
		readonly $attachables: IAttach[];
		$addChild(child: IAttach \| IBindScope, flags: BindingFlags): void;
		$removeChild(child: IAttach \| IBindScope): void;
		/**
		* Add the `$nodes` of this instance to the Host or RenderLocation that this instance is attached to.
		*/
		$addNodes(): void;
		/**
		* Remove the `$nodes` of this instance from the Host or RenderLocation that this instance is attached to, optionally returning them to a cache.
		*/
		$removeNodes(): void;
		}
		//# sourceMappingURL=renderable.d.ts.map

dist/templating/rendering-engine.d.ts

		@@ -6,3 +6,2 @@ import { IContainer, Immutable } from '@aurelia/kernel';
		import { IObserverLocator } from '../binding/observer-locator';
		import { IAnimator } from './animator';
		import { ICustomAttribute, ICustomAttributeType } from './custom-attribute';
		@@ -30,3 +29,2 @@ import { ICustomElement, ICustomElementType } from './custom-element';
		private parser;
		private animator;
		private templateLookup;
		@@ -36,3 +34,3 @@ private factoryLookup;
		private compilers;
		constructor(container: IContainer, changeSet: IChangeSet, observerLocator: IObserverLocator, eventManager: IEventManager, parser: IExpressionParser, animator: IAnimator, templateCompilers: ITemplateCompiler[]);
		constructor(container: IContainer, changeSet: IChangeSet, observerLocator: IObserverLocator, eventManager: IEventManager, parser: IExpressionParser, templateCompilers: ITemplateCompiler[]);
		getElementTemplate(definition: TemplateDefinition, componentType?: ICustomElementType): ITemplate;
		@@ -39,0 +37,0 @@ getViewFactory(definition: Immutable<ITemplateSource>, parentContext?: IRenderContext): IViewFactory;

dist/templating/resources/compose.d.ts

		@@ -1,6 +0,12 @@
		import { Immutable } from '@aurelia/kernel';
		import { Constructable, Immutable } from '@aurelia/kernel';
		import { BindingFlags } from '../../binding/binding-flags';
		import { INode } from '../../dom';
		import { PotentialRenderable } from '../create-element';
		import { ICustomElement } from '../custom-element';
		import { IHydrateElementInstruction } from '../instructions';
		import { IHydrateElementInstruction, TemplateDefinition } from '../instructions';
		import { IAttachLifecycle, IDetachLifecycle } from '../lifecycle';
		import { IRenderable } from '../renderable';
		import { IRenderingEngine } from '../rendering-engine';
		import { IView, IViewFactory } from '../view';
		declare type Subject = IViewFactory \| IView \| PotentialRenderable \| Constructable \| TemplateDefinition;
		export interface Compose extends ICustomElement {
		@@ -11,12 +17,19 @@ }
		private renderingEngine;
		subject: any;
		subject: Subject \| Promise<Subject>;
		composing: boolean;
		private task;
		private currentView;
		private properties;
		private coordinator;
		private lastSubject;
		constructor(renderable: IRenderable, instruction: Immutable<IHydrateElementInstruction>, renderingEngine: IRenderingEngine);
		binding(flags: BindingFlags): void;
		attaching(encapsulationSource: INode, lifecycle: IAttachLifecycle): void;
		detaching(lifecycle: IDetachLifecycle): void;
		unbinding(flags: BindingFlags): void;
		caching(): void;
		subjectChanged(newValue: any): void;
		private startComposition;
		private resolveView;
		private provideViewFor;
		private startComposition;
		private clear;
		}
		export {};
		//# sourceMappingURL=compose.d.ts.map

dist/templating/resources/if.d.ts

		@@ -0,4 +1,7 @@
		import { BindingFlags } from '../../binding/binding-flags';
		import { INode, IRenderLocation } from '../../dom';
		import { ICustomAttribute } from '../custom-attribute';
		import { IViewFactory } from '../view';
		import { IAttachLifecycle, IDetachLifecycle } from '../lifecycle';
		import { IView, IViewFactory } from '../view';
		import { CompositionCoordinator } from './composition-coordinator';
		export interface If extends ICustomAttribute {
		@@ -8,18 +11,17 @@ }
		ifFactory: IViewFactory;
		private location;
		location: IRenderLocation;
		value: boolean;
		elseFactory: IViewFactory;
		private ifView;
		private elseView;
		private $child;
		private encapsulationSource;
		ifView: IView;
		elseView: IView;
		coordinator: CompositionCoordinator;
		constructor(ifFactory: IViewFactory, location: IRenderLocation);
		bound(): void;
		attaching(encapsulationSource: INode): void;
		unbound(): void;
		valueChanged(newValue: any): void;
		private update;
		private activateBranch;
		private ensureViewCreated;
		private deactivateCurrentBranch;
		binding(flags: BindingFlags): void;
		attaching(encapsulationSource: INode, lifecycle: IAttachLifecycle): void;
		detaching(lifecycle: IDetachLifecycle): void;
		unbinding(flags: BindingFlags): void;
		caching(): void;
		valueChanged(): void;
		private updateView;
		private ensureView;
		}
		@@ -26,0 +28,0 @@ export declare class Else {

dist/templating/resources/repeat.d.ts

		@@ -1,18 +0,10 @@
		import { IContainer, Immutable } from '@aurelia/kernel';
		import { ForOfStatement } from '../../binding/ast';
		import { IScope } from '../../binding/binding-context';
		import { BindingFlags } from '../../binding/binding-flags';
		import { IChangeSet } from '../../binding/change-set';
		import { CollectionObserver, IObservedArray, IObservedSet, ObservedCollection } from '../../binding/observation';
		import { BindingFlags, CollectionObserver, ForOfStatement, IBatchedCollectionSubscriber, IChangeSet, IObservedArray, IScope, ObservedCollection, SetterObserver } from '../../binding';
		import { INode, IRenderLocation } from '../../dom';
		import { IResourceKind, IResourceType } from '../../resource';
		import { ICustomAttribute, ICustomAttributeSource } from '../custom-attribute';
		import { AttachLifecycle, DetachLifecycle } from '../lifecycle';
		import { ICustomAttribute } from '../custom-attribute';
		import { IAttachLifecycle, IDetachLifecycle } from '../lifecycle';
		import { IRenderable } from '../renderable';
		import { IRenderingEngine } from '../rendering-engine';
		import { IRuntimeBehavior } from '../runtime-behavior';
		import { IView, IViewFactory } from '../view';
		import { IBatchedCollectionSubscriber, IObservedMap } from './../../binding/observation';
		export declare function getCollectionObserver(changeSet: IChangeSet, collection: IObservedMap \| IObservedSet \| IObservedArray): CollectionObserver;
		export declare class Repeat<T extends ObservedCollection> implements ICustomAttribute, IBatchedCollectionSubscriber {
		export interface Repeat<T extends ObservedCollection> extends ICustomAttribute, IBatchedCollectionSubscriber {
		}
		export declare class Repeat<T extends ObservedCollection = IObservedArray> {
		changeSet: IChangeSet;
		@@ -22,33 +14,25 @@ location: IRenderLocation;
		factory: IViewFactory;
		container: IContainer;
		static kind: IResourceKind<ICustomAttributeSource, IResourceType<ICustomAttributeSource, ICustomAttribute>>;
		static description: Immutable<Required<ICustomAttributeSource>>;
		static register(container: IContainer): void;
		$changeCallbacks: (() => void)[];
		items: T;
		$isAttached: boolean;
		$isBound: boolean;
		$scope: IScope;
		$behavior: IRuntimeBehavior;
		$hydrate(renderingEngine: IRenderingEngine): void;
		private _items;
		items: T & {
		$observer: CollectionObserver;
		$observers: {
		items: SetterObserver;
		};
		encapsulationSource: INode;
		views: IView[];
		local: string;
		viewsRequireLifecycle: boolean;
		observer: CollectionObserver;
		hasPendingInstanceMutation: boolean;
		sourceExpression: ForOfStatement;
		constructor(changeSet: IChangeSet, location: IRenderLocation, renderable: IRenderable, factory: IViewFactory, container: IContainer);
		$bind(flags: BindingFlags, scope: IScope): void;
		$attach(encapsulationSource: INode, lifecycle: AttachLifecycle): void;
		$detach(lifecycle: DetachLifecycle): void;
		$unbind(flags: BindingFlags): void;
		flushChanges(): void;
		handleBatchedChange(indexMap?: number[]): void;
		private handleBatchedItemsOrInstanceMutation;
		private removeAllViews;
		forOf: ForOfStatement;
		local: string;
		constructor(changeSet: IChangeSet, location: IRenderLocation, renderable: IRenderable, factory: IViewFactory);
		bound(flags: BindingFlags): void;
		attaching(encapsulationSource: INode, lifecycle: IAttachLifecycle): void;
		detaching(lifecycle: IDetachLifecycle): void;
		unbound(flags: BindingFlags): void;
		itemsChanged(newValue: T, oldValue: T, flags: BindingFlags): void;
		handleBatchedChange(indexMap: number[] \| null): void;
		private processViews;
		private checkCollectionObserver;
		}
		//# sourceMappingURL=repeat.d.ts.map

dist/templating/resources/replaceable.d.ts

		@@ -1,5 +0,5 @@
		import { IScope } from '../../binding/binding-context';
		import { BindingFlags } from '../../binding/binding-flags';
		import { IRenderLocation } from '../../dom';
		import { ICustomAttribute } from '../custom-attribute';
		import { IAttachLifecycle, IDetachLifecycle } from '../lifecycle';
		import { IViewFactory } from '../view';
		@@ -10,7 +10,9 @@ export interface Replaceable extends ICustomAttribute {
		private factory;
		private $child;
		private currentView;
		constructor(factory: IViewFactory, location: IRenderLocation);
		bound(flags: BindingFlags, scope: IScope): void;
		unbound(flags: BindingFlags): void;
		binding(flags: BindingFlags): void;
		attaching(encapsulationSource: any, lifecycle: IAttachLifecycle): void;
		detaching(lifecycle: IDetachLifecycle): void;
		unbinding(flags: BindingFlags): void;
		}
		//# sourceMappingURL=replaceable.d.ts.map

dist/templating/resources/with.d.ts

		import { BindingFlags } from '../../binding/binding-flags';
		import { IRenderLocation } from '../../dom';
		import { ICustomAttribute } from '../custom-attribute';
		import { IAttachLifecycle, IDetachLifecycle } from '../lifecycle';
		import { IViewFactory } from '../view';
		@@ -10,9 +11,11 @@ export interface With extends ICustomAttribute {
		value: any;
		private $child;
		private currentView;
		constructor(factory: IViewFactory, location: IRenderLocation);
		valueChanged(): void;
		bound(flags: BindingFlags): void;
		unbound(flags: BindingFlags): void;
		binding(flags: BindingFlags): void;
		attaching(encapsulationSource: any, lifecycle: IAttachLifecycle): void;
		detaching(lifecycle: IDetachLifecycle): void;
		unbinding(flags: BindingFlags): void;
		private bindChild;
		}
		//# sourceMappingURL=with.d.ts.map

dist/templating/runtime-behavior.d.ts

		import { IAccessor, ISubscribable, ISubscriberCollection, MutationKind } from '../binding/observation';
		export interface IRuntimeBehavior {
		readonly hasCreated: boolean;
		readonly hasBinding: boolean;
		readonly hasBound: boolean;
		@@ -9,4 +10,6 @@ readonly hasAttaching: boolean;
		readonly hasDetached: boolean;
		readonly hasUnbinding: boolean;
		readonly hasUnbound: boolean;
		readonly hasRender: boolean;
		readonly hasCaching: boolean;
		}
		@@ -13,0 +16,0 @@ export interface IChildrenObserver extends IAccessor, ISubscribable<MutationKind.instance>, ISubscriberCollection<MutationKind.instance> {

dist/templating/template-compiler.d.ts

		import { IResourceDescriptions } from '../resource';
		import { TemplateDefinition } from './instructions';
		import { ITemplateSource, TemplateDefinition } from './instructions';
		import { ViewCompileFlags } from './view-compile-flags';
		export interface ITemplateCompiler {
		readonly name: string;
		compile(definition: TemplateDefinition, resources: IResourceDescriptions, viewCompileFlags?: ViewCompileFlags): TemplateDefinition;
		compile(definition: ITemplateSource, resources: IResourceDescriptions, viewCompileFlags?: ViewCompileFlags): TemplateDefinition;
		}
		export declare const ITemplateCompiler: import("@aurelia/kernel/dist/di").InterfaceSymbol<ITemplateCompiler>;
		//# sourceMappingURL=template-compiler.d.ts.map

dist/templating/view.d.ts

		import { IScope } from '../binding/binding-context';
		import { IBindScope } from '../binding/observation';
		import { IRenderLocation } from '../dom';
		import { IAttach } from './lifecycle';
		@@ -8,6 +9,5 @@ import { IRenderable } from './renderable';
		readonly factory: IViewFactory;
		onRender: RenderCallback;
		renderState: any;
		mount(location: IRenderLocation): void;
		release(): boolean;
		lockScope(scope: IScope): void;
		tryReturnToCache(): boolean;
		}
		@@ -14,0 +14,0 @@ export interface IViewFactory {

package.json

		{
		"name": "@aurelia/runtime",
		"version": "0.2.0",
		"version": "0.3.0-dev.20181013",
		"main": "dist/index.umd.js",
		@@ -25,2 +25,3 @@ "module": "dist/index.es6.js",
		"dist",
		"src",
		"README.md",
		@@ -46,3 +47,3 @@ "CHANGELOG.md",
		"dependencies": {
		"@aurelia/kernel": "^0.2.0"
		"@aurelia/kernel": "^0.3.0-dev.20181013"
		},
		@@ -88,3 +89,3 @@ "devDependencies": {
		},
		"gitHead": "712101a020943279230b68b075305246f84d1037"
		"gitHead": "6ba681c5c0255796f55855f2e64b3adcc4c494c3"
		}

dist/task-queue.d.ts

dist/task-queue.d.ts.map

dist/templating/animator.d.ts

dist/templating/animator.d.ts.map

dist/aurelia.d.ts.map