langchain 0.0.76 → 0.0.78

package/dist/llms/sagemaker_endpoint.cjs

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SageMakerEndpoint = exports.BaseSageMakerContentHandler = void 0;
+const client_sagemaker_runtime_1 = require("@aws-sdk/client-sagemaker-runtime");
+const base_js_1 = require("./base.cjs");
+/**
+ * A handler class to transform input from LLM to a format that SageMaker
+ * endpoint expects. Similarily, the class also handles transforming output from
+ * the SageMaker endpoint to a format that LLM class expects.
+ *
+ * Example:
+ * ```
+ * class ContentHandler implements ContentHandlerBase<string, string> {
+ *   contentType = "application/json"
+ *   accepts = "application/json"
+ *
+ *   transformInput(prompt: string, modelKwargs: Record<string, unknown>) {
+ *     const inputString = JSON.stringify({
+ *       prompt,
+ *      ...modelKwargs
+ *     })
+ *     return Buffer.from(inputString)
+ *   }
+ *
+ *   transformOutput(output: Uint8Array) {
+ *     const responseJson = JSON.parse(Buffer.from(output).toString("utf-8"))
+ *     return responseJson[0].generated_text
+ *   }
+ *
+ * }
+ * ```
+ */
+class BaseSageMakerContentHandler {
+    constructor() {
+        /** The MIME type of the input data passed to endpoint */
+        Object.defineProperty(this, "contentType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text/plain"
+        });
+        /** The MIME type of the response data returned from endpoint */
+        Object.defineProperty(this, "accepts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text/plain"
+        });
+    }
+}
+exports.BaseSageMakerContentHandler = BaseSageMakerContentHandler;
+class SageMakerEndpoint extends base_js_1.LLM {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "endpointName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpointKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const regionName = fields.clientOptions.region;
+        if (!regionName) {
+            throw new Error(`Please pass a "clientOptions" object with a "region" field to the constructor`);
+        }
+        const endpointName = fields?.endpointName;
+        if (!endpointName) {
+            throw new Error(`Please pass an "endpointName" field to the constructor`);
+        }
+        const contentHandler = fields?.contentHandler;
+        if (!contentHandler) {
+            throw new Error(`Please pass a "contentHandler" field to the constructor`);
+        }
+        this.endpointName = fields.endpointName;
+        this.contentHandler = fields.contentHandler;
+        this.endpointKwargs = fields.endpointKwargs;
+        this.modelKwargs = fields.modelKwargs;
+        this.client = new client_sagemaker_runtime_1.SageMakerRuntimeClient(fields.clientOptions);
+    }
+    _llmType() {
+        return "sagemaker_endpoint";
+    }
+    /** @ignore */
+    async _call(prompt, options) {
+        const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
+        const { contentType, accepts } = this.contentHandler;
+        const response = await this.caller.call(() => this.client.send(new client_sagemaker_runtime_1.InvokeEndpointCommand({
+            EndpointName: this.endpointName,
+            Body: body,
+            ContentType: contentType,
+            Accept: accepts,
+            ...this.endpointKwargs,
+        }), { abortSignal: options.signal }));
+        if (response.Body === undefined) {
+            throw new Error("Inference result missing Body");
+        }
+        return this.contentHandler.transformOutput(response.Body);
+    }
+}
+exports.SageMakerEndpoint = SageMakerEndpoint;

package/dist/llms/sagemaker_endpoint.d.ts

@@ -0,0 +1,82 @@
+import { SageMakerRuntimeClient, SageMakerRuntimeClientConfig } from "@aws-sdk/client-sagemaker-runtime";
+import { LLM, BaseLLMParams } from "./base.js";
+/**
+ * A handler class to transform input from LLM to a format that SageMaker
+ * endpoint expects. Similarily, the class also handles transforming output from
+ * the SageMaker endpoint to a format that LLM class expects.
+ *
+ * Example:
+ * ```
+ * class ContentHandler implements ContentHandlerBase<string, string> {
+ *   contentType = "application/json"
+ *   accepts = "application/json"
+ *
+ *   transformInput(prompt: string, modelKwargs: Record<string, unknown>) {
+ *     const inputString = JSON.stringify({
+ *       prompt,
+ *      ...modelKwargs
+ *     })
+ *     return Buffer.from(inputString)
+ *   }
+ *
+ *   transformOutput(output: Uint8Array) {
+ *     const responseJson = JSON.parse(Buffer.from(output).toString("utf-8"))
+ *     return responseJson[0].generated_text
+ *   }
+ *
+ * }
+ * ```
+ */
+export declare abstract class BaseSageMakerContentHandler<InputType, OutputType> {
+    /** The MIME type of the input data passed to endpoint */
+    contentType: string;
+    /** The MIME type of the response data returned from endpoint */
+    accepts: string;
+    /**
+     * Transforms the input to a format that model can accept as the request Body.
+     * Should return bytes or seekable file like object in the format specified in
+     * the contentType request header.
+     */
+    abstract transformInput(prompt: InputType, modelKwargs: Record<string, unknown>): Promise<Uint8Array>;
+    /**
+     * Transforms the output from the model to string that the LLM class expects.
+     */
+    abstract transformOutput(output: Uint8Array): Promise<OutputType>;
+}
+/** Content handler for LLM class. */
+export type SageMakerLLMContentHandler = BaseSageMakerContentHandler<string, string>;
+export interface SageMakerEndpointInput extends BaseLLMParams {
+    /**
+     * The name of the endpoint from the deployed SageMaker model. Must be unique
+     * within an AWS Region.
+     */
+    endpointName: string;
+    /**
+     * Options passed to the SageMaker client.
+     */
+    clientOptions: SageMakerRuntimeClientConfig;
+    /**
+     * The content handler class that provides an input and output transform
+     * functions to handle formats between LLM and the endpoint.
+     */
+    contentHandler: SageMakerLLMContentHandler;
+    /**
+     * Key word arguments to pass to the model.
+     */
+    modelKwargs?: Record<string, unknown>;
+    /**
+     * Optional attributes passed to the InvokeEndpointCommand
+     */
+    endpointKwargs?: Record<string, unknown>;
+}
+export declare class SageMakerEndpoint extends LLM {
+    endpointName: string;
+    contentHandler: SageMakerLLMContentHandler;
+    modelKwargs?: Record<string, unknown>;
+    endpointKwargs?: Record<string, unknown>;
+    client: SageMakerRuntimeClient;
+    constructor(fields: SageMakerEndpointInput);
+    _llmType(): string;
+    /** @ignore */
+    _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+}

package/dist/llms/sagemaker_endpoint.js

@@ -0,0 +1,118 @@
+import { SageMakerRuntimeClient, InvokeEndpointCommand, } from "@aws-sdk/client-sagemaker-runtime";
+import { LLM } from "./base.js";
+/**
+ * A handler class to transform input from LLM to a format that SageMaker
+ * endpoint expects. Similarily, the class also handles transforming output from
+ * the SageMaker endpoint to a format that LLM class expects.
+ *
+ * Example:
+ * ```
+ * class ContentHandler implements ContentHandlerBase<string, string> {
+ *   contentType = "application/json"
+ *   accepts = "application/json"
+ *
+ *   transformInput(prompt: string, modelKwargs: Record<string, unknown>) {
+ *     const inputString = JSON.stringify({
+ *       prompt,
+ *      ...modelKwargs
+ *     })
+ *     return Buffer.from(inputString)
+ *   }
+ *
+ *   transformOutput(output: Uint8Array) {
+ *     const responseJson = JSON.parse(Buffer.from(output).toString("utf-8"))
+ *     return responseJson[0].generated_text
+ *   }
+ *
+ * }
+ * ```
+ */
+export class BaseSageMakerContentHandler {
+    constructor() {
+        /** The MIME type of the input data passed to endpoint */
+        Object.defineProperty(this, "contentType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text/plain"
+        });
+        /** The MIME type of the response data returned from endpoint */
+        Object.defineProperty(this, "accepts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text/plain"
+        });
+    }
+}
+export class SageMakerEndpoint extends LLM {
+    constructor(fields) {
+        super(fields ?? {});
+        Object.defineProperty(this, "endpointName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "modelKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "endpointKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        const regionName = fields.clientOptions.region;
+        if (!regionName) {
+            throw new Error(`Please pass a "clientOptions" object with a "region" field to the constructor`);
+        }
+        const endpointName = fields?.endpointName;
+        if (!endpointName) {
+            throw new Error(`Please pass an "endpointName" field to the constructor`);
+        }
+        const contentHandler = fields?.contentHandler;
+        if (!contentHandler) {
+            throw new Error(`Please pass a "contentHandler" field to the constructor`);
+        }
+        this.endpointName = fields.endpointName;
+        this.contentHandler = fields.contentHandler;
+        this.endpointKwargs = fields.endpointKwargs;
+        this.modelKwargs = fields.modelKwargs;
+        this.client = new SageMakerRuntimeClient(fields.clientOptions);
+    }
+    _llmType() {
+        return "sagemaker_endpoint";
+    }
+    /** @ignore */
+    async _call(prompt, options) {
+        const body = await this.contentHandler.transformInput(prompt, this.modelKwargs ?? {});
+        const { contentType, accepts } = this.contentHandler;
+        const response = await this.caller.call(() => this.client.send(new InvokeEndpointCommand({
+            EndpointName: this.endpointName,
+            Body: body,
+            ContentType: contentType,
+            Accept: accepts,
+            ...this.endpointKwargs,
+        }), { abortSignal: options.signal }));
+        if (response.Body === undefined) {
+            throw new Error("Inference result missing Body");
+        }
+        return this.contentHandler.transformOutput(response.Body);
+    }
+}

package/dist/memory/buffer_memory.cjs

@@ -45,7 +45,7 @@ class BufferMemory extends chat_memory_js_1.BaseChatMemory {
             return result;
         }
         const result = {
-            [this.memoryKey]: (0, base_js_1.getBufferString)(messages),
+            [this.memoryKey]: (0, base_js_1.getBufferString)(messages, this.humanPrefix, this.aiPrefix),
         };
         return result;
     }

package/dist/memory/buffer_memory.js

@@ -42,7 +42,7 @@ export class BufferMemory extends BaseChatMemory {
             return result;
         }
         const result = {
-            [this.memoryKey]: getBufferString(messages),
+            [this.memoryKey]: getBufferString(messages, this.humanPrefix, this.aiPrefix),
         };
         return result;
     }

package/dist/memory/buffer_window_memory.cjs

@@ -52,7 +52,7 @@ class BufferWindowMemory extends chat_memory_js_1.BaseChatMemory {
             return result;
         }
         const result = {
-            [this.memoryKey]: (0, base_js_1.getBufferString)(messages.slice(-this.k * 2)),
+            [this.memoryKey]: (0, base_js_1.getBufferString)(messages.slice(-this.k * 2), this.humanPrefix, this.aiPrefix),
         };
         return result;
     }

package/dist/memory/buffer_window_memory.js

@@ -49,7 +49,7 @@ export class BufferWindowMemory extends BaseChatMemory {
             return result;
         }
         const result = {
-            [this.memoryKey]: getBufferString(messages.slice(-this.k * 2)),
+            [this.memoryKey]: getBufferString(messages.slice(-this.k * 2), this.humanPrefix, this.aiPrefix),
         };
         return result;
     }

package/dist/output_parsers/expression.cjs

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MasterHandler = exports.ExpressionParser = void 0;
+const factory_js_1 = require("./expression_type_handlers/factory.cjs");
+const output_parser_js_1 = require("../schema/output_parser.cjs");
+const base_js_1 = require("./expression_type_handlers/base.cjs");
+/**
+ * okay so we need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+class ExpressionParser extends output_parser_js_1.BaseOutputParser {
+    async parse(text) {
+        const parse = await base_js_1.ASTParser.importASTParser();
+        try {
+            const program = parse(text);
+            if (program.body.length > 1) {
+                throw new Error(`Expected 1 statement, got ${program.body.length}`);
+            }
+            const [node] = program.body;
+            if (!base_js_1.ASTParser.isExpressionStatement(node)) {
+                throw new Error(`Expected ExpressionStatement, got ${node.type}`);
+            }
+            const { expression: expressionStatement } = node;
+            if (!base_js_1.ASTParser.isCallExpression(expressionStatement)) {
+                throw new Error("Expected CallExpression");
+            }
+            const masterHandler = factory_js_1.MasterHandler.createMasterHandler();
+            return await masterHandler.handle(expressionStatement);
+        }
+        catch (err) {
+            throw new Error(`Error parsing ${err}: ${text}`);
+        }
+    }
+    getFormatInstructions() {
+        return "";
+    }
+}
+exports.ExpressionParser = ExpressionParser;
+__exportStar(require("./expression_type_handlers/types.cjs"), exports);
+var factory_js_2 = require("./expression_type_handlers/factory.cjs");
+Object.defineProperty(exports, "MasterHandler", { enumerable: true, get: function () { return factory_js_2.MasterHandler; } });

package/dist/output_parsers/expression.d.ts

@@ -0,0 +1,25 @@
+import { ParsedType } from "./expression_type_handlers/types.js";
+import { BaseOutputParser } from "../schema/output_parser.js";
+/**
+ * okay so we need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+export declare class ExpressionParser extends BaseOutputParser<ParsedType> {
+    parse(text: string): Promise<ParsedType>;
+    getFormatInstructions(): string;
+}
+export * from "./expression_type_handlers/types.js";
+export { MasterHandler } from "./expression_type_handlers/factory.js";

package/dist/output_parsers/expression.js

@@ -0,0 +1,49 @@
+import { MasterHandler } from "./expression_type_handlers/factory.js";
+import { BaseOutputParser } from "../schema/output_parser.js";
+import { ASTParser } from "./expression_type_handlers/base.js";
+/**
+ * okay so we need to be able to handle the following cases:
+ * ExpressionStatement
+ *  CallExpression
+ *      Identifier | MemberExpression
+ *      ExpressionLiterals: [
+ *          CallExpression
+ *          StringLiteral
+ *          NumericLiteral
+ *          ArrayLiteralExpression
+ *              ExpressionLiterals
+ *          ObjectLiteralExpression
+ *              PropertyAssignment
+ *                  Identifier
+ *                  ExpressionLiterals
+ *      ]
+ */
+export class ExpressionParser extends BaseOutputParser {
+    async parse(text) {
+        const parse = await ASTParser.importASTParser();
+        try {
+            const program = parse(text);
+            if (program.body.length > 1) {
+                throw new Error(`Expected 1 statement, got ${program.body.length}`);
+            }
+            const [node] = program.body;
+            if (!ASTParser.isExpressionStatement(node)) {
+                throw new Error(`Expected ExpressionStatement, got ${node.type}`);
+            }
+            const { expression: expressionStatement } = node;
+            if (!ASTParser.isCallExpression(expressionStatement)) {
+                throw new Error("Expected CallExpression");
+            }
+            const masterHandler = MasterHandler.createMasterHandler();
+            return await masterHandler.handle(expressionStatement);
+        }
+        catch (err) {
+            throw new Error(`Error parsing ${err}: ${text}`);
+        }
+    }
+    getFormatInstructions() {
+        return "";
+    }
+}
+export * from "./expression_type_handlers/types.js";
+export { MasterHandler } from "./expression_type_handlers/factory.js";

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayLiteralExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class ArrayLiteralExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isArrayExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "array_literal",
+            values: await Promise.all(node.elements.map((innerNode) => 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.parentHandler.handle(innerNode))),
+        };
+    }
+}
+exports.ArrayLiteralExpressionHandler = ArrayLiteralExpressionHandler;

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.d.ts

@@ -0,0 +1,7 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { ArrayLiteralType } from "./types.js";
+export declare class ArrayLiteralExpressionHandler extends NodeHandler {
+    accepts(node: ESTree.Node): Promise<ESTree.ArrayExpression | boolean>;
+    handle(node: ESTree.ArrayExpression): Promise<ArrayLiteralType>;
+}

package/dist/output_parsers/expression_type_handlers/array_literal_expression_handler.js

@@ -0,0 +1,22 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class ArrayLiteralExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isArrayExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "array_literal",
+            values: await Promise.all(node.elements.map((innerNode) => 
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.parentHandler.handle(innerNode))),
+        };
+    }
+}

package/dist/output_parsers/expression_type_handlers/base.cjs

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASTParser = exports.NodeHandler = void 0;
+class NodeHandler {
+    constructor(parentHandler) {
+        Object.defineProperty(this, "parentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parentHandler
+        });
+    }
+}
+exports.NodeHandler = NodeHandler;
+class ASTParser {
+    static async importASTParser() {
+        try {
+            if (!ASTParser.astParseInstance) {
+                const meriyah = await import("meriyah");
+                ASTParser.astParseInstance =
+                    meriyah.parseScript;
+            }
+            return ASTParser.astParseInstance;
+        }
+        catch (e) {
+            console.log(e);
+            throw new Error("Failed to import meriyah. Please install meriyah (i.e. npm install meriyah).");
+        }
+    }
+    static isProgram(node) {
+        return node.type === "Program";
+    }
+    static isExpressionStatement(node) {
+        return node.type === "ExpressionStatement";
+    }
+    static isCallExpression(node) {
+        return node.type === "CallExpression";
+    }
+    static isLiteral(node) {
+        return node.type === "Literal";
+    }
+    static isStringLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "string";
+    }
+    static isNumericLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "number";
+    }
+    static isBooleanLiteral(node) {
+        return node.type === "Literal" && typeof node.value === "boolean";
+    }
+    static isIdentifier(node) {
+        return node.type === "Identifier";
+    }
+    static isObjectExpression(node) {
+        return node.type === "ObjectExpression";
+    }
+    static isArrayExpression(node) {
+        return node.type === "ArrayExpression";
+    }
+    static isProperty(node) {
+        return node.type === "Property";
+    }
+    static isMemberExpression(node) {
+        return node.type === "MemberExpression";
+    }
+}
+exports.ASTParser = ASTParser;

package/dist/output_parsers/expression_type_handlers/base.d.ts

@@ -0,0 +1,23 @@
+import type meriyahT from "meriyah";
+export declare abstract class NodeHandler {
+    protected parentHandler?: NodeHandler | undefined;
+    constructor(parentHandler?: NodeHandler | undefined);
+    abstract accepts(node: meriyahT.ESTree.Node): Promise<meriyahT.ESTree.Node | boolean>;
+    abstract handle(node: meriyahT.ESTree.Node): Promise<any>;
+}
+export declare class ASTParser {
+    static astParseInstance: typeof meriyahT.parseScript;
+    static importASTParser(): Promise<typeof meriyahT.parseScript>;
+    static isProgram(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Program;
+    static isExpressionStatement(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.ExpressionStatement;
+    static isCallExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.CallExpression;
+    static isLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isStringLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isNumericLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isBooleanLiteral(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Literal;
+    static isIdentifier(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Identifier;
+    static isObjectExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.ObjectExpression;
+    static isArrayExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.ArrayExpression;
+    static isProperty(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.Property;
+    static isMemberExpression(node: meriyahT.ESTree.Node): node is meriyahT.ESTree.MemberExpression;
+}