langchain 0.0.76 → 0.0.78

package/dist/output_parsers/expression_type_handlers/base.js

@@ -0,0 +1,62 @@
+export class NodeHandler {
+    constructor(parentHandler) {
+        Object.defineProperty(this, "parentHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: parentHandler
+        });
+    }
+}
+export 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";
+    }
+}

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanLiteralHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class BooleanLiteralHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isBooleanLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "boolean_literal",
+            value: node.value,
+        };
+    }
+}
+exports.BooleanLiteralHandler = BooleanLiteralHandler;

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

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

package/dist/output_parsers/expression_type_handlers/boolean_literal_handler.js

@@ -0,0 +1,20 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class BooleanLiteralHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isBooleanLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "boolean_literal",
+            value: node.value,
+        };
+    }
+}

package/dist/output_parsers/expression_type_handlers/call_expression_handler.cjs

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class CallExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isCallExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        function checkCallExpressionArgumentType(arg) {
+            return [
+                base_js_1.ASTParser.isStringLiteral,
+                base_js_1.ASTParser.isNumericLiteral,
+                base_js_1.ASTParser.isBooleanLiteral,
+                base_js_1.ASTParser.isArrayExpression,
+                base_js_1.ASTParser.isObjectExpression,
+                base_js_1.ASTParser.isCallExpression,
+                base_js_1.ASTParser.isIdentifier,
+            ].reduce((acc, func) => acc || func(arg), false);
+        }
+        if (this.parentHandler === undefined) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { callee } = node;
+        let funcCall;
+        if (base_js_1.ASTParser.isIdentifier(callee)) {
+            funcCall = callee.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (base_js_1.ASTParser.isMemberExpression(callee)) {
+            funcCall = (await this.parentHandler.handle(callee));
+        }
+        else {
+            throw new Error("Unknown expression type");
+        }
+        const args = await Promise.all(node.arguments.map((arg) => {
+            if (!checkCallExpressionArgumentType(arg)) {
+                throw new Error("Unknown argument type");
+            }
+            if (!this.parentHandler) {
+                throw new Error("CallExpressionHandler must have a parent handler");
+            }
+            return this.parentHandler.handle(arg);
+        }));
+        return { type: "call_expression", funcCall, args };
+    }
+}
+exports.CallExpressionHandler = CallExpressionHandler;

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

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

package/dist/output_parsers/expression_type_handlers/call_expression_handler.js

@@ -0,0 +1,48 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class CallExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isCallExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        function checkCallExpressionArgumentType(arg) {
+            return [
+                ASTParser.isStringLiteral,
+                ASTParser.isNumericLiteral,
+                ASTParser.isBooleanLiteral,
+                ASTParser.isArrayExpression,
+                ASTParser.isObjectExpression,
+                ASTParser.isCallExpression,
+                ASTParser.isIdentifier,
+            ].reduce((acc, func) => acc || func(arg), false);
+        }
+        if (this.parentHandler === undefined) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { callee } = node;
+        let funcCall;
+        if (ASTParser.isIdentifier(callee)) {
+            funcCall = callee.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (ASTParser.isMemberExpression(callee)) {
+            funcCall = (await this.parentHandler.handle(callee));
+        }
+        else {
+            throw new Error("Unknown expression type");
+        }
+        const args = await Promise.all(node.arguments.map((arg) => {
+            if (!checkCallExpressionArgumentType(arg)) {
+                throw new Error("Unknown argument type");
+            }
+            if (!this.parentHandler) {
+                throw new Error("CallExpressionHandler must have a parent handler");
+            }
+            return this.parentHandler.handle(arg);
+        }));
+        return { type: "call_expression", funcCall, args };
+    }
+}

package/dist/output_parsers/expression_type_handlers/factory.cjs

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MasterHandler = void 0;
+const base_js_1 = require("./base.cjs");
+const array_literal_expression_handler_js_1 = require("./array_literal_expression_handler.cjs");
+const boolean_literal_handler_js_1 = require("./boolean_literal_handler.cjs");
+const call_expression_handler_js_1 = require("./call_expression_handler.cjs");
+const numeric_literal_handler_js_1 = require("./numeric_literal_handler.cjs");
+const object_literal_expression_handler_js_1 = require("./object_literal_expression_handler.cjs");
+const property_assignment_handler_js_1 = require("./property_assignment_handler.cjs");
+const string_literal_handler_js_1 = require("./string_literal_handler.cjs");
+const identifier_handler_js_1 = require("./identifier_handler.cjs");
+const member_expression_handler_js_1 = require("./member_expression_handler.cjs");
+const handlers = [
+    array_literal_expression_handler_js_1.ArrayLiteralExpressionHandler,
+    boolean_literal_handler_js_1.BooleanLiteralHandler,
+    call_expression_handler_js_1.CallExpressionHandler,
+    numeric_literal_handler_js_1.NumericLiteralHandler,
+    object_literal_expression_handler_js_1.ObjectLiteralExpressionHandler,
+    member_expression_handler_js_1.MemberExpressionHandler,
+    property_assignment_handler_js_1.PropertyAssignmentHandler,
+    string_literal_handler_js_1.StringLiteralHandler,
+    identifier_handler_js_1.IdentifierHandler,
+];
+class MasterHandler extends base_js_1.NodeHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nodeHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async accepts(node) {
+        throw new Error(`Master handler does not accept any nodes: ${node}`);
+    }
+    async handle(node) {
+        for (const handler of this.nodeHandlers) {
+            const accepts = await handler.accepts(node);
+            if (accepts) {
+                return handler.handle(node);
+            }
+        }
+        throw new Error(`No handler found for node: ${node}`);
+    }
+    static createMasterHandler() {
+        const masterHandler = new MasterHandler();
+        handlers.forEach((Handler) => {
+            const handlerInstance = new Handler(masterHandler);
+            masterHandler.nodeHandlers.push(handlerInstance);
+        });
+        return masterHandler;
+    }
+}
+exports.MasterHandler = MasterHandler;

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

@@ -0,0 +1,9 @@
+import type { ESTree } from "meriyah";
+import { NodeHandler } from "./base.js";
+import { ParsedType } from "./types.js";
+export declare class MasterHandler extends NodeHandler {
+    nodeHandlers: NodeHandler[];
+    accepts(node: ESTree.Node): Promise<ESTree.Node | boolean>;
+    handle(node: ESTree.CallExpression): Promise<ParsedType>;
+    static createMasterHandler(): MasterHandler;
+}

package/dist/output_parsers/expression_type_handlers/factory.js

@@ -0,0 +1,52 @@
+import { NodeHandler } from "./base.js";
+import { ArrayLiteralExpressionHandler } from "./array_literal_expression_handler.js";
+import { BooleanLiteralHandler } from "./boolean_literal_handler.js";
+import { CallExpressionHandler } from "./call_expression_handler.js";
+import { NumericLiteralHandler } from "./numeric_literal_handler.js";
+import { ObjectLiteralExpressionHandler } from "./object_literal_expression_handler.js";
+import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
+import { StringLiteralHandler } from "./string_literal_handler.js";
+import { IdentifierHandler } from "./identifier_handler.js";
+import { MemberExpressionHandler } from "./member_expression_handler.js";
+const handlers = [
+    ArrayLiteralExpressionHandler,
+    BooleanLiteralHandler,
+    CallExpressionHandler,
+    NumericLiteralHandler,
+    ObjectLiteralExpressionHandler,
+    MemberExpressionHandler,
+    PropertyAssignmentHandler,
+    StringLiteralHandler,
+    IdentifierHandler,
+];
+export class MasterHandler extends NodeHandler {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "nodeHandlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async accepts(node) {
+        throw new Error(`Master handler does not accept any nodes: ${node}`);
+    }
+    async handle(node) {
+        for (const handler of this.nodeHandlers) {
+            const accepts = await handler.accepts(node);
+            if (accepts) {
+                return handler.handle(node);
+            }
+        }
+        throw new Error(`No handler found for node: ${node}`);
+    }
+    static createMasterHandler() {
+        const masterHandler = new MasterHandler();
+        handlers.forEach((Handler) => {
+            const handlerInstance = new Handler(masterHandler);
+            masterHandler.nodeHandlers.push(handlerInstance);
+        });
+        return masterHandler;
+    }
+}

package/dist/output_parsers/expression_type_handlers/identifier_handler.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentifierHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class IdentifierHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isIdentifier(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = node.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "identifier", value: text };
+    }
+}
+exports.IdentifierHandler = IdentifierHandler;

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

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

package/dist/output_parsers/expression_type_handlers/identifier_handler.js

@@ -0,0 +1,18 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class IdentifierHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isIdentifier(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const text = node.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        return { type: "identifier", value: text };
+    }
+}

package/dist/output_parsers/expression_type_handlers/member_expression_handler.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemberExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class MemberExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isMemberExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { object, property } = node;
+        let prop;
+        if (base_js_1.ASTParser.isIdentifier(property)) {
+            prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (base_js_1.ASTParser.isStringLiteral(property)) {
+            prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        let identifier;
+        if (base_js_1.ASTParser.isIdentifier(object)) {
+            identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (base_js_1.ASTParser.isLiteral(object)) {
+            identifier = `${object.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid object type");
+        }
+        if (object.type !== "Identifier" && object.type !== "Literal") {
+            throw new Error("ArrayExpression is not supported");
+        }
+        return { type: "member_expression", identifier, property: prop };
+    }
+}
+exports.MemberExpressionHandler = MemberExpressionHandler;

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

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

package/dist/output_parsers/expression_type_handlers/member_expression_handler.js

@@ -0,0 +1,41 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class MemberExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isMemberExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const { object, property } = node;
+        let prop;
+        if (ASTParser.isIdentifier(property)) {
+            prop = property.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (ASTParser.isStringLiteral(property)) {
+            prop = `${property.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        let identifier;
+        if (ASTParser.isIdentifier(object)) {
+            identifier = object.name.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else if (ASTParser.isLiteral(object)) {
+            identifier = `${object.value}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        }
+        else {
+            throw new Error("Invalid object type");
+        }
+        if (object.type !== "Identifier" && object.type !== "Literal") {
+            throw new Error("ArrayExpression is not supported");
+        }
+        return { type: "member_expression", identifier, property: prop };
+    }
+}

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericLiteralHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class NumericLiteralHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isNumericLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "numeric_literal",
+            value: Number(node.value),
+        };
+    }
+}
+exports.NumericLiteralHandler = NumericLiteralHandler;

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

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

package/dist/output_parsers/expression_type_handlers/numeric_literal_handler.js

@@ -0,0 +1,20 @@
+import { NodeHandler, ASTParser } from "./base.js";
+export class NumericLiteralHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isNumericLiteral(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        return {
+            type: "numeric_literal",
+            value: Number(node.value),
+        };
+    }
+}

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectLiteralExpressionHandler = void 0;
+const base_js_1 = require("./base.cjs");
+const property_assignment_handler_js_1 = require("./property_assignment_handler.cjs");
+class ObjectLiteralExpressionHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isObjectExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const values = [];
+        const { properties } = node;
+        for (const property of properties) {
+            if (base_js_1.ASTParser.isProperty(property)) {
+                values.push(await new property_assignment_handler_js_1.PropertyAssignmentHandler(this.parentHandler).handle(property));
+            }
+        }
+        return { type: "object_literal", values };
+    }
+}
+exports.ObjectLiteralExpressionHandler = ObjectLiteralExpressionHandler;

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

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

package/dist/output_parsers/expression_type_handlers/object_literal_expression_handler.js

@@ -0,0 +1,25 @@
+import { NodeHandler, ASTParser } from "./base.js";
+import { PropertyAssignmentHandler } from "./property_assignment_handler.js";
+export class ObjectLiteralExpressionHandler extends NodeHandler {
+    async accepts(node) {
+        if (ASTParser.isObjectExpression(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        const values = [];
+        const { properties } = node;
+        for (const property of properties) {
+            if (ASTParser.isProperty(property)) {
+                values.push(await new PropertyAssignmentHandler(this.parentHandler).handle(property));
+            }
+        }
+        return { type: "object_literal", values };
+    }
+}

package/dist/output_parsers/expression_type_handlers/property_assignment_handler.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyAssignmentHandler = void 0;
+const base_js_1 = require("./base.cjs");
+class PropertyAssignmentHandler extends base_js_1.NodeHandler {
+    async accepts(node) {
+        if (base_js_1.ASTParser.isProperty(node)) {
+            return node;
+        }
+        else {
+            return false;
+        }
+    }
+    async handle(node) {
+        if (!this.parentHandler) {
+            throw new Error("ArrayLiteralExpressionHandler must have a parent handler");
+        }
+        let name;
+        if (base_js_1.ASTParser.isIdentifier(node.key)) {
+            name = node.key.name;
+        }
+        else if (base_js_1.ASTParser.isStringLiteral(node.key)) {
+            name = node.key.value;
+        }
+        else {
+            throw new Error("Invalid property key type");
+        }
+        if (!name) {
+            throw new Error("Invalid property key");
+        }
+        const identifier = `${name}`.replace(/^["'](.+(?=["']$))["']$/, "$1");
+        const value = await this.parentHandler.handle(node.value);
+        return { type: "property_assignment", identifier, value };
+    }
+}
+exports.PropertyAssignmentHandler = PropertyAssignmentHandler;

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

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