npm - @angular-wave/angular.ts - Versions diffs - 0.7.0-beta.0 → 0.7.0-beta.1 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (881) hide show

package/.husky/pre-commit CHANGED Viewed

@@ -1,3 +1,5 @@
+make lint
+make check
 make types
 make pretty
 git add ./

package/@types/animations/animate-children-directive.d.ts CHANGED Viewed

@@ -1,8 +1,10 @@
 /**
  * @param {*} $interpolate
- * @returns {import("../types").Directive}
+ * @returns {import("../interface.ts").Directive}
  */
-export function $$AnimateChildrenDirective($interpolate: any): any;
+export function $$AnimateChildrenDirective(
+  $interpolate: any,
+): import("../interface.ts").Directive;
 export namespace $$AnimateChildrenDirective {
   let $inject: string[];
 }

package/@types/animations/animate-swap.d.ts CHANGED Viewed

@@ -1,9 +1,9 @@
 /**
- * @returns {import('../types.js').Directive}
+ * @returns {import('../interface.ts').Directive}
  */
 export function ngAnimateSwapDirective(
   $animate: any,
-): import("../types.js").Directive;
+): import("../interface.ts").Directive;
 export namespace ngAnimateSwapDirective {
   let $inject: string[];
 }

package/@types/animations/animate.d.ts CHANGED Viewed

@@ -168,7 +168,7 @@ export class AnimateProvider {
         off: any;
         /**
          *  Associates the provided element with a host parent element to allow the element to be animated even if it exists
-         *  outside of the DOM structure of the AngularJS application. By doing so, any animation triggered via `$animate` can be issued on the
+         *  outside of the DOM structure of the AngularTS application. By doing so, any animation triggered via `$animate` can be issued on the
          *  element despite being outside the realm of the application or within another application. Say for example if the application
          *  was bootstrapped on an element that is somewhere inside of the `<body>` tag, but we wanted to allow for an element to be situated
          *  as a direct child of `document.body`, then this can be achieved by pinning the element via `$animate.pin(element)`. Keep in mind

package/@types/animations/interface.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+export type RafScheduler = {
+  /**
+   * Schedules a list of functions to run on the next animation frame(s).
+   * @param tasks - The tasks to be scheduled.
+   */
+  (tasks: Array<() => void>): void;
+  /**
+   * Internal queue of scheduled task arrays.
+   */
+  queue: Array<Array<() => void>>;
+  /**
+   * Waits until the animation frame is quiet before running the provided function.
+   * Cancels any previous animation frame requests.
+   * @param fn - The function to run when the frame is quiet.
+   */
+  waitUntilQuiet(fn: () => void): void;
+};

package/@types/animations/raf-scheduler.d.ts CHANGED Viewed

@@ -1,24 +1,37 @@
 /**
- * @typedef {Function} RafSchedulerFunction
- * @typedef {Object} RafSchedulerObject
- * @property {Function} waitUntilQuiet - Function to wait until the animation frame is quiet.
- * @typedef {RafSchedulerObject & RafSchedulerFunction} RafScheduler
+ * @typedef {import('./interface.js').RafScheduler} RafScheduler
+ * @typedef {import('../interface.js').ServiceProvider} ServiceProvider
  */
 /**
- * Creates a requestAnimationFrame scheduler.
+ * Service provider that creates a requestAnimationFrame-based scheduler.
+ * @implements {ServiceProvider}
  */
-export function RafSchedulerProvider(): void;
-export class RafSchedulerProvider {
+export class RafSchedulerProvider implements ServiceProvider {
   /**
-   * @returns {RafScheduler} The scheduler object.
+   * Internal task queue, where each item is an array of functions to run.
+   * @type {Array<Array<() => void>>}
    */
-  $get: () => RafScheduler;
-}
-export type RafSchedulerFunction = Function;
-export type RafSchedulerObject = {
+  queue: Array<Array<() => void>>;
+  /**
+   * ID of the currently scheduled animation frame (if any).
+   * Used for cancellation and tracking.
+   * @type {number|null}
+   */
+  cancelFn: number | null;
   /**
-   * - Function to wait until the animation frame is quiet.
+   * Processes the next batch of tasks in the animation frame.
+   * Executes the first group of functions in the queue, then
+   * schedules the next frame if needed.
    */
-  waitUntilQuiet: Function;
-};
-export type RafScheduler = RafSchedulerObject & RafSchedulerFunction;
+  nextTick(): void;
+  /**
+   * Returns the scheduler function.
+   * This function allows tasks to be queued for execution on future animation frames.
+   * It also has helper methods and state attached.
+   *
+   * @returns {RafScheduler} The scheduler function with `queue` and `waitUntilQuiet`.
+   */
+  $get(): RafScheduler;
+}
+export type RafScheduler = import("./interface.js").RafScheduler;
+export type ServiceProvider = import("../interface.js").ServiceProvider;

package/@types/core/compile/attributes.d.ts CHANGED Viewed

@@ -18,7 +18,7 @@ export class Attributes {
   );
   $rootScope: import("../scope/scope.js").Scope;
   $animate: any;
-  $exceptionHandler: import("../exception-handler.js").ErrorHandler;
+  $exceptionHandler: import("../error-handler.ts").ErrorHandler;
   $sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */

package/@types/core/compile/compile.d.ts CHANGED Viewed

@@ -1,9 +1,14 @@
-export function CompileProvider(
-  $provide: any,
-  $$sanitizeUriProvider: any,
-): void;
+export const DirectiveSuffix: "Directive";
 export class CompileProvider {
-  constructor($provide: any, $$sanitizeUriProvider: any);
+  static $inject: string[];
+  /**
+   * @param {import('../../interface.js').Provider} $provide
+   * @param $$sanitizeUriProvider
+   */
+  constructor(
+    $provide: import("../../interface.js").Provider,
+    $$sanitizeUriProvider: any,
+  );
   /**
    * Register a new directive with the compiler.
    *
@@ -120,7 +125,7 @@ export class CompileProvider {
         $interpolate: any,
         $exceptionHandler: import("../exception-handler.js").ErrorHandler,
         $templateRequest: any,
-        $parse: import("../parse/parse.js").ParseService,
+        $parse: import("../parse/interface.ts").ParseService,
         $controller: any,
         $rootScope: import("../scope/scope.js").Scope,
         $sce: any,
@@ -134,10 +139,6 @@ export class CompileProvider {
       ) => PublicLinkFn)
   )[];
 }
-export namespace CompileProvider {
-  let $inject: string[];
-}
-export const DirectiveSuffix: "Directive";
 /**
  * A function passed as the fifth argument to a {@type PublicLinkFn} link function.
  * It behaves like a linking function, with the `scope` argument automatically created
@@ -165,7 +166,7 @@ export type PublicLinkFn = (
   scope: import("../scope/scope.js").Scope,
   cloneConnectFn?: TranscludeFn,
   options?: any,
-) => Element | Node | ChildNode;
+) => Element | Node | ChildNode | Node[];
 export type CompileFn = (
   compileNode: string | Element | Node | ChildNode | NodeList,
   transcludeFn?: TranscludeFn,
@@ -175,13 +176,19 @@ export type CompileFn = (
 ) => PublicLinkFn;
 export type LinkFnMapping = {
   index: number;
-  nodeLinkFn?: NodeLinkFn;
+  nodeLinkFnCtx?: NodeLinkFnCtx;
   childLinkFn?: CompositeLinkFn;
 };
 export type CompileNodesFn = () => CompositeLinkFn;
-export type NodeLinkFn = (
-  childLinkFn: CompositeLinkFn,
-) => Node | Element | NodeList;
+export type NodeLinkFn = () => Node | Element | NodeList;
+export type NodeLinkFnCtx = {
+  nodeLinkFn: NodeLinkFn;
+  terminal: boolean;
+  transclude: TranscludeFn;
+  transcludeOnThisElement: boolean;
+  templateOnThisElement: boolean;
+  newScope: boolean;
+};
 export type ApplyDirectivesToNodeFn = () => NodeLinkFn;
 export type CompositeLinkFn = (
   scope: import("../scope/scope.js").Scope,

package/@types/core/controller/controller.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 export function identifierForController(controller: any, ident: any): any;
 /**
- * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * The {@link ng.$controller $controller service} is used by AngularTS to create new
  * controllers.
  *
  * This provider allows controller registration via the

package/@types/core/di/internal-injector.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 /**
  * Injector for providers
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class ProviderInjector extends AbstractInjector {
   /**
@@ -11,7 +11,7 @@ export class ProviderInjector extends AbstractInjector {
 }
 /**
  * Injector for factories and services
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class InjectorService extends AbstractInjector {
   /**
@@ -21,7 +21,11 @@ export class InjectorService extends AbstractInjector {
    */
   constructor(strictDi: boolean, providerInjector: ProviderInjector);
   providerInjector: ProviderInjector;
-  factory(serviceName: any): any;
+  /**
+   * @param {string} serviceName
+   * @returns {*}
+   */
+  factory(serviceName: string): any;
   /**
    *
    * @param {string} name
@@ -41,9 +45,9 @@ declare class AbstractInjector {
   /** @type {boolean} */
   strictDi: boolean;
   path: any[];
-  /** @type {Object.<string, import("../../types").Module>} */
+  /** @type {Object.<string, import("./ng-module.js").NgModule>} */
   modules: {
-    [x: string]: any;
+    [x: string]: import("./ng-module.js").NgModule;
   };
   /**
    * Get a service by name.
@@ -68,7 +72,7 @@ declare class AbstractInjector {
    * @param {*} [self]
    * @param {Object} [locals]
    * @param {string} [serviceName]
-   * @returns
+   * @returns {*}
    */
   invoke(
     fn: Function | string | Array<any>,

package/@types/core/di/ng-module.d.ts CHANGED Viewed

@@ -22,13 +22,13 @@ export class NgModule {
    */
   constructor(name: string, requires: Array<string>, configFn?: Function);
   /**
+   * Name of the current module.
    * @type {string}
-   * Name of the module.
    */
   name: string;
   /**
-   * Holds the list of modules which the injector will load before the current module is
-   * loaded.
+   * Array of module names that this module depends on.
+   * @type {string[]}
    */
   requires: string[];
   /**

package/@types/core/error-handler.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+/**
+ * A callback type for handling errors.
+ *
+ * @param exception - The exception associated with the error.
+ * @param cause - Optional information about the context in which the error was thrown.
+ */
+export type ErrorHandler = (exception: Error, cause?: string) => void;

package/@types/core/exception-handler.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 /**
- * Handles uncaught exceptions thrown in AngularJS expressions.
+ * Handles uncaught exceptions thrown in AngularTS expressions.
  *
  * By default, this service delegates to `$log.error()`, logging the exception to the browser console.
  * You can override this behavior to provide custom exception handling—such as reporting errors
@@ -7,7 +7,7 @@
  *
  * ## Default Behavior
  *
- * Uncaught exceptions within AngularJS expressions are intercepted and passed to this service.
+ * Uncaught exceptions within AngularTS expressions are intercepted and passed to this service.
  * The default implementation logs the error using `$log.error(exception, cause)`.
  *
  * ## Custom Implementation
@@ -39,15 +39,10 @@
  * }
  * ```
  *
- * @see {@link angular.ErrorHandler AngularJS ErrorHandler}
+ * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
 /** @typedef {import('../services/log').LogService} LogService */
-/**
- * @callback ErrorHandler
- * @param {Error} exception - Exception associated with the error.
- * @param {string} [cause] - Optional information about the context in which the error was thrown.
- * @returns {void}
- */
+/** @typedef {import("./error-handler.ts").ErrorHandler }  ErrorHandler */
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
  * Can be overridden to implement custom error-handling logic.
@@ -60,4 +55,4 @@ export class ExceptionHandlerProvider {
   $get: (string | (($log: LogService) => ErrorHandler))[];
 }
 export type LogService = any;
-export type ErrorHandler = (exception: Error, cause?: string) => void;
+export type ErrorHandler = import("./error-handler.ts").ErrorHandler;

package/@types/core/filter/filter.d.ts CHANGED Viewed

@@ -1,8 +1,24 @@
-export function FilterProvider($provide: any): void;
+/**
+ * @param {import('../../interface.ts').Provider} $provide
+ */
+export function FilterProvider(
+  $provide: import("../../interface.ts").Provider,
+): void;
 export class FilterProvider {
-  constructor($provide: any);
-  register: (name: any, factory: any) => any;
-  $get: (string | (($injector: any) => (name: any) => any))[];
+  /**
+   * @param {import('../../interface.ts').Provider} $provide
+   */
+  constructor($provide: import("../../interface.ts").Provider);
+  register: (
+    name: string | Record<string, import("../../interface.ts").FilterFactory>,
+    factory: import("../../interface.ts").FilterFactory,
+  ) => import("../../interface.ts").ServiceProvider;
+  $get: (
+    | string
+    | ((
+        $injector: import("../../core/di/internal-injector.js").InjectorService,
+      ) => (name: any) => any)
+  )[];
 }
 export namespace FilterProvider {
   let $inject: string[];

package/@types/core/interpolate/interpolate.d.ts CHANGED Viewed

@@ -3,9 +3,9 @@
  * 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>
@@ -22,7 +22,7 @@ export class InterpolateProvider {
   $get: (
     | string
     | ((
-        $parse: import("../parse/parse.js").ParseService,
+        $parse: import("../parse/interface.ts").ParseService,
         $sce: any,
       ) => {
         (

package/@types/core/location/location.d.ts CHANGED Viewed

@@ -89,7 +89,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.

package/@types/core/parse/interface.d.ts ADDED Viewed

@@ -0,0 +1,79 @@
+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/@types/core/parse/interpreter.d.ts CHANGED Viewed

@@ -14,17 +14,21 @@ 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: any): any;
+  compile(ast: any): import("./interface.ts").CompiledExpression;
   /**
    * Recurses the AST nodes.
    * @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: any, context?: any, create?: boolean | 1): any;
+  recurse(
+    ast: any,
+    context?: any,
+    create?: boolean | 1,
+  ): import("./interface.ts").CompiledExpressionFunction;
   /**
    * Unary plus operation.
    * @param {function} argument - The argument function.
@@ -189,17 +193,24 @@ 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: any, context?: any): Function;
+  value(
+    value: any,
+    context?: any,
+  ): import("./interface.ts").CompiledExpressionFunction;
   /**
    * Returns the value of an identifier.
    * @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: string, context?: any, create?: boolean | 1): Function;
+  identifier(
+    name: string,
+    context?: any,
+    create?: boolean | 1,
+  ): import("./interface.ts").CompiledExpressionFunction;
   /**
    * Returns the value of a computed member expression.
    * @param {function} left - The left operand function.

package/@types/core/parse/parse.d.ts CHANGED Viewed

@@ -1,42 +1,7 @@
-/**
- * @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(): void;
 export class ParseProvider {
   /**
-   * 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
@@ -59,7 +24,7 @@ export class ParseProvider {
     identifierStart?: (arg0: any) => boolean,
     identifierContinue?: (arg0: any) => boolean,
   ) => ParseProvider;
-  $get: (string | (($filter: (any: any) => any) => ParseService))[];
+  $get: (string | (($filter: (any: any) => any) => any))[];
 }
 export function constantWatchDelegate(
   scope: any,
@@ -67,60 +32,3 @@ export function constantWatchDelegate(
   objectEquality: any,
   parsedExpression: any,
 ): any;
-export type CompiledExpressionProps = {
-  /**
-   * - Indicates if the expression is a literal.
-   */
-  literal: boolean;
-  /**
-   * - Indicates if the expression is constant.
-   */
-  constant: boolean;
-  isPure?: boolean;
-  oneTime: boolean;
-  decoratedNode: import("./interpreter.js").DecoratedASTNode;
-  $$watchDelegate?: (
-    arg0: import("../scope/scope.js").Scope,
-    arg1: Function,
-    arg2: boolean,
-    arg3: CompiledExpression,
-    arg4:
-      | string
-      | ((scope: import("../scope/scope.js").Scope) => any)
-      | CompiledExpression,
-  ) => any;
-  inputs: any[] | Function;
-  /**
-   * - Assigns a value to a context. If value is not provided,
-   */
-  assign?: (arg0: any, arg1: any) => any;
-};
-export type CompiledExpressionHandlerMap = {
-  /**
-   * - Indicates if the expression is a literal.
-   */
-  literal: boolean;
-  /**
-   * - Indicates if the expression is constant.
-   */
-  constant: boolean;
-  isPure?: boolean;
-  oneTime: boolean;
-  /**
-   * - property keys to observe
-   */
-  keyMap: Map<string, Function>;
-};
-export type CompiledExpressionFunction = Function;
-export type CompiledExpression = CompiledExpressionFunction &
-  CompiledExpressionProps;
-export type ParseService = (
-  arg0:
-    | CompiledExpression
-    | string
-    | ((arg0: import("../scope/scope.js").Scope) => any),
-  arg1:
-    | ((arg0: any, arg1: import("../scope/scope.js").Scope, arg2: any) => any)
-    | undefined,
-  arg2: boolean | undefined,
-) => CompiledExpression;

package/@types/core/parse/parser/parser.d.ts CHANGED Viewed

@@ -22,9 +22,9 @@ export class Parser {
   /**
    *
    * @param {string} exp - Expression to be parsed
-   * @returns {import("../parse.js").CompiledExpression}
+   * @returns {import("../interface.ts").CompiledExpression}
    */
-  parse(exp: string): import("../parse.js").CompiledExpression;
+  parse(exp: string): import("../interface.ts").CompiledExpression;
   /**
    * @param {string} exp - Expression to be parsed
    * @returns {ParsedAST}

package/@types/core/sanitize/interface.d.ts ADDED Viewed

@@ -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;
+}