pinets 0.6.1 → 0.7.1

package/dist/types/Context.class.d.ts

@@ -1,42 +1,19 @@
-import { IProvider, ISymbolInfo } from './marketData/IProvider';
+import { IProvider } from './marketData/IProvider';
 import { PineArray } from './namespaces/array/array.index';
-import { PineMap } from './namespaces/map/map.index';
-import { PineMatrix } from './namespaces/matrix/matrix.index';
-import { Barstate } from './namespaces/Barstate';
 import { Input } from './namespaces/input/input.index';
 import PineMath from './namespaces/math/math.index';
 import { PineRequest } from './namespaces/request/request.index';
 import TechnicalAnalysis from './namespaces/ta/ta.index';
 import { Series } from './Series';
-import { Log } from './namespaces/Log';
-import { Str } from './namespaces/Str';
-import { Timeframe } from './namespaces/Timeframe';
 export declare class Context {
     data: any;
+    indicator: IndicatorOptions;
     cache: any;
     taState: any;
     isSecondaryContext: boolean;
     NA: any;
     lang: any;
     pine: {
-        input: Input;
-        ta: TechnicalAnalysis;
-        math: PineMath;
-        request: PineRequest;
-        array: PineArray;
-        map: PineMap;
-        matrix: PineMatrix;
-        na: () => any;
-        plotchar: (...args: any[]) => any;
-        color: any;
-        plot: (...args: any[]) => any;
-        nz: (...args: any[]) => any;
-        bar_index: number;
-        syminfo: ISymbolInfo;
-        barstate: Barstate;
-        log: Log;
-        str: Str;
-        timeframe: Timeframe;
         [key: string]: any;
     };
     private static _deprecationWarningsShown;
@@ -66,6 +43,7 @@ export declare class Context {
         eDate?: number;
         fullContext?: Context;
     });
+    private bindContextObject;
     /**
      * this function is used to initialize the target variable with the source array
      * this array will represent a time series and its values will be shifted at runtime in order to mimic Pine script behavior

package/dist/types/namespaces/Core.d.ts

@@ -1,3 +1,4 @@
+export declare function parseIndicatorOptions(args: any[]): Partial<IndicatorOptions>;
 export declare class Core {
     private context;
     color: {
@@ -30,10 +31,14 @@ export declare class Core {
     };
     constructor(context: any);
     private extractPlotOptions;
-    indicator(title: string, shorttitle?: string, options?: IndicatorOptions): void;
-    plotchar(series: number[], title: string, options: PlotCharOptions): void;
-    plot(series: any, title: string, options: PlotOptions): void;
+    indicator(...args: any[]): any;
     get bar_index(): any;
     na(series: any): boolean;
     nz(series: any, replacement?: number): any;
+    fixnan(series: any): any;
+    alertcondition(condition: any, title: any, message: any): void;
+    bool(series: any): boolean;
+    int(series: any): number;
+    float(series: any): number;
+    string(series: any): any;
 }

package/dist/types/namespaces/Plot.helper.d.ts

@@ -0,0 +1,16 @@
+export declare class PlotHelper {
+    private context;
+    constructor(context: any);
+    private extractPlotOptions;
+    plotchar(series: number[], title: string, options: PlotCharOptions): void;
+    plot(...args: any[]): void;
+}
+export declare class HlineHelper {
+    private context;
+    constructor(context: any);
+    get style_dashed(): string;
+    get style_solid(): string;
+    get style_dotted(): string;
+    param(source: any, index?: number, name?: string): any;
+    any(price: any, title: any, color: any, linestyle: any, linewidth: any, editable: any, display: any): any;
+}

package/dist/types/namespaces/Plots.d.ts

@@ -0,0 +1,16 @@
+export declare class PlotHelper {
+    private context;
+    constructor(context: any);
+    private extractPlotOptions;
+    plotchar(series: number[], title: string, options: PlotCharOptions): void;
+    plot(...args: any[]): void;
+}
+export declare class HlineHelper {
+    private context;
+    constructor(context: any);
+    get style_dashed(): string;
+    get style_solid(): string;
+    get style_dotted(): string;
+    param(source: any, index?: number, name?: string): any;
+    any(price: any, title: any, color: any, linestyle: any, linewidth: any, editable: any, display: any): any;
+}

package/dist/types/namespaces/Types.d.ts

@@ -74,7 +74,6 @@ export declare enum display {
     data_window = "data_window",
     none = "none",
     pane = "pane",
-    pine_screener = "pine_screener",
     price_scale = "price_scale",
     status_line = "status_line"
 }
@@ -82,5 +81,6 @@ declare const types: {
     order: typeof order;
     currency: typeof currency;
     dayofweek: typeof dayofweek;
+    display: typeof display;
 };
 export default types;

package/dist/types/namespaces/input/utils.d.ts

@@ -1,14 +1,2 @@
-export declare function parseInputOptions(args: any[]): {
-    defval?: any;
-    title?: string;
-    options?: any[];
-    tooltip?: string;
-    minval?: number;
-    maxval?: number;
-    step?: number;
-    inline?: string;
-    group?: string;
-    confirm?: boolean;
-    display?: string;
-    active?: boolean;
-};
+import { InputOptions } from './types';
+export declare function parseInputOptions(args: any[]): Partial<InputOptions>;

package/dist/types/namespaces/ta/methods/pivothigh.d.ts

@@ -1 +1 @@
-export declare function pivothigh(context: any): (source: any, _leftbars: any, _rightbars: any) => any;
+export declare function pivothigh(context: any): (source: any, _leftbars: any, _rightbars: any, _callId?: string) => any;

package/dist/types/namespaces/ta/methods/pivotlow.d.ts

@@ -1 +1 @@
-export declare function pivotlow(context: any): (source: any, _leftbars: any, _rightbars: any) => any;
+export declare function pivotlow(context: any): (source: any, _leftbars: any, _rightbars: any, _callId?: string) => any;

package/dist/types/namespaces/utils.d.ts

@@ -0,0 +1,12 @@
+import { Series } from '../Series';
+export type PineTypeMap<T> = {
+    [K in keyof T]-?: T[K] extends number ? 'number' : T[K] extends string ? 'string' : T[K] extends boolean ? 'boolean' : T[K] extends Series ? 'series' : T[K] extends Array<any> ? 'array' : never;
+};
+/**
+ * This function is used to parse the arguments for a Pine params.
+ * @param args - The arguments to parse.
+ * @param signatures - The signatures to parse, each signature is an array of argument names.
+ * @param types - The types to parse, each type is a string representing the type of the argument.
+ * @returns The parsed arguments, the arguments are parsed according to the signatures and types.
+ */
+export declare function parseArgsForPineParams<T>(args: any[], signatures: any[], types: Record<string, string>): Partial<T> & T;

package/dist/types/transpiler/index.d.ts

@@ -1,4 +1,4 @@
-export declare function transpile(fn: string | Function, options?: {
+export declare function transpile(source: string | Function, options?: {
     debug: boolean;
     ln?: boolean;
 }): Function;

package/dist/types/transpiler/pineToJS/ast.d.ts

@@ -0,0 +1,167 @@
+export declare class ASTNode {
+    type: string;
+    constructor(type: string);
+}
+export declare class Program extends ASTNode {
+    body: any[];
+    constructor(body: any[]);
+}
+export declare class ExpressionStatement extends ASTNode {
+    expression: any;
+    constructor(expression: any);
+}
+export declare enum VariableDeclarationKind {
+    VAR = "var",
+    LET = "let",
+    CONST = "const"
+}
+export declare class VariableDeclaration extends ASTNode {
+    declarations: any[];
+    kind: VariableDeclarationKind;
+    constructor(declarations: any[], kind?: VariableDeclarationKind);
+}
+export declare class VariableDeclarator extends ASTNode {
+    id: any;
+    init: any;
+    varType: any;
+    constructor(id: any, init: any, varType?: any);
+}
+export declare class FunctionDeclaration extends ASTNode {
+    id: any;
+    params: any[];
+    body: any;
+    returnType: any;
+    constructor(id: any, params: any[], body: any, returnType?: any);
+}
+export declare class TypeDefinition extends ASTNode {
+    name: string;
+    fields: any[];
+    constructor(name: string, fields: any[]);
+}
+export declare class IfStatement extends ASTNode {
+    test: any;
+    consequent: any;
+    alternate: any | null;
+    _line: number;
+    constructor(test: any, consequent: any, alternate?: any | null);
+}
+export declare class ForStatement extends ASTNode {
+    init: any;
+    test: any;
+    update: any;
+    body: any;
+    isForIn: boolean;
+    constructor(init: any, test: any, update: any, body: any);
+}
+export declare class WhileStatement extends ASTNode {
+    test: any;
+    body: any;
+    constructor(test: any, body: any);
+}
+export declare class BlockStatement extends ASTNode {
+    body: any[];
+    constructor(body: any[]);
+}
+export declare class ReturnStatement extends ASTNode {
+    argument: any;
+    constructor(argument: any);
+}
+export declare class Identifier extends ASTNode {
+    name: string;
+    varType: string;
+    returnType: any;
+    isMethod: boolean;
+    constructor(name: string);
+}
+export declare class Literal extends ASTNode {
+    value: any;
+    raw: string;
+    constructor(value: any, raw?: string);
+}
+export declare class BinaryExpression extends ASTNode {
+    operator: string;
+    left: any;
+    right: any;
+    constructor(operator: string, left: any, right: any);
+}
+export declare class UnaryExpression extends ASTNode {
+    operator: string;
+    argument: any;
+    prefix: boolean;
+    constructor(operator: string, argument: any, prefix?: boolean);
+}
+export declare class AssignmentExpression extends ASTNode {
+    operator: string;
+    left: any;
+    right: any;
+    constructor(operator: string, left: any, right: any);
+}
+export declare class UpdateExpression extends ASTNode {
+    operator: string;
+    argument: any;
+    prefix: boolean;
+    constructor(operator: string, argument: any, prefix?: boolean);
+}
+export declare class CallExpression extends ASTNode {
+    callee: any;
+    args: any[];
+    arguments: any[];
+    constructor(callee: any, args: any[]);
+}
+export declare class MemberExpression extends ASTNode {
+    object: any;
+    property: any;
+    computed: boolean;
+    constructor(object: any, property: any, computed?: boolean);
+}
+export declare class ConditionalExpression extends ASTNode {
+    test: any;
+    consequent: any;
+    alternate: any;
+    needsIIFE: boolean;
+    consequentStmts: any[];
+    alternateStmts: any[];
+    constructor(test: any, consequent: any, alternate: any);
+}
+export declare class ArrayExpression extends ASTNode {
+    elements: any[];
+    constructor(elements: any[]);
+}
+export declare class ObjectExpression extends ASTNode {
+    properties: any[];
+    constructor(properties: any[]);
+}
+export declare class Property extends ASTNode {
+    key: any;
+    value: any;
+    kind: string;
+    method: boolean;
+    shorthand: boolean;
+    computed: boolean;
+    constructor(key: any, value: any);
+}
+export declare class ArrayPattern extends ASTNode {
+    elements: any[];
+    constructor(elements: any[]);
+}
+export declare class AssignmentPattern extends ASTNode {
+    left: any;
+    right: any;
+    constructor(left: any, right: any);
+}
+export declare class ArrowFunctionExpression extends ASTNode {
+    params: any[];
+    body: any;
+    expression: boolean;
+    constructor(params: any[], body: any, expression?: boolean);
+}
+export declare class SwitchExpression extends ASTNode {
+    discriminant: any;
+    cases: any[];
+    constructor(discriminant: any, cases: any[]);
+}
+export declare class SwitchCase extends ASTNode {
+    test: any;
+    consequent: any;
+    constructor(test: any, consequent: any);
+}

package/dist/types/transpiler/pineToJS/codegen.d.ts

@@ -0,0 +1,53 @@
+export declare class CodeGenerator {
+    private indent;
+    private indentStr;
+    private output;
+    private sourceCode;
+    private sourceLines;
+    private lastCommentedLine;
+    private includeSourceComments;
+    constructor(options?: {
+        indentStr?: string;
+        sourceCode?: string;
+        includeSourceComments?: boolean;
+    });
+    generate(ast: any): string;
+    writeSourceComment(startLine: any, endLine?: any): void;
+    write(str: any): void;
+    writeLine(str?: string): void;
+    increaseIndent(): void;
+    decreaseIndent(): void;
+    generateProgram(node: any): void;
+    generateStatement(node: any): void;
+    generateTypeDefinition(node: any): void;
+    generateFunctionDeclaration(node: any): void;
+    generateVariableDeclaration(node: any): void;
+    generateExpressionStatement(node: any): void;
+    generateIfStatement(node: any): void;
+    generateIfStatementWithAssignment(condExpr: any, varName: any): void;
+    generateNestedIfWithAssignments(node: any, varName: any): void;
+    generateNestedIfAlternatesWithAssignments(alternate: any, varName: any): void;
+    generateForStatement(node: any): void;
+    generateWhileStatement(node: any): void;
+    generateReturnStatement(node: any): void;
+    generateBlockStatement(node: any, addIndent?: boolean): void;
+    generateExpression(node: any): void;
+    generateLiteral(node: any): void;
+    generateBinaryExpression(node: any): void;
+    generateUnaryExpression(node: any): void;
+    generateAssignmentExpression(node: any): void;
+    generateUpdateExpression(node: any): void;
+    generateCallExpression(node: any): void;
+    generateMemberExpression(node: any): void;
+    generateConditionalExpression(node: any): void;
+    generateIIFEConditional(node: any): void;
+    generateIIFEIfBlock(node: any): void;
+    generateNestedIfWithReturns(node: any): void;
+    generateNestedIfAlternates(alternate: any): void;
+    generateNestedIfAsExpression(node: any): void;
+    generateArrayExpression(node: any): void;
+    generateObjectExpression(node: any): void;
+    generateSwitchExpression(node: any): void;
+    generateSequenceExpression(node: any): void;
+    needsParentheses(node: any): boolean;
+}

package/dist/types/transpiler/pineToJS/lexer.d.ts

@@ -0,0 +1,31 @@
+import { Token } from './tokens';
+export declare class Lexer {
+    private source;
+    private pos;
+    private line;
+    private column;
+    private tokens;
+    private indentStack;
+    private atLineStart;
+    private parenDepth;
+    private bracketDepth;
+    private braceDepth;
+    constructor(source: string);
+    tokenize(): Token[];
+    handleNewline(): void;
+    handleIndentation(): void;
+    readComment(): void;
+    readString(): void;
+    readColorLiteral(): void;
+    readNumber(): void;
+    readIdentifier(): void;
+    readOperatorOrPunctuation(): boolean;
+    peek(offset?: number): string;
+    advance(): string;
+    skipWhitespaceInline(): void;
+    isDigit(ch: any): boolean;
+    isIdentifierStart(ch: any): boolean;
+    isIdentifierChar(ch: any): boolean;
+    getCurrentIndent(): number;
+    addToken(type: any, value: any, indent?: any): void;
+}

package/dist/types/transpiler/pineToJS/parser.d.ts

@@ -0,0 +1,45 @@
+import { Token } from './tokens';
+import { Program, VariableDeclaration, FunctionDeclaration, TypeDefinition, IfStatement, ForStatement, WhileStatement, BlockStatement, CallExpression, ArrayExpression, SwitchExpression } from './ast';
+export declare class Parser {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    peek(offset?: number): Token;
+    advance(): Token;
+    match(type: any, value?: any): boolean;
+    expect(type: any, value?: any): Token;
+    skipNewlines(): void;
+    parse(): Program;
+    parseStatement(): any;
+    isFunctionDeclaration(): boolean;
+    parseTypeDefinition(): TypeDefinition;
+    parseVarDeclaration(): VariableDeclaration;
+    parseTypedVarDeclaration(): VariableDeclaration;
+    parseFunctionDeclaration(): FunctionDeclaration;
+    parseMethodDeclaration(): FunctionDeclaration;
+    parseFunctionBody(): BlockStatement;
+    parseStatementOrSequence(): any;
+    parseIfStatement(): IfStatement;
+    parseForStatement(): ForStatement;
+    parseWhileStatement(): WhileStatement;
+    parseBlock(): BlockStatement;
+    isTupleDestructuring(): boolean;
+    parseTupleDestructuring(): VariableDeclaration;
+    parseExpression(): any;
+    parseTernary(): any;
+    parseLogicalOr(): any;
+    parseLogicalAnd(): any;
+    parseEquality(): any;
+    parseComparison(): any;
+    parseAdditive(): any;
+    parseMultiplicative(): any;
+    parseUnary(): any;
+    parsePostfix(): any;
+    parseCallExpression(callee: any): CallExpression;
+    parsePrimary(): any;
+    parseArrayLiteral(): ArrayExpression;
+    parseIfExpression(): any;
+    needsIIFE(consequentStmts: any, alternateStmts: any): any;
+    parseSwitchExpression(): SwitchExpression;
+    getBlockValue(statements: any): any;
+}

package/dist/types/transpiler/pineToJS/pineToJS.index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Extract Pine Script version from source code
+ * Looks for //@version=X comment on its own line (can be anywhere in the file)
+ * The line must start with // and contain only @version=X (with optional whitespace)
+ * Returns the version number or null if not found
+ */
+export declare function extractPineScriptVersion(sourceCode: string): number | null;
+export declare function pineToJS(sourceCode: string, options?: any): {
+    success: boolean;
+    version: number;
+    error: string;
+    code?: undefined;
+    ast?: undefined;
+    tokens?: undefined;
+    stack?: undefined;
+} | {
+    success: boolean;
+    version: number;
+    code: string;
+    ast: import("./ast").Program;
+    tokens: import("./tokens").Token[];
+    error?: undefined;
+    stack?: undefined;
+} | {
+    success: boolean;
+    version: number;
+    error: any;
+    stack: any;
+    code?: undefined;
+    ast?: undefined;
+    tokens?: undefined;
+};

package/dist/types/transpiler/pineToJS/tokens.d.ts

@@ -0,0 +1,34 @@
+export declare const TokenType: {
+    NUMBER: string;
+    STRING: string;
+    BOOLEAN: string;
+    IDENTIFIER: string;
+    KEYWORD: string;
+    OPERATOR: string;
+    LPAREN: string;
+    RPAREN: string;
+    LBRACKET: string;
+    RBRACKET: string;
+    LBRACE: string;
+    RBRACE: string;
+    COMMA: string;
+    DOT: string;
+    COLON: string;
+    SEMICOLON: string;
+    INDENT: string;
+    DEDENT: string;
+    NEWLINE: string;
+    COMMENT: string;
+    EOF: string;
+};
+export declare const Keywords: Set<string>;
+export declare const MultiCharOperators: string[];
+export declare class Token {
+    type: string;
+    value: any;
+    line: number;
+    column: number;
+    indent: number;
+    constructor(type: string, value: any, line: number, column: number, indent?: number);
+    toString(): string;
+}

package/dist/types/transpiler/settings.d.ts

@@ -1,4 +1,6 @@
 export declare const KNOWN_NAMESPACES: string[];
+export declare const NAMESPACES_LIKE: string[];
+export declare const ASYNC_METHODS: string[];
 export declare const CONTEXT_DATA_VARS: string[];
 export declare const CONTEXT_PINE_VARS: string[];
 export declare const CONTEXT_CORE_VARS: string[];

package/dist/types/transpiler/transformers/WrapperTransformer.d.ts

@@ -1,9 +1,11 @@
 /**
  * Wraps unwrapped code in a context arrow function.
- * If the code is already wrapped in a function, returns it as-is.
- * Otherwise, wraps it in: (context) => { ... }
+ * If the code is already wrapped in a function:
+ *   - If async, returns it as-is
+ *   - If not async, converts it to async
+ * Otherwise, wraps it in: async (context) => { ... }
  *
  * @param code The input code string
- * @returns The wrapped code string
+ * @returns The wrapped code string (always async)
  */
 export declare function wrapInContextFunction(code: string): string;

package/dist/types/transpiler/utils/ASTFactory.d.ts

@@ -17,4 +17,5 @@ export declare const ASTFactory: {
     createMathEqCall(left: any, right: any): any;
     createWrapperFunction(body: any): any;
     createVariableDeclaration(name: string, init: any): any;
+    createAwaitExpression(argument: any): any;
 };

package/dist/types/types/PineTypes.d.ts

@@ -15,6 +15,8 @@ type PlotCharOptions = {
     force_overlay?: boolean;
 };
 type PlotOptions = {
+    series?: number;
+    title?: string;
     color?: string;
     linewidth?: number;
     style?: string;
@@ -30,21 +32,23 @@ type PlotOptions = {
     force_overlay?: boolean;
 };
 type IndicatorOptions = {
-    overlay?: boolean;
-    format?: string;
-    precision?: number;
-    scale?: number;
-    max_bars_back?: number;
-    timeframe?: string;
-    timeframe_gaps?: boolean;
-    explicit_plot_zorder?: number;
-    max_lines_count?: number;
-    max_labels_count?: number;
-    max_boxes_count?: number;
-    calc_bars_count?: number;
-    max_polylines_count?: number;
-    dynamic_requests?: boolean;
-    behind_chart?: boolean;
+    title: string;
+    shorttitle: string;
+    overlay: boolean;
+    format: string;
+    precision: number;
+    scale: string;
+    max_bars_back: number;
+    timeframe: string;
+    timeframe_gaps: boolean;
+    explicit_plot_zorder: boolean;
+    max_lines_count: number;
+    max_labels_count: number;
+    max_boxes_count: number;
+    calc_bars_count: number;
+    max_polylines_count: number;
+    dynamic_requests: boolean;
+    behind_chart: boolean;
 };
 type TSessionInfo = {
     isfirstbar: boolean;

package/package.json

@@ -1,11 +1,28 @@
 {
     "name": "pinets",
-    "version": "0.6.1",
+    "version": "0.7.1",
     "description": "",
-    "main": "dist/pinets.dev.es.js",
+    "main": "dist/pinets.min.cjs",
+    "module": "dist/pinets.min.es.js",
+    "browser": "dist/pinets.min.browser.es.js",
     "types": "dist/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "node": {
+                "import": "./dist/pinets.min.es.js",
+                "require": "./dist/pinets.min.cjs"
+            },
+            "browser": {
+                "import": "./dist/pinets.min.browser.es.js",
+                "default": "./dist/pinets.min.browser.js"
+            },
+            "default": "./dist/pinets.min.es.js"
+        }
+    },
     "files": [
-        "dist"
+        "dist/*.min.*",
+        "dist/types"
     ],
     "type": "module",
     "scripts": {
@@ -20,13 +37,15 @@
         "generate:request-index": "node scripts/generate-request-index.js",
         "generate:map-index": "node scripts/generate-map-index.js",
         "generate:matrix-index": "node scripts/generate-matrix-index.js",
-        "build:dev:all": "npm run generate:ta-index && npm run generate:math-index && npm run generate:array-index && npm run generate:input-index && npm run generate:request-index && npm run generate:map-index && npm run generate:matrix-index && npm run build:dev:browser && npm run build:dev:cjs && npm run build:dev:es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
+        "build:dev:all": "npm run generate:ta-index && npm run generate:math-index && npm run generate:array-index && npm run generate:input-index && npm run generate:request-index && npm run generate:map-index && npm run generate:matrix-index && npm run build:dev:browser && npm run build:dev:cjs && npm run build:dev:es && npm run build:dev:browser-es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
         "build:dev:cjs": "cross-env BUILD=dev FORMAT=cjs rollup -c ./rollup.config.js",
         "build:dev:browser": "cross-env BUILD=dev FORMAT=browser rollup -c ./rollup.config.js",
+        "build:dev:browser-es": "cross-env BUILD=dev FORMAT=browser-es rollup -c ./rollup.config.js",
         "build:dev:es": "cross-env BUILD=dev rollup -c ./rollup.config.js",
-        "build:prod:all": "npm run generate:ta-index && npm run generate:math-index && npm run generate:array-index && npm run generate:input-index && npm run generate:request-index && npm run generate:map-index && npm run generate:matrix-index && npm run build:prod:browser && npm run build:prod:cjs && npm run build:prod:es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
+        "build:prod:all": "npm run generate:ta-index && npm run generate:math-index && npm run generate:array-index && npm run generate:input-index && npm run generate:request-index && npm run generate:map-index && npm run generate:matrix-index && npm run build:prod:browser && npm run build:prod:cjs && npm run build:prod:es && npm run build:prod:browser-es && tsc --emitDeclarationOnly --declaration --outDir dist/types -p tsconfig.dts.json",
         "build:prod:cjs": "cross-env BUILD=prod FORMAT=cjs rollup -c ./rollup.config.js",
         "build:prod:browser": "cross-env BUILD=prod FORMAT=browser rollup -c ./rollup.config.js",
+        "build:prod:browser-es": "cross-env BUILD=prod FORMAT=browser-es rollup -c ./rollup.config.js",
         "build:prod:es": "cross-env BUILD=prod rollup -c ./rollup.config.js",
         "knip": "knip"
     },