@angular-wave/angular.ts 0.9.0 → 0.9.1

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

@@ -1,201 +0,0 @@
-export const DirectiveSuffix: "Directive";
-export class CompileProvider {
-  static $inject: string[];
-  /**
-   * @param {import('../../interface.js').Provider} $provide
-   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
-   */
-  constructor(
-    $provide: import("../../interface.js").Provider,
-    $$sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
-  );
-  /**
-   * Register a new directive with the compiler.
-   *
-   * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
-   *    as `ng-bind`), or an object map of directives where the keys are the names and the values
-   *    are the factories.
-   * @param {Function|Array} directiveFactory An injectable directive factory function. See the
-   *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
-   * @returns {CompileProvider} Self for chaining.
-   */
-  directive: (
-    name: string | any,
-    directiveFactory: Function | any[],
-  ) => CompileProvider;
-  /**
-   * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
-   *    or an object map of components where the keys are the names and the values are the component definition objects.
-   * @param {import("../../interface.js").ComponentOptions} options Component definition object (a simplified
-   *    {directive definition object}),
-   *    with the following properties (all optional):
-   *
-   *    - `controller` – `{(string|function()=}` – controller constructor function that should be
-   *      associated with newly created scope or the name of a {controller} if passed as a string. An empty `noop` function by default.
-   *    - `controllerAs` – `{string=}` – identifier name for to reference the controller in the component's scope.
-   *      If present, the controller will be published to scope under the `controllerAs` name.
-   *      If not present, this will default to be `$ctrl`.
-   *    - `template` – `{string=|function()=}` – html template as a string or a function that
-   *      returns an html template as a string which should be used as the contents of this component.
-   *      Empty string by default.
-   *
-   *      If `template` is a function, then it is {injected} with
-   *      the following locals:
-   *
-   *      - `$element` - Current element
-   *      - `$attrs` - Current attributes object for the element
-   *
-   *    - `templateUrl` – `{string=|function()=}` – path or function that returns a path to an html
-   *      template that should be used  as the contents of this component.
-   *
-   *      If `templateUrl` is a function, then it is {injected} with
-   *      the following locals:
-   *
-   *      - `$element` - Current element
-   *      - `$attrs` - Current attributes object for the element
-   *
-   *    - `bindings` – `{object=}` – defines bindings between DOM attributes and component properties.
-   *      Component properties are always bound to the component controller and not to the scope.
-   *      See {`bindToController`}.
-   *    - `transclude` – `{boolean=}` – whether {content transclusion} is enabled.
-   *      Disabled by default.
-   *    - `require` - `{Object<string, string>=}` - requires the controllers of other directives and binds them to
-   *      this component's controller. The object keys specify the property names under which the required
-   *      controllers (object values) will be bound. See {`require`}.
-   *    - `$...` – additional properties to attach to the directive factory function and the controller
-   *      constructor function. (This is used by the component router to annotate)
-   *
-   * @returns {CompileProvider} the compile provider itself, for chaining of function calls.
-   */
-  component: (
-    name: string | any,
-    options: import("../../interface.js").ComponentOptions,
-  ) => CompileProvider;
-  /**
-   * 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 preventing XSS attacks via html links.
-   *
-   * Any url about to be assigned to a[href] via data-binding is first normalized and turned into
-   * an absolute url. Afterwards, the url is matched against the `aHrefSanitizationTrustedUrlList`
-   * regular expression. If a match is found, the original url is written into the dom. Otherwise,
-   * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
-   *
-   * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
-   *    chaining otherwise.
-   */
-  aHrefSanitizationTrustedUrlList: (
-    regexp?: RegExp | undefined,
-  ) => RegExp | import("../sanitize/sanitize-uri.js").SanitizeUriProvider;
-  /**
-   * 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 links.
-   *
-   * Any url about to be assigned to img[src] via data-binding is first normalized and turned into
-   * an absolute url. Afterwards, the url is matched against the `imgSrcSanitizationTrustedUrlList`
-   * regular expression. If a match is found, the original url is written into the dom. Otherwise,
-   * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
-   *
-   * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
-   *    chaining otherwise.
-   */
-  imgSrcSanitizationTrustedUrlList: (
-    regexp?: RegExp | undefined,
-  ) => RegExp | import("../sanitize/sanitize-uri.js").SanitizeUriProvider;
-  strictComponentBindingsEnabled: (enabled: any) => boolean | this;
-  /**
-   * Defines the security context for DOM properties bound by ng-prop-*.
-   *
-   * @param {string} elementName The element name or '*' to match any element.
-   * @param {string} propertyName The DOM property name.
-   * @param {string} ctx The {@link $sce} security context in which this value is safe for use, e.g. `$sce.URL`
-   * @returns {object} `this` for chaining
-   */
-  addPropertySecurityContext: (
-    elementName: string,
-    propertyName: string,
-    ctx: string,
-  ) => object;
-  $get: (
-    | string
-    | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
-        $interpolate: any,
-        $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-        $templateRequest: any,
-        $parse: import("../parse/interface.ts").ParseService,
-        $controller: any,
-        $rootScope: import("../scope/scope.js").Scope,
-        $sce: any,
-        $animate: any,
-      ) => (
-        compileNode: string | Element | Node | ChildNode | NodeList,
-        transcludeFn?: TranscludeFn,
-        maxPriority?: number,
-        ignoreDirective?: string,
-        previousCompileContext?: any,
-      ) => PublicLinkFn)
-  )[];
-}
-/**
- * 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
- * as a new child of the transcluded parent scope.
- *
- * The function returns the DOM content to be injected (transcluded) into the directive.
- */
-export type TranscludeFn = (
-  clone?: Element | Node | ChildNode | NodeList | Node[],
-  scope?: import("../scope/scope.js").Scope,
-) => any;
-/**
- * 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
- * as a new child of the transcluded parent scope.
- *
- * The function returns the DOM content to be injected (transcluded) into the directive.
- */
-export type BoundTranscludeFn = () => Element | Node;
-export type SimpleChange = {
-  currentValue: any;
-  firstChange: boolean;
-};
-export type PublicLinkFn = (
-  scope: import("../scope/scope.js").Scope,
-  cloneConnectFn?: TranscludeFn,
-  options?: any,
-) => Element | Node | ChildNode | Node[];
-export type CompileFn = (
-  compileNode: string | Element | Node | ChildNode | NodeList,
-  transcludeFn?: TranscludeFn,
-  maxPriority?: number,
-  ignoreDirective?: string,
-  previousCompileContext?: any,
-) => PublicLinkFn;
-export type LinkFnMapping = {
-  index: number;
-  nodeLinkFnCtx?: NodeLinkFnCtx;
-  childLinkFn?: CompositeLinkFn;
-};
-export type CompileNodesFn = () => CompositeLinkFn;
-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,
-  $linkNode: NodeRef,
-  parentBoundTranscludeFn?: Function,
-) => any;
-import { NodeRef } from "../../shared/noderef.js";

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

@@ -1,54 +0,0 @@
-export function identifierForController(controller: any, ident: any): any;
-/**
- * The {@link ng.$controller $controller service} is used by AngularTS to create new
- * controllers.
- *
- * This provider allows controller registration via the
- * {@link ng.$controllerProvider#register register} method.
- */
-export class ControllerProvider {
-  /**
-   * @type {Map<string, Function|Object>}
-   * @private
-   */
-  private controllers;
-  /**
-   * Check if a controller with a given name exists.
-   *
-   * @param {string} name Controller name to check.
-   * @returns {boolean} True if the controller exists, false otherwise.
-   */
-  has(name: string): boolean;
-  /**
-   * Register a controller.
-   *
-   * @param {string|Object} name Controller name, or an object map of controllers where the keys are
-   *    the names and the values are the constructors.
-   * @param {Function|Array} constructor Controller constructor function (optionally decorated with DI
-   *    annotations in the array notation).
-   */
-  register(name: string | any, constructor: Function | any[]): void;
-  /**
-   * $get method for dependency injection.
-   */
-  $get: (
-    | string
-    | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => Function)
-  )[];
-  /**
-   * Adds an identifier to the controller instance in the given locals' scope.
-   *
-   * @param {Object} locals The locals object containing the scope.
-   * @param {string} identifier The identifier to assign.
-   * @param {Object} instance The controller instance.
-   * @param {string} name The name of the controller.
-   */
-  addIdentifier(
-    locals: any,
-    identifier: string,
-    instance: any,
-    name: string,
-  ): void;
-}

package/@types/core/di/injector.d.ts

@@ -1,22 +0,0 @@
-/**
- *
- * @param {Array<String|Function>} modulesToLoad
- * @param {boolean} [strictDi]
- * @returns {InjectorService}
- */
-export function createInjector(
-  modulesToLoad: Array<string | Function>,
-  strictDi?: boolean,
-): InjectorService;
-/**
- * @param {any} fn
- * @param {boolean} [strictDi]
- * @param {String} [name]
- * @returns {Array<string>}
- */
-export function annotate(
-  fn: any,
-  strictDi?: boolean,
-  name?: string,
-): Array<string>;
-import { InjectorService } from "./internal-injector.js";

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

@@ -1,23 +0,0 @@
-export class FilterProvider {
-  static $inject: string[];
-  /**
-   * @param {import('../../interface.ts').Provider} $provide
-   */
-  constructor($provide: import("../../interface.ts").Provider);
-  $provide: import("../../interface.ts").Provider;
-  /**
-   * @param {string|Record<string, import('../../interface.ts').FilterFactory>} name
-   * @param {import('../../interface.ts').FilterFactory} [factory]
-   * @return {import('../../interface.ts').Provider}
-   */
-  register(
-    name: string | Record<string, import("../../interface.ts").FilterFactory>,
-    factory?: import("../../interface.ts").FilterFactory,
-  ): import("../../interface.ts").Provider;
-  $get: (
-    | string
-    | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
-      ) => import("../../interface.ts").FilterFn)
-  )[];
-}

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

@@ -1,38 +0,0 @@
-/**
- *
- * 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 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 AngularTS
- * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
- * security bugs!
- * </div>
- */
-export class InterpolateProvider {
-  /**
-   * @type {string} Symbol to denote start of expression in the interpolated string. Defaults to `{{`.
-   */
-  startSymbol: string;
-  /**
-   * @type {string} Symbol to denote the end of expression in the interpolated string. Defaults to `}}`.
-   */
-  endSymbol: string;
-  $get: (
-    | string
-    | ((
-        $parse: import("../parse/interface.ts").ParseService,
-        $sce: any,
-      ) => {
-        (
-          text: string,
-          mustHaveExpression?: boolean | undefined,
-          trustedContext?: string | undefined,
-          allOrNothing?: boolean | undefined,
-        ): Function;
-        startSymbol(): string;
-        endSymbol(): string;
-      })
-  )[];
-}

package/@types/core/parse/ast/ast-node.d.ts

@@ -1,56 +0,0 @@
-import { ASTType } from "../ast-type.js";
-/**
- * Represents a node in an Abstract Syntax Tree (AST).
- */
-export type ASTNode = {
-  /** The type of the AST node. */
-  type: ASTType;
-  /** The name of the identifier, if applicable. */
-  name?: string;
-  /** The kind of the property (e.g., 'init'). */
-  kind?: string;
-  /** The value of the node if it is a literal. */
-  value?: any;
-  /** The elements of an array node. */
-  elements?: ASTNode[];
-  /** The properties of an object node. */
-  properties?: ASTNode[];
-  /** The key of an object property. */
-  key?: ASTNode;
-  /** The left-hand side of a binary expression. */
-  left?: ASTNode;
-  /** The right-hand side of a binary expression. */
-  right?: ASTNode;
-  /** The argument of a unary expression. */
-  argument?: ASTNode;
-  /** The test expression of a conditional expression. */
-  test?: ASTNode;
-  /** The alternate expression of a conditional expression. */
-  alternate?: ASTNode;
-  /** The consequent expression of a conditional expression. */
-  consequent?: ASTNode;
-  /** The body of a program or block statement. */
-  body?: ASTNode[];
-  /** A list of expressions to observe in a program or block statement. */
-  toWatch?: ASTNode[];
-  /** The expression of an expression statement. */
-  expression?: ASTNode;
-  /** The callee of a call expression. */
-  callee?: ASTNode;
-  /** The arguments of a call expression. */
-  arguments?: ASTNode[];
-  /** Indicates if a unary operator is a prefix. */
-  prefix?: boolean;
-  /** The object of a member expression. */
-  object?: ASTNode;
-  /** The property of a member expression. */
-  property?: ASTNode;
-  /** Indicates if a member expression is computed. */
-  computed?: boolean;
-  /** The operator of a binary or logical expression. */
-  operator?: string;
-  /** Indicates if the expression should be filtered. */
-  filter?: boolean;
-  /** Indicates in node depends on non-shallow state of objects */
-  isPure?: boolean;
-};

package/@types/core/parse/ast/ast.d.ts

@@ -1,164 +0,0 @@
-/**
- * @class
- */
-export class AST {
-  /**
-   * @param {import('../lexer/lexer.js').Lexer} lexer - The lexer instance for tokenizing input
-   */
-  constructor(lexer: import("../lexer/lexer.js").Lexer);
-  /** @type {import('../lexer/lexer.js').Lexer} */
-  lexer: import("../lexer/lexer.js").Lexer;
-  selfReferential: {
-    this: {
-      type: number;
-    };
-    $locals: {
-      type: number;
-    };
-  };
-  /**
-   * Parses the input text and generates an AST.
-   * @param {string} text - The input text to parse.
-   * @returns {ASTNode} The root node of the AST.
-   */
-  ast(text: string): ASTNode;
-  text: string;
-  tokens: import("../lexer/token.js").Token[];
-  /**
-   * Parses a program.
-   * @returns {ASTNode} The program node.
-   */
-  program(): ASTNode;
-  /**
-   * Parses an expression statement.
-   * @returns {ASTNode} The expression statement node.
-   */
-  expressionStatement(): ASTNode;
-  /**
-   * Parses a filter chain.
-   * @returns {ASTNode} The filter chain node.
-   */
-  filterChain(): ASTNode;
-  /**
-   * Parses an assignment expression.
-   * @returns {ASTNode} The assignment expression node.
-   */
-  assignment(): ASTNode;
-  /**
-   * Parses a ternary expression.
-   * @returns {ASTNode} The ternary expression node.
-   */
-  ternary(): ASTNode;
-  /**
-   * Parses a logical OR expression.
-   * @returns {ASTNode} The logical OR expression node.
-   */
-  logicalOR(): ASTNode;
-  /**
-   * Parses a logical AND expression.
-   * @returns {ASTNode} The logical AND expression node.
-   */
-  logicalAND(): ASTNode;
-  /**
-   * Parses an equality expression.
-   * @returns {ASTNode} The equality expression node.
-   */
-  equality(): ASTNode;
-  /**
-   * Parses a relational expression.
-   * @returns {ASTNode} The relational expression node.
-   */
-  relational(): ASTNode;
-  /**
-   * Parses an additive expression.
-   * @returns {ASTNode} The additive expression node.
-   */
-  additive(): ASTNode;
-  /**
-   * Parses a multiplicative expression.
-   * @returns {ASTNode} The multiplicative expression node.
-   */
-  multiplicative(): ASTNode;
-  /**
-   * Parses a unary expression.
-   * @returns {ASTNode} The unary expression node.
-   */
-  unary(): ASTNode;
-  /**
-   * Parses a primary expression.
-   * @returns {ASTNode} The primary expression node.
-   */
-  primary(): ASTNode;
-  /**
-   * Parses a filter.
-   * @param {ASTNode} baseExpression - The base expression to apply the filter to.
-   * @returns {ASTNode} The filter node.
-   */
-  filter(baseExpression: ASTNode): ASTNode;
-  /**
-   * Parses function arguments.
-   * @returns {ASTNode[]} The arguments array.
-   */
-  parseArguments(): ASTNode[];
-  /**
-   * Parses an identifier.
-   * @returns {ASTNode} The identifier node.
-   */
-  identifier(): ASTNode;
-  /**
-   * Parses a constant.
-   * @returns {ASTNode} The constant node.
-   */
-  constant(): ASTNode;
-  /**
-   * Parses an array declaration.
-   * @returns {ASTNode} The array declaration node.
-   */
-  arrayDeclaration(): ASTNode;
-  /**
-   * Parses an object.
-   * @returns {ASTNode} The object node.
-   */
-  object(): ASTNode;
-  /**
-   * Throws a syntax error.
-   * @param {string} msg - The error message.
-   * @param {import("../lexer/lexer.js").Token} [token] - The token that caused the error.
-   */
-  throwError(msg: string, token?: import("../lexer/lexer.js").Token): void;
-  /**
-   * Consumes a token if it matches the expected type.
-   * @param {string} [e1] - The expected token type.
-   * @returns {import("../lexer/lexer.js").Token} The consumed token.
-   */
-  consume(e1?: string): import("../lexer/lexer.js").Token;
-  /**
-   * Returns the next token without consuming it.
-   * @returns {import("../lexer/lexer.js").Token} The next token.
-   */
-  peekToken(): import("../lexer/lexer.js").Token;
-  /**
-   * Checks if the next token matches any of the expected types.
-   * @param {...string} [expected] - The expected token types.
-   * @returns {import('../lexer/lexer.js').Token|boolean} The next token if it matches, otherwise false.
-   */
-  peek(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
-  /**
-   * Checks if the token at the specified index matches any of the expected types.
-   * @param {number} i - The index to check.
-   * @param {...string} [expected] - The expected token types.
-   * @returns {import("../lexer/lexer.js").Token|boolean} The token at the specified index if it matches, otherwise false.
-   */
-  peekAhead(
-    i: number,
-    ...expected: string[]
-  ): import("../lexer/lexer.js").Token | boolean;
-  /**
-   * Consumes the next token if it matches any of the expected types.
-   * @param {...string} [expected] - The expected token types.
-   * @returns {import("../lexer/lexer.js").Token|boolean} The consumed token if it matches, otherwise false.
-   */
-  expect(...expected: string[]): import("../lexer/lexer.js").Token | boolean;
-}
-export type ASTNode = import("./ast-node.ts").ASTNode;
-export type Token = import("../lexer/token.js").Token;

package/@types/core/parse/lexer/lexer.d.ts

@@ -1,119 +0,0 @@
-/**
- * @typedef {Object} LexerOptions
- * @property {(ch: string, codePoint: number) => boolean} [isIdentifierStart] - Custom function to determine if a character is a valid identifier start.
- * @property {(ch: string, codePoint: number) => boolean} [isIdentifierContinue] - Custom function to determine if a character is a valid identifier continuation.
- */
-/**
- * Represents a lexer that tokenizes input text. The Lexer takes the original expression string and returns an array of tokens parsed from that string.
- * For example, the string "a + b" would result in tokens for a, +, and b.
- */
-export class Lexer {
-  /**
-   * Creates an instance of Lexer.
-   * @param {LexerOptions} options - Lexer options.
-   */
-  constructor(options: LexerOptions);
-  /** @type {LexerOptions} */
-  options: LexerOptions;
-  /**
-   * Tokenizes the input text.
-   * @param {string} text Input text to lex.
-   * @returns {Array<Token>} Array of tokens.
-   */
-  lex(text: string): Array<Token>;
-  text: string;
-  index: number;
-  /** @type {Array<Token>} */
-  tokens: Array<Token>;
-  /**
-   * Checks if a character is contained in a set of characters.
-   * @param {string} ch Character to check.
-   * @param {string} chars Set of characters.
-   * @returns {boolean} True if character is in the set, false otherwise.
-   */
-  is(ch: string, chars: string): boolean;
-  /**
-   * Peeks at the next character in the text.
-   * @param {number} [i=1] Number of characters to peek.
-   * @returns {string|false} Next character or false if end of text.
-   */
-  peek(i?: number): string | false;
-  /**
-   * Checks if a character is a number.
-   * @param {string} ch Character to check.
-   * @returns {boolean} True if character is a number, false otherwise.
-   */
-  isNumber(ch: string): boolean;
-  /**
-   * Checks if a character is whitespace.
-   * @param {string} ch Character to check.
-   * @returns {boolean} True if character is whitespace, false otherwise.
-   */
-  isWhitespace(ch: string): boolean;
-  /**
-   * Checks if a character is a valid identifier start.
-   * @param {string} ch Character to check.
-   * @returns {boolean} True if character is a valid identifier start, false otherwise.
-   */
-  isIdentifierStart(ch: string): boolean;
-  /**
-   * Checks if a character is a valid identifier continuation.
-   * @param {string} ch Character to check.
-   * @returns {boolean} True if character is a valid identifier continuation, false otherwise.
-   */
-  isIdentifierContinue(ch: string): boolean;
-  /**
-   * Converts a character to its Unicode code point.
-   * @param {string} ch Character to convert.
-   * @returns {number} Unicode code point.
-   */
-  codePointAt(ch: string): number;
-  /**
-   * Peeks at the next multicharacter sequence in the text.
-   * @returns {string} Next multicharacter sequence.
-   */
-  peekMultichar(): string;
-  /**
-   * Checks if a character is an exponent operator.
-   * @param {string} ch Character to check.
-   * @returns {boolean} True if character is an exponent operator, false otherwise.
-   */
-  isExpOperator(ch: string): boolean;
-  /**
-   * Throws a lexer error.
-   * @param {string} error Error message.
-   * @param {number} [start] Start index.
-   * @param {number} [end] End index.
-   * @throws {Error} Lexer error.
-   */
-  throwError(error: string, start?: number, end?: number): void;
-  /**
-   * Reads and tokenizes a number from the text.
-   * @return {void}
-   */
-  readNumber(): void;
-  /**
-   * Reads and tokenizes an identifier from the text.
-   */
-  readIdent(): void;
-  /**
-   * Reads and tokenizes a string from the text.
-   * @param {string} quote Quote character used for the string.
-   */
-  readString(quote: string): void;
-  /**
-   * @returns {string}
-   */
-  handleUnicodeEscape(): string;
-}
-export type Token = import("./token.ts").Token;
-export type LexerOptions = {
-  /**
-   * - Custom function to determine if a character is a valid identifier start.
-   */
-  isIdentifierStart?: (ch: string, codePoint: number) => boolean;
-  /**
-   * - Custom function to determine if a character is a valid identifier continuation.
-   */
-  isIdentifierContinue?: (ch: string, codePoint: number) => boolean;
-};