@angular-wave/angular.ts 0.7.0-beta.0 → 0.7.0-beta.1

package/src/core/sce/sce.md

@@ -10,29 +10,29 @@
 /\*\*
 
 -
-- `$sce` is a service that provides Strict Contextual Escaping services to AngularJS.
+- `$sce` is a service that provides Strict Contextual Escaping services to AngularTS.
 -
 - ## Strict Contextual Escaping
 -
-- Strict Contextual Escaping (SCE) is a mode in which AngularJS constrains bindings to only render
+- Strict Contextual Escaping (SCE) is a mode in which AngularTS constrains bindings to only render
 - trusted values. Its goal is to assist in writing code in a way that (a) is secure by default, and
 - (b) makes auditing for security vulnerabilities such as XSS, clickjacking, etc. a lot easier.
 -
 - ### Overview
 -
-- To systematically block XSS security bugs, AngularJS treats all values as untrusted by default in
-- HTML or sensitive URL bindings. When binding untrusted values, AngularJS will automatically
+- To systematically block XSS security bugs, AngularTS treats all values as untrusted by default in
+- HTML or sensitive URL bindings. When binding untrusted values, AngularTS will automatically
 - run security checks on them (sanitizations, trusted URL resource, depending on context), or throw
 - when it cannot guarantee the security of the result. That behavior depends strongly on contexts:
 - HTML can be sanitized, but template URLs cannot, for instance.
 -
 - To illustrate this, consider the `ng-bind-html` directive. It renders its value directly as HTML:
-- we call that the _context_. When given an untrusted input, AngularJS will attempt to sanitize it
+- we call that the _context_. When given an untrusted input, AngularTS will attempt to sanitize it
 - before rendering if a sanitizer is available, and throw otherwise. To bypass sanitization and
 - render the input as-is, you will need to mark it as trusted for that context before attempting
 - to bind it.
 -
-- As of version 1.2, AngularJS ships with SCE enabled by default.
+- As of version 1.2, AngularTS ships with SCE enabled by default.
 -
 - ### In practice
 -
@@ -63,7 +63,7 @@
 - ensure that you didn't accidentally delete the line that sanitized the value, or renamed some
 - properties/fields and forgot to update the binding to the sanitized value?
 -
-- To be secure by default, AngularJS makes sure bindings go through that sanitization, or
+- To be secure by default, AngularTS makes sure bindings go through that sanitization, or
 - any similar validation process, unless there's a good reason to trust the given value in this
 - context. That trust is formalized with a function call. This means that as a developer, you
 - can assume all untrusted bindings are safe. Then, to audit your code for binding security issues,
@@ -73,7 +73,7 @@
 - Ensuring that the internal API exposed by that code doesn't markup arbitrary values as safe then
 - becomes a more manageable task.
 -
-- In the case of AngularJS' SCE service, one uses {@link ng.$sce#trustAs $sce.trustAs}
+- In the case of AngularTS' SCE service, one uses {@link ng.$sce#trustAs $sce.trustAs}
 - (and shorthand methods such as {@link ng.$sce#trustAsHtml $sce.trustAsHtml}, etc.) to
 - build the trusted versions of your values.
 -
@@ -84,7 +84,7 @@
 - a way to enforce the required security context in your data sink. Directives use {@link
 - ng.$sce#parseAs $sce.parseAs} rather than `$parse` to watch attribute bindings, which performs
 - the {@link ng.$sce#getTrusted $sce.getTrusted} behind the scenes on non-constant literals. Also,
-- when binding without directives, AngularJS will understand the context of your bindings
+- when binding without directives, AngularTS will understand the context of your bindings
 - automatically.
 -
 - As an example, {@link ng.directive:ngBindHtml ngBindHtml} uses {@link
@@ -112,7 +112,7 @@
 - This applies both to the {@link ng.directive:ngInclude `ng-include`} directive as well as
 - `templateUrl`'s specified by {@link guide/directive directives}.
 -
-- By default, AngularJS only loads templates from the same domain and protocol as the application
+- By default, AngularTS only loads templates from the same domain and protocol as the application
 - document. This is done by calling {@link ng.$sce#getTrustedResourceUrl
 - $sce.getTrustedResourceUrl} on the template URL. To load templates from other domains and/or
 - protocols, you may either add them to the {@link ng.$sceDelegateProvider#trustedResourceUrlList
@@ -136,7 +136,7 @@
 - `<div ng-bind-html="'<b>implicitly trusted</b>'"></div>`) just works (remember to include the
 - `ngSanitize` module). The `$sceDelegate` will also use the `$sanitize` service if it is available
 - when binding untrusted values to `$sce.HTML` context.
-- AngularJS provides an implementation in `angular-sanitize.js`, and if you
+- AngularTS provides an implementation in `angular-sanitize.js`, and if you
 - wish to use it, you will also need to depend on the {@link ngSanitize `ngSanitize`} module in
 - your application.
 -
@@ -165,7 +165,7 @@
 -
 -
 - <div class="alert alert-warning">
-- Be aware that, before AngularJS 1.7.0, `a[href]` and `img[src]` used to sanitize their
+- Be aware that, before AngularTS 1.7.0, `a[href]` and `img[src]` used to sanitize their
 - interpolated values directly rather than rely upon {@link ng.$sce#getTrusted `$sce.getTrusted`}.
 -
 - **As of 1.7.0, this is no longer the case.**
@@ -175,7 +175,7 @@
 - service evaluates the expressions.
 - </div>
 -
-- There are no CSS or JS context bindings in AngularJS currently, so their corresponding `$sce.trustAs`
+- There are no CSS or JS context bindings in AngularTS currently, so their corresponding `$sce.trustAs`
 - functions aren't useful yet. This might evolve.
 -
 - ### Format of items in {@link ng.$sceDelegateProvider#trustedResourceUrlList trustedResourceUrlList}/{@link ng.$sceDelegateProvider#bannedResourceUrlList bannedResourceUrlList} <a name="resourceUrlPatternItem"></a>

package/src/core/scope/scope.js

@@ -10,6 +10,7 @@ import {
   isNull,
   isProxy,
   isProxySymbol,
+  hasOwn,
 } from "../../shared/utils.js";
 import { ASTType } from "../parse/ast-type.js";
 
@@ -24,7 +25,7 @@ export function nextId() {
 }
 
 /**
- * @type {import('../parse/parse.js').ParseService}
+ * @type {import('../parse/interface.ts').ParseService}
  */
 let $parse;
 
@@ -55,7 +56,7 @@ export class RootScopeProvider {
     "$parse",
     /**
      * @param {import('../exception-handler.js').ErrorHandler} exceptionHandler
-     * @param {import('../parse/parse.js').ParseService} parse
+     * @param {import('../parse/interface.ts').ParseService} parse
      */
     (exceptionHandler, parse) => {
       $exceptionHandler = exceptionHandler;
@@ -86,7 +87,7 @@ export function createScope(target = {}, context) {
   if (typeof target === "object") {
     const proxy = new Proxy(target, context || new Scope());
     for (const key in target) {
-      if (Object.prototype.hasOwnProperty.call(target, key)) {
+      if (hasOwn(target, key)) {
         try {
           if (
             (target.constructor.$nonscope &&
@@ -117,7 +118,7 @@ export function createScope(target = {}, context) {
  * @typedef {Object} Listener
  * @property {Object} originalTarget - The original target object.
  * @property {ListenerFunction} listenerFn - The function invoked when changes are detected.
- * @property {import("../parse/parse.js").CompiledExpression} watchFn
+ * @property {import("../parse/interface.ts").CompiledExpression} watchFn
  * @property {number} id - Deregistration id
  * @property {number} scopeId - The scope that created the Listener
  * @property {string[]} property
@@ -281,7 +282,7 @@ export class Scope {
       }
 
       if (isObject(value)) {
-        if (Object.prototype.hasOwnProperty.call(target, property)) {
+        if (hasOwn(target, property)) {
           Object.keys(oldValue)
             .filter((x) => !value[x])
             .forEach((k) => {
@@ -522,7 +523,7 @@ export class Scope {
       }
     }
 
-    if (Object.prototype.hasOwnProperty.call(this.propertyMap, property)) {
+    if (hasOwn(this.propertyMap, property)) {
       this.$target = target;
       return this.propertyMap[property];
     } else {
@@ -614,6 +615,7 @@ export class Scope {
     if (get.constant) {
       if (listenerFn) {
         Promise.resolve().then(() => {
+          // @ts-ignore
           let res = get();
           while (isFunction(res)) {
             res = res();

package/src/directive/aria/aria.js

@@ -1,4 +1,4 @@
-import { extend } from "../../shared/utils.js";
+import { extend, hasOwn } from "../../shared/utils.js";
 
 const ARIA_DISABLE_ATTR = "ngAriaDisable";
 
@@ -57,7 +57,7 @@ export function AriaProvider() {
 
   function watchExpr(attrName, ariaAttr, nativeAriaNodeNames, negate) {
     return function (scope, elem, attr) {
-      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+      if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
       const ariaCamelName = attr.$normalize(ariaAttr);
       if (
@@ -104,7 +104,7 @@ export function ngMessagesAriaDirective() {
     restrict: "A",
     require: "?ngMessages",
     link(_scope, elem, attr) {
-      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+      if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
       if (!elem.hasAttribute("aria-live")) {
         elem.setAttribute("aria-live", "assertive");
@@ -118,7 +118,7 @@ export function ngClickAriaDirective($aria, $parse) {
   return {
     restrict: "A",
     compile(elem, attr) {
-      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+      if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
       const fn = $parse(attr.ngClick);
 
@@ -262,7 +262,7 @@ export function ngModelAriaDirective($aria) {
     require: "ngModel",
     priority: 200, // Make sure watches are fired after any other directives that affect the ngModel value
     compile(elem, attr) {
-      if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+      if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
       const shape = getShape(attr);
 
@@ -315,12 +315,10 @@ export function ngModelAriaDirective($aria) {
               if ($aria.config("ariaValue")) {
                 const needsAriaValuemin =
                   !elem.hasAttribute("aria-valuemin") &&
-                  (Object.prototype.hasOwnProperty.call(attr, "min") ||
-                    Object.prototype.hasOwnProperty.call(attr, "ngMin"));
+                  (hasOwn(attr, "min") || hasOwn(attr, "ngMin"));
                 const needsAriaValuemax =
                   !elem.hasAttribute("aria-valuemax") &&
-                  (Object.prototype.hasOwnProperty.call(attr, "max") ||
-                    Object.prototype.hasOwnProperty.call(attr, "ngMax"));
+                  (hasOwn(attr, "max") || hasOwn(attr, "ngMax"));
                 const needsAriaValuenow = !elem.hasAttribute("aria-valuenow");
 
                 if (needsAriaValuemin) {
@@ -346,7 +344,7 @@ export function ngModelAriaDirective($aria) {
           }
 
           if (
-            !Object.prototype.hasOwnProperty.call(attr, "ngRequired") &&
+            !hasOwn(attr, "ngRequired") &&
             ngModel.$validators.required &&
             shouldAttachAttr("aria-required", "ariaRequired", elem, false)
           ) {
@@ -370,7 +368,7 @@ export function ngModelAriaDirective($aria) {
 ngDblclickAriaDirective.$inject = ["$aria"];
 export function ngDblclickAriaDirective($aria) {
   return function (scope, elem, attr) {
-    if (Object.prototype.hasOwnProperty.call(attr, ARIA_DISABLE_ATTR)) return;
+    if (hasOwn(attr, ARIA_DISABLE_ATTR)) return;
 
     if (
       $aria.config("tabindex") &&

package/src/directive/attrs/attrs.md

@@ -6,10 +6,10 @@
 - @priority 99
 -
 - @description
-- Using AngularJS markup like `{{hash}}` in an href attribute will
+- Using AngularTS markup like `{{hash}}` in an href attribute will
 - make the link go to the wrong URL if the user clicks it before
-- AngularJS has a chance to replace the `{{hash}}` markup with its
-- value. Until AngularJS replaces the markup the link will be broken
+- AngularTS has a chance to replace the `{{hash}}` markup with its
+- value. Until AngularTS replaces the markup the link will be broken
 - and will most likely return a 404 error. The `ngHref` directive
 - solves this problem.
 -
@@ -47,9 +47,9 @@
 - @priority 99
 -
 - @description
-- Using AngularJS markup like `{{hash}}` in a `src` attribute doesn't
+- Using AngularTS markup like `{{hash}}` in a `src` attribute doesn't
 - work right: The browser will fetch from the URL with the literal
-- text `{{hash}}` until AngularJS replaces the expression inside
+- text `{{hash}}` until AngularTS replaces the expression inside
 - `{{hash}}`. The `ngSrc` directive solves this problem.
 -
 - The buggy way to write it:
@@ -86,9 +86,9 @@
 - @priority 99
 -
 - @description
-- Using AngularJS markup like `{{hash}}` in a `srcset` attribute doesn't
+- Using AngularTS markup like `{{hash}}` in a `srcset` attribute doesn't
 - work right: The browser will fetch from the URL with the literal
-- text `{{hash}}` until AngularJS replaces the expression inside
+- text `{{hash}}` until AngularTS replaces the expression inside
 - `{{hash}}`. The `ngSrcset` directive solves this problem.
 -
 - The buggy way to write it:

package/src/directive/bind/bind.js

@@ -1,7 +1,7 @@
 import { isUndefined, stringify, isNull, isProxy } from "../../shared/utils.js";
 
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngBindDirective() {
   return {
@@ -20,7 +20,7 @@ export function ngBindDirective() {
 }
 
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngBindTemplateDirective() {
   return {
@@ -40,20 +40,20 @@ export function ngBindTemplateDirective() {
 
 ngBindHtmlDirective.$inject = ["$parse"];
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngBindHtmlDirective($parse) {
   return {
     restrict: "A",
     compile(_tElement, tAttrs) {
-      $parse(tAttrs.ngBindHtml); // checks for interpolation errors
+      $parse(tAttrs["ngBindHtml"]); // checks for interpolation errors
       return (
         /**
          * @param {import('../../core/scope/scope.js').Scope} scope
          * @param {Element} element
          */
         (scope, element) => {
-          scope.$watch(tAttrs.ngBindHtml, (val) => {
+          scope.$watch(tAttrs["ngBindHtml"], (val) => {
             if (isUndefined(val) || isNull(val)) {
               val = "";
             }

package/src/directive/bind/bind.md

@@ -2,11 +2,11 @@
 
 ### Description
 
-The `ngBind` attribute tells AngularJS to replace the text content of the specified HTML element with the value of a given expression, and to update the text content when the value of that expression changes.
+The `ngBind` attribute tells AngularTS to replace the text content of the specified HTML element with the value of a given expression, and to update the text content when the value of that expression changes.
 
 Typically, you don't use `ngBind` directly, but instead, you use the double curly markup like `{{ expression }}` which is similar but less verbose.
 
-It is preferable to use `ngBind` instead of `{{ expression }}` if a template is momentarily displayed by the browser in its raw state before AngularJS compiles it. Since `ngBind` is an element attribute, it makes the bindings invisible to the user while the page is loading.
+It is preferable to use `ngBind` instead of `{{ expression }}` if a template is momentarily displayed by the browser in its raw state before AngularTS compiles it. Since `ngBind` is an element attribute, it makes the bindings invisible to the user while the page is loading.
 
 An alternative solution to this problem would be using the [`ngCloak`](https://docs.angularjs.org/api/ng/directive/ngCloak) directive.
 
@@ -103,7 +103,7 @@ content will be sanitized using the
 service. To utilize this functionality, ensure that `$sanitize` is available,
 for example, by including
 [`ngSanitize`](https://docs.angularjs.org/api/ngSanitize) in your module's
-dependencies (not in core AngularJS). To use `ngSanitize` in your module's
+dependencies (not in core AngularTS). To use `ngSanitize` in your module's
 dependencies, you need to include "angular-sanitize.js" in your application. You
 may also bypass sanitization for values you know are safe. To do so, bind to an
 explicitly trusted value via

package/src/directive/channel/channel.js

@@ -18,7 +18,7 @@ import { isObject } from "../../shared/utils.js";
  * JavaScript:
  * angular.EventBus.publish('userChannel', { user: { firstName: 'John', lastName: 'Smith' } });
  *
- * @returns {import("../../types.js").Directive}
+ * @returns {import("../../interface.ts").Directive}
  */
 export function ngChannelDirective() {
   return {

package/src/directive/class/class.js

@@ -2,7 +2,7 @@ import { getCacheData, setCacheData } from "../../shared/dom.js";
 import { hasAnimate, isObject, isString } from "../../shared/utils.js";
 
 /**
- * @returns {() => import("../../types.js").Directive}
+ * @returns {() => import("../../interface.ts").Directive}
  */
 function classDirective(name, selector) {
   name = `ngClass${name}`;

package/src/directive/cloak/cloak.js

@@ -1,5 +1,5 @@
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngCloakDirective() {
   return {

package/src/directive/cloak/cloak.md

@@ -6,7 +6,7 @@
 
 ### Description
 
-The `ngCloak` directive is used to prevent the AngularJS HTML template from being briefly displayed by the browser in its raw (uncompiled) form while your application is loading. Use this directive to avoid the undesirable flicker effect caused by the HTML template display.
+The `ngCloak` directive is used to prevent the AngularTS HTML template from being briefly displayed by the browser in its raw (uncompiled) form while your application is loading. Use this directive to avoid the undesirable flicker effect caused by the HTML template display.
 
 The directive can be applied to the `<body>` element, but the preferred usage is to apply multiple `ngCloak` directives to small portions of the page to permit progressive rendering of the browser view.
 

package/src/directive/controller/controller.js

@@ -1,5 +1,5 @@
 /**
- * @returns {import("../../types.js").Directive}
+ * @returns {import("../../interface.ts").Directive}
  */
 export function ngControllerDirective() {
   return {

package/src/directive/controller/controller.md

@@ -32,14 +32,14 @@ Yes
 
 ## Example
 
-Here is a simple form for editing user contact information. Adding, removing, clearing, and greeting are methods declared on the controller (see source tab). These methods can easily be called from the AngularJS markup. Any changes to the data are automatically reflected in the View without the need for a manual update.
+Here is a simple form for editing user contact information. Adding, removing, clearing, and greeting are methods declared on the controller (see source tab). These methods can easily be called from the AngularTS markup. Any changes to the data are automatically reflected in the View without the need for a manual update.
 
 Two different declaration styles are included below:
 
 - One binds methods and properties directly onto the controller using `this`: `ng-controller="SettingsController1 as settings"`
 - One injects `$scope` into the controller: `ng-controller="SettingsController2"`
 
-The second option is more common in the AngularJS community and is generally used in boilerplates and in this guide. However, there are advantages to binding properties directly to the controller and avoiding scope.
+The second option is more common in the AngularTS community and is generally used in boilerplates and in this guide. However, there are advantages to binding properties directly to the controller and avoiding scope.
 
 - Using `controller as` makes it obvious which controller you are accessing in the template when multiple controllers apply to an element.
 - If you are writing your controllers as classes you have easier access to the properties and methods, which will appear on the scope, from inside the controller code.

package/src/directive/events/events.js

@@ -16,7 +16,7 @@ export const ngEventDirectives = {};
         "$parse",
         "$exceptionHandler",
         /**
-         * @param {import("../../core/parse/parse.js").ParseService} $parse
+         * @param {import("../../core/parse/interface.ts").ParseService} $parse
          * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
          * @returns
          */
@@ -34,11 +34,11 @@ export const ngEventDirectives = {};
 
 /**
  *
- * @param {import("../../core/parse/parse.js").ParseService} $parse
+ * @param {import("../../core/parse/interface.ts").ParseService} $parse
  * @param {import('../../core/exception-handler.js').ErrorHandler} $exceptionHandler
  * @param {string} directiveName
  * @param {string} eventName
- * @returns {import("../../types.js").Directive}
+ * @returns {import("../../interface.ts").Directive}
  */
 export function createEventDirective(
   $parse,

package/src/directive/events/events.md

@@ -47,7 +47,7 @@ The `ngDblclick` directive allows you to specify custom behavior on a dblclick e
 **Priority:** `0`
 
 **Description:**  
-Enables binding AngularJS expressions to onsubmit events.
+Enables binding AngularTS expressions to onsubmit events.
 
 Additionally, it prevents the default action (which for forms means sending the request to the server and reloading the current page), but only if the form does not contain `action`, `data-action`, or `x-action` attributes.
 
@@ -69,7 +69,7 @@ Additionally, it prevents the default action (which for forms means sending the
 **Description:**  
 Specify custom behavior on focus event.
 
-Note: As the `focus` event is executed synchronously when calling `input.focus()`, AngularJS executes the expression using `scope.$evalAsync` if the event is fired during an `$apply` to ensure a consistent state.
+Note: As the `focus` event is executed synchronously when calling `input.focus()`, AngularTS executes the expression using `scope.$evalAsync` if the event is fired during an `$apply` to ensure a consistent state.
 
 **Param:**
 

package/src/directive/form/form.js

@@ -373,7 +373,7 @@ export class FormController {
    *        `ng-invalid-my-error` classes and can be bound to as `{{ someForm.$error.myError }}`.
    * @param {boolean} state Whether the current state is valid (true), invalid (false), pending
    *        (undefined),  or skipped (null). Pending is used for unfulfilled `$asyncValidators`.
-   *        Skipped is used by AngularJS when validators do not run because of parse errors and when
+   *        Skipped is used by AngularTS when validators do not run because of parse errors and when
    *        `$asyncValidators` do not run because any of the `$validators` failed.
    * @param {import("../model/model.js").NgModelController | FormController} controller - The controller whose validity state is
    *        triggering the change.
@@ -496,9 +496,9 @@ export class FormController {
  *
  * ## Alias: {@link ng.directive:ngForm `ngForm`}
  *
- * In AngularJS, forms can be nested. This means that the outer form is valid when all of the child
+ * In AngularTS, forms can be nested. This means that the outer form is valid when all of the child
  * forms are valid as well. However, browsers do not allow nesting of `<form>` elements, so
- * AngularJS provides the {@link ng.directive:ngForm `ngForm`} directive, which behaves identically to
+ * AngularTS provides the {@link ng.directive:ngForm `ngForm`} directive, which behaves identically to
  * `form` but can be nested. Nested forms can be useful, for example, if the validity of a sub-group
  * of controls needs to be determined.
  *
@@ -515,12 +515,12 @@ export class FormController {
  *
  * ## Submitting a form and preventing the default action
  *
- * Since the role of forms in client-side AngularJS applications is different than in classical
+ * Since the role of forms in client-side AngularTS applications is different than in classical
  * roundtrip apps, it is desirable for the browser not to translate the form submission into a full
  * page reload that sends the data to the server. Instead some javascript logic should be triggered
  * to handle the form submission in an application-specific way.
  *
- * For this reason, AngularJS prevents the default action (form submission to the server) unless the
+ * For this reason, AngularTS prevents the default action (form submission to the server) unless the
  * `<form>` element has an `action` attribute specified.
  *
  * You can use one of the following two ways to specify what javascript method should be called when

package/src/directive/if/if.js

@@ -6,7 +6,7 @@ ngIfDirective.$inject = ["$animate"];
  *
  * TODO // Add type for animate service
  * @param {*}  $animate
- * @returns {import("../../types.js").Directive}
+ * @returns {import("../../interface.ts").Directive}
  */
 export function ngIfDirective($animate) {
   return {

package/src/directive/include/include.js

@@ -125,7 +125,7 @@ ngIncludeFillContentDirective.$inject = ["$compile"];
 
 /**
  * @param {import("../../core/compile/compile.js").CompileFn} $compile
- * @returns {import("../../types.js").Directive}
+ * @returns {import("../../interface.ts").Directive}
  */
 export function ngIncludeFillContentDirective($compile) {
   return {

package/src/directive/include/include.md

@@ -13,7 +13,7 @@
 - $sce.getTrustedResourceUrl} on it. To load templates from other domains or protocols
 - you may either add them to your {@link ng.$sceDelegateProvider#trustedResourceUrlList trusted
 - resource URL list} or {@link $sce#trustAsResourceUrl wrap them} as trusted values. Refer to
-- AngularJS's {@link ng.$sce Strict Contextual Escaping}.
+- AngularTS's {@link ng.$sce Strict Contextual Escaping}.
 -
 - In addition, the browser's
 - [Same Origin Policy](https://code.google.com/p/browsersec/wiki/Part2#Same-origin_policy_for_XMLHttpRequest)
@@ -32,7 +32,7 @@
 -
 - The enter and leave animation occur concurrently.
 -
-- @param {string} ngInclude|src AngularJS expression evaluating to URL. If the source is a string constant,
+- @param {string} ngInclude|src AngularTS expression evaluating to URL. If the source is a string constant,
 -                 make sure you wrap it in **single** quotes, e.g. `src="'myPartialTemplate.html'"`.
 - @param {string=} onload Expression to evaluate when a new partial is loaded.
 -                  <div class="alert alert-warning">

package/src/directive/init/init.js

@@ -1,7 +1,7 @@
 import { getController } from "../../shared/dom.js";
 
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngInitDirective() {
   return {

package/src/directive/input/input.js

@@ -975,7 +975,7 @@ function checkboxInputType(
 }
 
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 inputDirective.$inject = ["$browser", "$filter", "$parse"];
 
@@ -1008,7 +1008,7 @@ export function inputDirective($browser, $filter, $parse) {
 }
 
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function hiddenInputBrowserCacheDirective() {
   const valueProperty = {
@@ -1026,7 +1026,7 @@ export function hiddenInputBrowserCacheDirective() {
     restrict: "E",
     priority: 200,
     compile(_, attr) {
-      if (lowercase(attr.type) !== "hidden") {
+      if (lowercase(attr["type"]) !== "hidden") {
         return;
       }
 
@@ -1054,7 +1054,7 @@ export function hiddenInputBrowserCacheDirective() {
 const CONSTANT_VALUE_REGEXP = /^(true|false|\d+)$/;
 
 /**
- * @returns {import('../../types.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngValueDirective() {
   /**
@@ -1080,14 +1080,14 @@ export function ngValueDirective() {
     restrict: "A",
     priority: 100,
     compile(tpl, tplAttr) {
-      if (CONSTANT_VALUE_REGEXP.test(tplAttr.ngValue)) {
+      if (CONSTANT_VALUE_REGEXP.test(tplAttr["ngValue"])) {
         return function ngValueConstantLink(scope, elm, attr) {
-          const value = scope.$eval(attr.ngValue);
+          const value = scope.$eval(attr["ngValue"]);
           updateElementValue(elm, attr, value);
         };
       }
       return function ngValueLink(scope, elm, attr) {
-        scope.$watch(attr.ngValue, (value) => {
+        scope.$watch(attr["ngValue"], (value) => {
           updateElementValue(elm, attr, value);
         });
       };