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

package/src/core/filter/filter.md

@@ -9,7 +9,7 @@
 - annotated with dependencies and is responsible for creating a filter function.
 -
 - <div class="alert alert-warning">
-- **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+- **Note:** Filter names must be valid AngularTS {@link expression} identifiers, such as `uppercase` or `orderBy`.
 - Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
 - your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
 - (`myapp_subsection_filterx`).
@@ -64,8 +64,8 @@
 
 -
 -
-- For more information about how AngularJS filters work, and how to create your own filters, see
-- {@link guide/filter Filters} in the AngularJS Developer Guide.
+- For more information about how AngularTS filters work, and how to create your own filters, see
+- {@link guide/filter Filters} in the AngularTS Developer Guide.
   \*/
 
 /\*\*
@@ -76,7 +76,7 @@
 - @description
 - Filters are used for formatting data displayed to the user.
 -
-- They can be used in view templates, controllers or services. AngularJS comes
+- They can be used in view templates, controllers or services. AngularTS comes
 - with a collection of [built-in filters](api/ng/filter), but it is easy to
 - define your own as well.
 -
@@ -121,7 +121,7 @@
 - the keys are the filter names and the values are the filter factories.
 -
 - <div class="alert alert-warning">
-- **Note:** Filter names must be valid AngularJS {@link expression} identifiers, such as `uppercase` or `orderBy`.
+- **Note:** Filter names must be valid AngularTS {@link expression} identifiers, such as `uppercase` or `orderBy`.
 - Names with special characters, such as hyphens and dots, are not allowed. If you wish to namespace
 - your filters, then you can use capitalization (`myappSubsectionFilterx`) or underscores
 - (`myapp_subsection_filterx`).

package/src/core/interpolate/interpolate.js

@@ -32,9 +32,9 @@ function interr(text, err) {
  * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
  *
  * <div class="alert alert-danger">
- * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularJS
+ * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularTS
  * template within a Python Jinja template (or any other template language). Mixing templating
- * languages is **very dangerous**. The embedding template language will not safely escape AngularJS
+ * languages is **very dangerous**. The embedding template language will not safely escape AngularTS
  * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
  * security bugs!
  * </div>
@@ -57,7 +57,7 @@ export class InterpolateProvider {
     "$sce",
     /**
      *
-     * @param {import("../parse/parse.js").ParseService} $parse
+     * @param {import("../parse/interface.ts").ParseService} $parse
      * @param {*} $sce
      * @returns
      */
@@ -97,7 +97,7 @@ export class InterpolateProvider {
        * ```js
        *   let $interpolate = ...; // injected
        *   let exp = $interpolate('Hello {{name | uppercase}}!');
-       *   expect(exp({name:'AngularJS'})).toEqual('Hello ANGULARJS!');
+       *   expect(exp({name:'AngularTS'})).toEqual('Hello ANGULARJS!');
        * ```
        *
        * `$interpolate` takes an optional fourth argument, `allOrNothing`. If `allOrNothing` is
@@ -115,8 +115,8 @@ export class InterpolateProvider {
        *   // "allOrNothing" mode
        *   exp = $interpolate('{{greeting}} {{name}}!', false, null, true);
        *   expect(exp(context)).toBeUndefined();
-       *   context.name = 'AngularJS';
-       *   expect(exp(context)).toEqual('Hello AngularJS!');
+       *   context.name = 'AngularTS';
+       *   expect(exp(context)).toEqual('Hello AngularTS!');
        * ```
        *
        * `allOrNothing` is useful for interpolating URLs. `ngSrc` and `ngSrcset` use this behavior.

package/src/core/interpolate/interpolate.spec.js

@@ -289,7 +289,7 @@ describe("$interpolate", () => {
 
     // This test demonstrates that the web-server is responsible for escaping every single instance
     // of interpolation start/end markers in an expression which they do not wish to evaluate,
-    // because AngularJS will not protect them from being evaluated (due to the added compleity
+    // because AngularTS will not protect them from being evaluated (due to the added compleity
     // and maintenance burden of context-sensitive escaping)
     it("should evaluate expressions between escaped start/end symbols", () => {
       expect($interpolate("\\{\\{Hello, {{bar}}!\\}\\}")(obj)).toBe(

package/src/core/location/location.js

@@ -156,7 +156,7 @@ export class Location {
    *
    * Return host of current URL.
    *
-   * Note: compared to the non-AngularJS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
+   * Note: compared to the non-AngularTS version `location.host` which returns `hostname:port`, this returns the `hostname` portion only.
    *
    *
    * @return {string} host of current URL.
@@ -507,7 +507,7 @@ export class LocationHashbangUrl extends Location {
      *  * a.setAttribute('href', '/foo')
      *   * a.pathname === '/C:/foo' //true
      *
-     * Inside of AngularJS, we're always using pathnames that
+     * Inside of AngularTS, we're always using pathnames that
      * do not include drive names for routing.
      */
     function removeWindowsDriveName(path, url, base) {
@@ -747,7 +747,7 @@ export class LocationProvider {
             !event.defaultPrevented
           ) {
             if ($location.$$parseLinkUrl(absHref, relHref)) {
-              // We do a preventDefault for all urls that are part of the AngularJS application,
+              // We do a preventDefault for all urls that are part of the AngularTS application,
               // in html5mode and also without, so that we are able to abort navigation without
               // getting double entries in the location history.
               event.preventDefault();

package/src/core/parse/ast/ast.js

@@ -1,6 +1,6 @@
 import { isAssignable } from "../interpreter.js";
 import { ASTType } from "../ast-type.js";
-import { minErr } from "../../../shared/utils.js";
+import { hasOwn, minErr } from "../../../shared/utils.js";
 
 /**
  * @typedef {import("./ast-node.ts").ASTNode} ASTNode
@@ -269,7 +269,7 @@ export class AST {
     } else if (this.expect("{")) {
       primary = this.object();
     } else if (
-      Object.prototype.hasOwnProperty.call(
+      hasOwn(
         this.selfReferential,
         /** @type {import("../lexer/lexer.js").Token} */ (this.peek()).text,
       )

package/src/core/parse/interface.ts

@@ -0,0 +1,84 @@
+import type { DecoratedASTNode } from "./interpreter.js";
+import type { Scope } from "../scope/scope.js";
+
+/**
+ * Describes metadata and behavior for a compiled AngularJS expression.
+ */
+export interface CompiledExpressionProps {
+  /** Indicates if the expression is a literal. */
+  literal: boolean;
+  /** Indicates if the expression is constant. */
+  constant: boolean;
+  /** Optional flag for pure expressions. */
+  isPure?: boolean;
+  /** Indicates if the expression should be evaluated only once. */
+  oneTime: boolean;
+  /** AST node decorated with metadata. */
+  decoratedNode: DecoratedASTNode;
+  /**
+   * Optional custom watch delegate function for the expression.
+   * @param scope - The current scope.
+   * @param listener - A listener function.
+   * @param equalityCheck - Whether to use deep equality.
+   * @param expression - The compiled expression or string.
+   */
+  $$watchDelegate?: (
+    scope: Scope,
+    listener: Function,
+    equalityCheck: boolean,
+    expression: CompiledExpression | string | ((scope: Scope) => any),
+  ) => any;
+  /** Expression inputs; may be an array or a function. */
+  inputs: any[] | Function;
+  /**
+   * Optional assign function for two-way binding.
+   * Assigns a value to a context.
+   * If value is not provided, may return the getter.
+   */
+  assign?: (context: any, value: any) => any;
+}
+
+/**
+ * Expression function with context and optional locals/assign.
+ * Evaluates the compiled expression.
+ */
+export type CompiledExpressionFunction = (
+  context: Scope,
+  locals?: object,
+  assign?: any,
+) => any;
+
+/**
+ * A compiled expression that is both a function and includes expression metadata.
+ */
+export type CompiledExpression = CompiledExpressionFunction &
+  CompiledExpressionProps;
+
+/**
+ * Map used for expressions that watch specific object keys.
+ */
+export interface CompiledExpressionHandlerMap {
+  /** Indicates if the expression is a literal. */
+  literal: boolean;
+  /** Indicates if the expression is constant. */
+  constant: boolean;
+  /** Optional flag for pure expressions. */
+  isPure?: boolean;
+  /** Indicates if the expression should be evaluated only once. */
+  oneTime: boolean;
+  /** A map of property keys to observe. */
+  keyMap: Map<string, Function>;
+}
+
+/**
+ * Parses a string or expression function into a compiled expression.
+ * @param expression - The input expression (string or function).
+ * @param interceptorFn - Optional value transformer.
+ * @param expensiveChecks - Whether to enable expensive change detection.
+ * @returns A compiled expression.
+ */
+export type ParseService = (
+  expression: CompiledExpression | string | ((scope: Scope) => any),
+  interceptorFn?: (value: any, scope: Scope, locals: any) => any,
+  expensiveChecks?: boolean,
+) => CompiledExpression;

package/src/core/parse/interpreter.js

@@ -15,16 +15,16 @@ export class ASTInterpreter {
   /**
    * Compiles the AST into a function.
    * @param {import("./ast/ast").ASTNode} ast - The AST to compile.
-   * @returns {import("./parse").CompiledExpression}
+   * @returns {import("./interface.ts").CompiledExpression}
    */
   compile(ast) {
     let decoratedNode = findConstantAndWatchExpressions(ast, this.$filter);
     /** @type {import("./ast/ast").ASTNode} */
     let assignable;
-    /** @type {import("./parse").CompiledExpression} */
+    /** @type {import("./interface.ts").CompiledExpression} */
     let assign;
     if ((assignable = assignableAST(decoratedNode))) {
-      assign = /** @type {import("./parse").CompiledExpression} */ (
+      assign = /** @type {import("./interface.ts").CompiledExpression} */ (
         this.recurse(assignable)
       );
     }
@@ -33,9 +33,10 @@ export class ASTInterpreter {
     if (toWatch) {
       inputs = [];
       for (const [key, watch] of Object.entries(toWatch)) {
-        const input = /** @type {import("./parse").CompiledExpression} */ (
-          this.recurse(watch)
-        );
+        const input =
+          /** @type {import("./interface.ts").CompiledExpression} */ (
+            this.recurse(watch)
+          );
         input.isPure = watch.isPure;
         watch.input = input;
         inputs.push(input);
@@ -47,7 +48,7 @@ export class ASTInterpreter {
       expressions.push(this.recurse(expression.expression));
     });
 
-    /** @type {import("./parse").CompiledExpression} */
+    /** @type {import("./interface.ts").CompiledExpression} */
     const fn =
       decoratedNode.body.length === 0
         ? () => {}
@@ -75,7 +76,7 @@ export class ASTInterpreter {
    * @param {import("./ast/ast").ASTNode} ast - The AST node.
    * @param {Object} [context] - The context.
    * @param {boolean|1} [create] - The create flag.
-   * @returns {import("./parse").CompiledExpressionFunction} The recursive function.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The recursive function.
    */
   recurse(ast, context, create) {
     let left;
@@ -97,11 +98,13 @@ export class ASTInterpreter {
         right = this.recurse(ast.right);
         return this[`binary${ast.operator}`](left, right, context);
       case ASTType.ConditionalExpression:
-        return this["ternary?:"](
-          this.recurse(ast.test),
-          this.recurse(ast.alternate),
-          this.recurse(ast.consequent),
-          context,
+        return /** @type {import("./interface.ts").CompiledExpressionFunction} */ (
+          this["ternary?:"](
+            this.recurse(ast.test),
+            this.recurse(ast.alternate),
+            this.recurse(ast.consequent),
+            context,
+          )
         );
       case ASTType.Identifier:
         return self.identifier(ast.name, context, create);
@@ -111,19 +114,21 @@ export class ASTInterpreter {
           right = ast.property.name;
         }
         if (ast.computed) right = this.recurse(ast.property);
-        return ast.computed
-          ? this.computedMember(
-              left,
-              /** @type {function } */ (right),
-              context,
-              create,
-            )
-          : this.nonComputedMember(
-              left,
-              /** @type {string } */ (right),
-              context,
-              create,
-            );
+        return /** @type {import("./interface.ts").CompiledExpressionFunction} */ (
+          ast.computed
+            ? this.computedMember(
+                left,
+                /** @type {function } */ (right),
+                context,
+                create,
+              )
+            : this.nonComputedMember(
+                left,
+                /** @type {string } */ (right),
+                context,
+                create,
+              )
+        );
       case ASTType.CallExpression:
         args = [];
         ast.arguments.forEach((expr) => {
@@ -505,7 +510,7 @@ export class ASTInterpreter {
    * Returns the value of a literal.
    * @param {*} value - The literal value.
    * @param {Object} [context] - The context.
-   * @returns {function} The function returning the literal value.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the literal value.
    */
   value(value, context) {
     return function () {
@@ -518,7 +523,7 @@ export class ASTInterpreter {
    * @param {string} name - The identifier name.
    * @param {Object} [context] - The context.
    * @param {boolean|1} [create] - Whether to create the identifier if it does not exist.
-   * @returns {function} The function returning the identifier value.
+   * @returns {import("./interface.ts").CompiledExpressionFunction} The function returning the identifier value.
    */
   identifier(name, context, create) {
     return function (scope, locals) {

package/src/core/parse/parse.js

@@ -3,46 +3,6 @@ import { PURITY_RELATIVE } from "./interpreter.js";
 import { Lexer } from "./lexer/lexer.js";
 import { Parser } from "./parser/parser.js";
 
-/**
- * @typedef {Object} CompiledExpressionProps
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {import("./interpreter.js").DecoratedASTNode} decoratedNode
- * @property {function(import('../scope/scope.js').Scope, Function, boolean, CompiledExpression, string | ((scope:  import('../scope/scope.js').Scope) => any) | CompiledExpression): any} [$$watchDelegate]
- * @property {any[]|Function} inputs
- * @property {function(any, any): any} [assign] - Assigns a value to a context. If value is not provided,
- */
-
-/**
- * @typedef {Object} CompiledExpressionHandlerMap
- * @property {boolean} literal - Indicates if the expression is a literal.
- * @property {boolean} constant - Indicates if the expression is constant.
- * @property {boolean} [isPure]
- * @property {boolean} oneTime
- * @property {Map<string, Function>} keyMap - property keys to observe
- */
-
-/**
- * @typedef {Function} CompiledExpressionFunction
- * @param {import('../scope/scope.js').Scope} context - An object against which any expressions embedded in the strings are evaluated against (typically a scope object).
- * @param {object} [locals] - local variables context object, useful for overriding values in `context`.
- * @param {any} [assign]
- * @returns {any}
- * undefined is gonna be used since the implementation
- * does not check the parameter. Let's force a value for consistency. If consumer
- * wants to undefine it, pass the undefined value explicitly.
- */
-
-/**
- * @typedef {CompiledExpressionFunction & CompiledExpressionProps} CompiledExpression
- */
-
-/**
- * @typedef {function(CompiledExpression|string|function(import('../scope/scope.js').Scope):any, function(any, import('../scope/scope.js').Scope, any):any=, boolean=): CompiledExpression} ParseService
- */
-
 export function ParseProvider() {
   const cache = Object.create(null);
 
@@ -53,7 +13,7 @@ export function ParseProvider() {
   var identContinue;
 
   /**
-   * Allows defining the set of characters that are allowed in AngularJS expressions. The function
+   * Allows defining the set of characters that are allowed in AngularTS expressions. The function
    * `identifierStart` will get called to know if a given character is a valid character to be the
    * first character for an identifier. The function `identifierContinue` will get called to know if
    * a given character is a valid character to be a follow-up identifier character. The functions
@@ -83,7 +43,7 @@ export function ParseProvider() {
     /**
      *
      * @param {(any) => any} $filter
-     * @returns {ParseService}
+     * @returns {import('./interface').ParseService}
      */
     function ($filter) {
       /** @type {import("./lexer/lexer.js").LexerOptions} */
@@ -128,7 +88,7 @@ export function ParseProvider() {
       /**
        * @param {Function} parsedExpression
        * @param interceptorFn
-       * @returns {CompiledExpression|*}
+       * @returns {import('./interface').CompiledExpression|*}
        */
       function addInterceptor(parsedExpression, interceptorFn) {
         if (!interceptorFn) return parsedExpression;
@@ -231,8 +191,8 @@ export function constantWatchDelegate(
 
 /**
  *
- * @param {CompiledExpression} parsedExpression
- * @returns {CompiledExpression}
+ * @param {import('./interface.ts').CompiledExpression} parsedExpression
+ * @returns {import('./interface.ts').CompiledExpression}
  */
 function addWatchDelegate(parsedExpression) {
   if (parsedExpression.constant) {
@@ -249,7 +209,7 @@ function addWatchDelegate(parsedExpression) {
  * @param {import('../scope/scope.js').Scope} scope
  * @param {Function} listener
  * @param {*} objectEquality
- * @param {CompiledExpression} parsedExpression
+ * @param {import('./interface').CompiledExpression} parsedExpression
  * @returns
  */
 function inputsWatchDelegate(
@@ -276,9 +236,7 @@ function inputsWatchDelegate(
             inputExpression.isPure,
           )
         ) {
-          lastResult = parsedExpression($scope, undefined, undefined, [
-            newInputValue,
-          ]);
+          lastResult = parsedExpression($scope, undefined, [newInputValue]);
           oldInputValueOf = newInputValue && getValueOf(newInputValue);
         }
         return lastResult;
@@ -315,12 +273,7 @@ function inputsWatchDelegate(
         }
 
         if (changed) {
-          lastResult = parsedExpression(
-            scope,
-            undefined,
-            undefined,
-            oldInputValues,
-          );
+          lastResult = parsedExpression(scope, undefined, oldInputValues);
         }
 
         return lastResult;

package/src/core/parse/parse.md

@@ -1,9 +1,9 @@
-// Sandboxing AngularJS Expressions
+// Sandboxing AngularTS Expressions
 // ------------------------------
-// AngularJS expressions are no longer sandboxed. So it is now even easier to access arbitrary JS code by
+// AngularTS expressions are no longer sandboxed. So it is now even easier to access arbitrary JS code by
 // various means such as obtaining a reference to native JS functions like the Function constructor.
 //
-// As an example, consider the following AngularJS expression:
+// As an example, consider the following AngularTS expression:
 //
 // {}.toString.constructor('alert("evil JS code")')
 //
@@ -20,14 +20,14 @@
 -
 - @description
 -
-- Converts AngularJS {@link guide/expression expression} into a function.
+- Converts AngularTS {@link guide/expression expression} into a function.
 -
 - let getter = $parse('user.name');
 - let setter = getter.assign;
-- let context = {user:{name:'AngularJS'}};
+- let context = {user:{name:'AngularTS'}};
 - let locals = {user:{name:'local'}};
 -
-- expect(getter(context)).toEqual('AngularJS');
+- expect(getter(context)).toEqual('AngularTS');
 - setter(context, 'newValue');
 - expect(context.user.name).toEqual('newValue');
 - expect(getter(context, locals)).toEqual('local');

package/src/core/parse/parser/parser.js

@@ -27,7 +27,7 @@ export class Parser {
   /**
    *
    * @param {string} exp - Expression to be parsed
-   * @returns {import("../parse.js").CompiledExpression}
+   * @returns {import("../interface.ts").CompiledExpression}
    */
   parse(exp) {
     const { ast } = this.getAst(exp);

package/src/core/sanitize/interface.ts

@@ -0,0 +1,10 @@
+/**
+ * Sanitizer function that processes a URI string and optionally
+ * treats it as a media URL.
+ */
+export interface SanitizerFn {
+  (
+    uri: string | null | undefined,
+    isMediaUrl?: boolean,
+  ): string | null | undefined;
+}

package/src/core/sanitize/sanitize-uri.js

@@ -1,84 +1,74 @@
 import { isDefined } from "../../shared/utils.js";
 import { urlResolve } from "../url-utils/url-utils.js";
 
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider } */
+
 /**
- *
- * @description
  * Private service to sanitize uris for links and images. Used by $compile.
+ * @implements {ServiceProvider}
  */
-export function SanitizeUriProvider() {
-  let aHrefSanitizationTrustedUrlList = /^\s*(https?|s?ftp|mailto|tel|file):/;
-  let imgSrcSanitizationTrustedUrlList =
-    /^\s*((https?|ftp|file|blob):|data:image\/)/;
+export class SanitizeUriProvider {
+  constructor() {
+    /**
+     * @private
+     * @type {RegExp}
+     */
+    this._aHrefSanitizationTrustedUrlList =
+      /^\s*(https?|s?ftp|mailto|tel|file):/;
+
+    /**
+     * @private
+     * @type {RegExp}
+     */
+    this._imgSrcSanitizationTrustedUrlList =
+      /^\s*((https?|ftp|file|blob):|data:image\/)/;
+  }
 
   /**
-   * @description
-   * Retrieves or overrides the default regular expression that is used for determining trusted safe
-   * urls during a[href] sanitization.
-   *
-   * The sanitization is a security measure aimed at prevent XSS attacks via HTML anchor links.
-   *
-   * Any url due to be assigned to an `a[href]` attribute via interpolation is marked as requiring
-   * the $sce.URL security context. When interpolation occurs a call is made to `$sce.trustAsUrl(url)`
-   * which in turn may call `$$sanitizeUri(url, isMedia)` to sanitize the potentially malicious URL.
+   * Retrieves or overrides the regexp used to trust URLs for a[href] sanitization.
    *
-   * If the URL matches the `aHrefSanitizationTrustedUrlList` regular expression, it is returned unchanged.
-   *
-   * If there is no match the URL is returned prefixed with `'unsafe:'` to ensure that when it is written
-   * to the DOM it is inactive and potentially malicious code will not be executed.
-   *
-   * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|SanitizeUriProvider} Current RegExp if called without value or self for
-   *    chaining otherwise.
+   * @param {RegExp=} regexp New regexp to trust URLs with.
+   * @returns {RegExp|SanitizeUriProvider} Current regexp if no param, or self for chaining.
    */
-  this.aHrefSanitizationTrustedUrlList = function (regexp) {
+  aHrefSanitizationTrustedUrlList(regexp) {
     if (isDefined(regexp)) {
-      aHrefSanitizationTrustedUrlList = regexp;
+      this._aHrefSanitizationTrustedUrlList = regexp;
       return this;
     }
-    return aHrefSanitizationTrustedUrlList;
-  };
+    return this._aHrefSanitizationTrustedUrlList;
+  }
 
   /**
-   * @description
-   * Retrieves or overrides the default regular expression that is used for determining trusted safe
-   * urls during img[src] sanitization.
-   *
-   * The sanitization is a security measure aimed at prevent XSS attacks via HTML image src links.
-   *
-   * Any URL due to be assigned to an `img[src]` attribute via interpolation is marked as requiring
-   * the $sce.MEDIA_URL security context. When interpolation occurs a call is made to
-   * `$sce.trustAsMediaUrl(url)` which in turn may call `$$sanitizeUri(url, isMedia)` to sanitize
-   * the potentially malicious URL.
+   * Retrieves or overrides the regexp used to trust URLs for img[src] sanitization.
    *
-   * If the URL matches the `imgSrcSanitizationTrustedUrlList` regular expression, it is returned
-   * unchanged.
-   *
-   * If there is no match the URL is returned prefixed with `'unsafe:'` to ensure that when it is written
-   * to the DOM it is inactive and potentially malicious code will not be executed.
-   *
-   * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|SanitizeUriProvider} Current RegExp if called without value or self for chaining otherwise.
+   * @param {RegExp=} regexp New regexp to trust URLs with.
+   * @returns {RegExp|SanitizeUriProvider} Current regexp if no param, or self for chaining.
    */
-  this.imgSrcSanitizationTrustedUrlList = function (regexp) {
+  imgSrcSanitizationTrustedUrlList(regexp) {
     if (isDefined(regexp)) {
-      imgSrcSanitizationTrustedUrlList = regexp;
+      this._imgSrcSanitizationTrustedUrlList = regexp;
       return this;
     }
-    return imgSrcSanitizationTrustedUrlList;
-  };
+    return this._imgSrcSanitizationTrustedUrlList;
+  }
+
+  /**
+   * @returns {import("./interface.js").SanitizerFn} Sanitizer function.
+   */
+  $get() {
+    return (uri, isMediaUrl) => {
+      if (!uri) return uri;
 
-  this.$get = function () {
-    return function (uri, isMediaUrl) {
-      // if (!uri) return uri;
       const regex = isMediaUrl
-        ? imgSrcSanitizationTrustedUrlList
-        : aHrefSanitizationTrustedUrlList;
-      const normalizedVal = urlResolve(uri && uri.trim()).href;
+        ? this._imgSrcSanitizationTrustedUrlList
+        : this._aHrefSanitizationTrustedUrlList;
+
+      const normalizedVal = urlResolve(uri.trim()).href;
+
       if (normalizedVal !== "" && !normalizedVal.match(regex)) {
         return `unsafe:${normalizedVal}`;
       }
       return uri;
     };
-  };
+  }
 }

package/src/core/sanitize/sanitize-uri.spec.js

@@ -1,4 +1,4 @@
-import { SanitizeUriProvider } from "./sanitize-uri";
+import { SanitizeUriProvider } from "./sanitize-uri.js";
 
 describe("sanitizeUri", () => {
   let sanitizeHref;