gremlin 3.8.1 → 4.0.0-beta.3

package/build/cjs/language/translator/TranslateVisitor.cjs

@@ -0,0 +1,398 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const GremlinLexer_js_1 = require("../grammar/GremlinLexer.cjs");
+/**
+ * Base visitor for translating Gremlin queries. Mirrors the Java TranslateVisitor.
+ * Makes no changes to input except:
+ * - Normalizes whitespace
+ * - Normalizes numeric suffixes to lower case
+ * - Makes anonymous traversals explicit with double underscore
+ * - Makes enums explicit with their proper name
+ */
+class TranslateVisitor {
+    graphTraversalSourceName;
+    sb = [];
+    parameters = new Set();
+    constructor(graphTraversalSourceName = 'g') {
+        this.graphTraversalSourceName = graphTraversalSourceName;
+    }
+    getTranslated() {
+        return this.sb.join('');
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    processGremlinSymbol(step) {
+        return step;
+    }
+    appendArgumentSeparator() {
+        this.sb.push(', ');
+    }
+    appendStepSeparator() {
+        this.sb.push('.');
+    }
+    appendStepOpen() {
+        this.sb.push('(');
+    }
+    appendStepClose() {
+        this.sb.push(')');
+    }
+    appendAnonymousSpawn() {
+        this.sb.push('__.');
+    }
+    visit(tree) {
+        if (tree == null)
+            return;
+        // antlr-ng does not generate accept() overrides per context class —
+        // ParserRuleContext.accept() always calls visitChildren, never dispatching to
+        // the specific visitXxx method. We perform the dispatch ourselves here by
+        // mapping the context class name (e.g. StringLiteralContext) to the
+        // corresponding visitor method (e.g. visitStringLiteral).
+        const className = tree?.constructor?.name ?? '';
+        if (className.endsWith('Context')) {
+            const methodName = 'visit' + className.slice(0, -'Context'.length);
+            const method = this[methodName];
+            if (typeof method === 'function') {
+                method.call(this, tree);
+                return;
+            }
+        }
+        // No specific visitor method found — fall through to accept() which calls
+        // visitChildren for rule contexts, visitTerminal for terminals.
+        tree.accept(this);
+    }
+    visitChildren(node) {
+        const n = node.getChildCount();
+        for (let i = 0; i < n; i++) {
+            this.visit(node.getChild(i));
+        }
+    }
+    getCardinalityFunctionClass() {
+        return 'Cardinality';
+    }
+    static removeFirstAndLastCharacters(text) {
+        return text != null && text.length > 0 ? text.substring(1, text.length - 1) : '';
+    }
+    handleStringLiteralText(text) {
+        this.sb.push('"');
+        this.sb.push(text);
+        this.sb.push('"');
+    }
+    appendExplicitNaming(txt, prefix) {
+        if (!txt.startsWith(prefix + '.')) {
+            this.sb.push(this.processGremlinSymbol(prefix));
+            this.sb.push('.');
+            this.sb.push(this.processGremlinSymbol(txt));
+        }
+        else {
+            const parts = txt.split('.');
+            this.sb.push(this.processGremlinSymbol(parts[0]));
+            this.sb.push('.');
+            this.sb.push(this.processGremlinSymbol(parts[1]));
+        }
+    }
+    visitTerminal(node) {
+        // skip EOF node
+        if (node == null || node.getSymbol().type === -1)
+            return;
+        // TRAVERSAL_ROOT is the traversal source token (e.g. 'g') — always output as-is,
+        // never subject to processGremlinSymbol (which may capitalize it in some dialects).
+        if (node.getSymbol().type === GremlinLexer_js_1.GremlinLexer.TRAVERSAL_ROOT) {
+            this.sb.push(this.graphTraversalSourceName);
+            return;
+        }
+        const terminal = node.getSymbol().text ?? '';
+        switch (terminal) {
+            case '(':
+                this.appendStepOpen();
+                break;
+            case ')':
+                this.appendStepClose();
+                break;
+            case ',':
+                this.appendArgumentSeparator();
+                break;
+            case '.':
+                this.appendStepSeparator();
+                break;
+            case 'new':
+                this.sb.push('new');
+                if (!(node.parent?.constructor?.name === 'MapKeyContext')) {
+                    this.sb.push(' ');
+                }
+                break;
+            default:
+                this.sb.push(this.processGremlinSymbol(terminal));
+        }
+    }
+    visitErrorNode(_node) {
+        // no-op
+    }
+    visitTraversalSource(ctx) {
+        this.sb.push(this.graphTraversalSourceName);
+        // child counts more than 1 means there is a step separator and a traversal source method
+        if (ctx.getChildCount() > 1) {
+            if (ctx.getChild(0).getChildCount() > 1) {
+                this.appendStepSeparator();
+                this.visitTraversalSourceSelfMethod(ctx.getChild(0).getChild(2));
+            }
+            this.appendStepSeparator();
+            this.visitTraversalSourceSelfMethod(ctx.getChild(2));
+        }
+    }
+    visitTraversalSourceSelfMethod(ctx) {
+        this.visitChildren(ctx);
+    }
+    visitNestedTraversal(ctx) {
+        if (ctx.ANON_TRAVERSAL_ROOT() == null) {
+            this.appendAnonymousSpawn();
+        }
+        this.visitChildren(ctx);
+    }
+    visitTraversalScope(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Scope');
+    }
+    visitTraversalT(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'T');
+    }
+    visitTraversalTShort(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'T');
+    }
+    visitTraversalTLong(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'T');
+    }
+    visitTraversalMerge(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Merge');
+    }
+    visitTraversalOrder(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Order');
+    }
+    visitTraversalBarrier(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Barrier');
+    }
+    visitTraversalDirection(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Direction');
+    }
+    visitTraversalDirectionShort(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Direction');
+    }
+    visitTraversalDirectionLong(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Direction');
+    }
+    visitTraversalCardinality(ctx) {
+        if (ctx.LPAREN() != null && ctx.RPAREN() != null) {
+            const idx = ctx.K_CARDINALITY() != null ? 2 : 0;
+            const txt = ctx.getChild(idx).getText();
+            this.appendExplicitNaming(txt, this.getCardinalityFunctionClass());
+            this.appendStepOpen();
+            this.visit(ctx.genericLiteral());
+            this.appendStepClose();
+        }
+        else {
+            this.appendExplicitNaming(ctx.getText(), 'Cardinality');
+        }
+    }
+    visitTraversalColumn(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Column');
+    }
+    visitTraversalPop(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Pop');
+    }
+    visitTraversalOperator(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Operator');
+    }
+    visitTraversalPick(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'Pick');
+    }
+    visitTraversalDT(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'DT');
+    }
+    visitTraversalGType(ctx) {
+        this.appendExplicitNaming(ctx.getText(), 'GType');
+    }
+    visitTraversalPredicate(ctx) {
+        switch (ctx.getChildCount()) {
+            case 1:
+                this.visit(ctx.getChild(0));
+                break;
+            case 5:
+                // handle negate of P
+                this.visit(ctx.getChild(0));
+                this.sb.push('.');
+                this.sb.push(this.processGremlinSymbol('negate'));
+                this.sb.push('()');
+                break;
+            case 6:
+                // handle and/or predicates
+                this.visit(ctx.getChild(0));
+                this.sb.push('.');
+                this.sb.push(this.processGremlinSymbol(ctx.getChild(2).getText()));
+                this.sb.push('(');
+                this.visit(ctx.getChild(4));
+                this.sb.push(')');
+                break;
+        }
+    }
+    visitP(ctx, pClass, methodName) {
+        this.sb.push(pClass);
+        this.appendStepSeparator();
+        this.sb.push(this.processGremlinSymbol(methodName));
+        this.appendStepOpen();
+        const children = [];
+        for (let i = 0; i < ctx.getChildCount(); i++) {
+            const child = ctx.getChild(i);
+            const name = child.constructor?.name ?? '';
+            if (name === 'GenericArgumentContext' ||
+                name === 'GenericArgumentVarargsContext' ||
+                name === 'StringArgumentContext' ||
+                name === 'StringLiteralContext' ||
+                name === 'TraversalGTypeContext' ||
+                name === 'TraversalPredicateContext') {
+                children.push(child);
+            }
+        }
+        for (let ix = 0; ix < children.length; ix++) {
+            this.visit(children[ix]);
+            if (ix < children.length - 1) {
+                this.appendArgumentSeparator();
+            }
+        }
+        this.appendStepClose();
+    }
+    visitTraversalPredicate_eq(ctx) { this.visitP(ctx, 'P', 'eq'); }
+    visitTraversalPredicate_neq(ctx) { this.visitP(ctx, 'P', 'neq'); }
+    visitTraversalPredicate_lt(ctx) { this.visitP(ctx, 'P', 'lt'); }
+    visitTraversalPredicate_lte(ctx) { this.visitP(ctx, 'P', 'lte'); }
+    visitTraversalPredicate_gt(ctx) { this.visitP(ctx, 'P', 'gt'); }
+    visitTraversalPredicate_gte(ctx) { this.visitP(ctx, 'P', 'gte'); }
+    visitTraversalPredicate_inside(ctx) { this.visitP(ctx, 'P', 'inside'); }
+    visitTraversalPredicate_outside(ctx) { this.visitP(ctx, 'P', 'outside'); }
+    visitTraversalPredicate_between(ctx) { this.visitP(ctx, 'P', 'between'); }
+    visitTraversalPredicate_within(ctx) { this.visitP(ctx, 'P', 'within'); }
+    visitTraversalPredicate_without(ctx) { this.visitP(ctx, 'P', 'without'); }
+    visitTraversalPredicate_typeOf(ctx) { this.visitP(ctx, 'P', 'typeOf'); }
+    visitTraversalPredicate_not(ctx) { this.visitP(ctx, 'P', 'not'); }
+    visitTraversalPredicate_containing(ctx) { this.visitP(ctx, 'TextP', 'containing'); }
+    visitTraversalPredicate_notContaining(ctx) { this.visitP(ctx, 'TextP', 'notContaining'); }
+    visitTraversalPredicate_startingWith(ctx) { this.visitP(ctx, 'TextP', 'startingWith'); }
+    visitTraversalPredicate_notStartingWith(ctx) { this.visitP(ctx, 'TextP', 'notStartingWith'); }
+    visitTraversalPredicate_endingWith(ctx) { this.visitP(ctx, 'TextP', 'endingWith'); }
+    visitTraversalPredicate_notEndingWith(ctx) { this.visitP(ctx, 'TextP', 'notEndingWith'); }
+    visitTraversalPredicate_regex(ctx) { this.visitP(ctx, 'TextP', 'regex'); }
+    visitTraversalPredicate_notRegex(ctx) { this.visitP(ctx, 'TextP', 'notRegex'); }
+    visitBooleanArgument(ctx) {
+        if (ctx.booleanLiteral() != null) {
+            this.visitBooleanLiteral(ctx.booleanLiteral());
+        }
+        else {
+            this.visitVariable(ctx.variable());
+        }
+    }
+    visitGenericArgument(ctx) {
+        if (ctx.genericLiteral() != null) {
+            this.visitGenericLiteral(ctx.genericLiteral());
+        }
+        else {
+            this.visitVariable(ctx.variable());
+        }
+    }
+    visitGenericLiteral(ctx) {
+        this.visitChildren(ctx);
+    }
+    visitIntegerLiteral(ctx) {
+        this.sb.push(ctx.getText().toLowerCase());
+    }
+    visitFloatLiteral(ctx) {
+        if (ctx.infLiteral() != null) {
+            this.visit(ctx.infLiteral());
+            return;
+        }
+        if (ctx.nanLiteral() != null) {
+            this.visit(ctx.nanLiteral());
+            return;
+        }
+        this.sb.push(ctx.getText().toLowerCase());
+    }
+    visitBooleanLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitNullLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitNanLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitInfLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitUuidLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitCharacterLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitDurationLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitBinaryLiteral(ctx) {
+        this.sb.push(ctx.getText());
+    }
+    visitStringLiteral(ctx) {
+        const text = TranslateVisitor.removeFirstAndLastCharacters(ctx.getText());
+        this.handleStringLiteralText(text);
+    }
+    visitStringNullableLiteral(ctx) {
+        if (ctx.getText() === 'null') {
+            this.sb.push('null');
+        }
+        else {
+            const text = TranslateVisitor.removeFirstAndLastCharacters(ctx.getText());
+            this.handleStringLiteralText(text);
+        }
+    }
+    visitNakedKey(ctx) {
+        this.handleStringLiteralText(ctx.getText());
+    }
+    visitVariable(ctx) {
+        const varName = ctx.getText();
+        this.sb.push(varName);
+        this.parameters.add(varName);
+    }
+    visitKeyword(ctx) {
+        const keyword = ctx.getText();
+        if (ctx.parent?.constructor?.name === 'MapKeyContext' ||
+            ctx.parent?.constructor?.name === 'ConfigurationContext') {
+            this.handleStringLiteralText(keyword);
+        }
+        else {
+            this.sb.push(keyword);
+            this.sb.push(' ');
+        }
+    }
+    visitMapKey(ctx) {
+        const keyIndex = (ctx.LPAREN() != null && ctx.RPAREN() != null) ? 1 : 0;
+        this.visit(ctx.getChild(keyIndex));
+    }
+    visitMapEntry(ctx) {
+        this.visitChildren(ctx);
+    }
+}
+exports.default = TranslateVisitor;

package/build/cjs/language/translator/TranslateVisitor.d.cts

@@ -0,0 +1,94 @@
+import { ErrorNode, TerminalNode } from 'antlr4ng';
+/**
+ * Base visitor for translating Gremlin queries. Mirrors the Java TranslateVisitor.
+ * Makes no changes to input except:
+ * - Normalizes whitespace
+ * - Normalizes numeric suffixes to lower case
+ * - Makes anonymous traversals explicit with double underscore
+ * - Makes enums explicit with their proper name
+ */
+export default class TranslateVisitor {
+    protected readonly graphTraversalSourceName: string;
+    protected readonly sb: string[];
+    protected readonly parameters: Set<string>;
+    constructor(graphTraversalSourceName?: string);
+    getTranslated(): string;
+    getParameters(): ReadonlySet<string>;
+    protected processGremlinSymbol(step: string): string;
+    protected appendArgumentSeparator(): void;
+    protected appendStepSeparator(): void;
+    protected appendStepOpen(): void;
+    protected appendStepClose(): void;
+    protected appendAnonymousSpawn(): void;
+    visit(tree: any): void;
+    visitChildren(node: any): void;
+    protected getCardinalityFunctionClass(): string;
+    protected static removeFirstAndLastCharacters(text: string): string;
+    protected handleStringLiteralText(text: string): void;
+    protected appendExplicitNaming(txt: string, prefix: string): void;
+    visitTerminal(node: TerminalNode): void;
+    visitErrorNode(_node: ErrorNode): void;
+    visitTraversalSource(ctx: any): void;
+    visitTraversalSourceSelfMethod(ctx: any): void;
+    visitNestedTraversal(ctx: any): void;
+    visitTraversalScope(ctx: any): void;
+    visitTraversalT(ctx: any): void;
+    visitTraversalTShort(ctx: any): void;
+    visitTraversalTLong(ctx: any): void;
+    visitTraversalMerge(ctx: any): void;
+    visitTraversalOrder(ctx: any): void;
+    visitTraversalBarrier(ctx: any): void;
+    visitTraversalDirection(ctx: any): void;
+    visitTraversalDirectionShort(ctx: any): void;
+    visitTraversalDirectionLong(ctx: any): void;
+    visitTraversalCardinality(ctx: any): void;
+    visitTraversalColumn(ctx: any): void;
+    visitTraversalPop(ctx: any): void;
+    visitTraversalOperator(ctx: any): void;
+    visitTraversalPick(ctx: any): void;
+    visitTraversalDT(ctx: any): void;
+    visitTraversalGType(ctx: any): void;
+    visitTraversalPredicate(ctx: any): void;
+    protected visitP(ctx: any, pClass: string, methodName: string): void;
+    visitTraversalPredicate_eq(ctx: any): void;
+    visitTraversalPredicate_neq(ctx: any): void;
+    visitTraversalPredicate_lt(ctx: any): void;
+    visitTraversalPredicate_lte(ctx: any): void;
+    visitTraversalPredicate_gt(ctx: any): void;
+    visitTraversalPredicate_gte(ctx: any): void;
+    visitTraversalPredicate_inside(ctx: any): void;
+    visitTraversalPredicate_outside(ctx: any): void;
+    visitTraversalPredicate_between(ctx: any): void;
+    visitTraversalPredicate_within(ctx: any): void;
+    visitTraversalPredicate_without(ctx: any): void;
+    visitTraversalPredicate_typeOf(ctx: any): void;
+    visitTraversalPredicate_not(ctx: any): void;
+    visitTraversalPredicate_containing(ctx: any): void;
+    visitTraversalPredicate_notContaining(ctx: any): void;
+    visitTraversalPredicate_startingWith(ctx: any): void;
+    visitTraversalPredicate_notStartingWith(ctx: any): void;
+    visitTraversalPredicate_endingWith(ctx: any): void;
+    visitTraversalPredicate_notEndingWith(ctx: any): void;
+    visitTraversalPredicate_regex(ctx: any): void;
+    visitTraversalPredicate_notRegex(ctx: any): void;
+    visitBooleanArgument(ctx: any): void;
+    visitGenericArgument(ctx: any): void;
+    visitGenericLiteral(ctx: any): void;
+    visitIntegerLiteral(ctx: any): void;
+    visitFloatLiteral(ctx: any): void;
+    visitBooleanLiteral(ctx: any): void;
+    visitNullLiteral(ctx: any): void;
+    visitNanLiteral(ctx: any): void;
+    visitInfLiteral(ctx: any): void;
+    visitUuidLiteral(ctx: any): void;
+    visitCharacterLiteral(ctx: any): void;
+    visitDurationLiteral(ctx: any): void;
+    visitBinaryLiteral(ctx: any): void;
+    visitStringLiteral(ctx: any): void;
+    visitStringNullableLiteral(ctx: any): void;
+    visitNakedKey(ctx: any): void;
+    visitVariable(ctx: any): void;
+    visitKeyword(ctx: any): void;
+    visitMapKey(ctx: any): void;
+    visitMapEntry(ctx: any): void;
+}

package/build/cjs/language/translator/Translation.cjs

@@ -0,0 +1,47 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translation = void 0;
+/**
+ * Holds the result of a Gremlin translation.
+ */
+class Translation {
+    original;
+    translated;
+    parameters;
+    constructor(original, translated, parameters) {
+        this.original = original;
+        this.translated = translated;
+        this.parameters = parameters;
+    }
+    getOriginal() {
+        return this.original;
+    }
+    getTranslated() {
+        return this.translated;
+    }
+    getParameters() {
+        return this.parameters;
+    }
+    toString() {
+        return this.translated;
+    }
+}
+exports.Translation = Translation;

package/build/cjs/language/translator/Translation.d.cts

@@ -0,0 +1,13 @@
+/**
+ * Holds the result of a Gremlin translation.
+ */
+export declare class Translation {
+    readonly original: string;
+    readonly translated: string;
+    readonly parameters: ReadonlySet<string>;
+    constructor(original: string, translated: string, parameters: ReadonlySet<string>);
+    getOriginal(): string;
+    getTranslated(): string;
+    getParameters(): ReadonlySet<string>;
+    toString(): string;
+}

package/build/cjs/language/translator/Translator.cjs

@@ -0,0 +1,46 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translator = void 0;
+const TranslateVisitor_js_1 = __importDefault(require("./TranslateVisitor.cjs"));
+const JavascriptTranslateVisitor_js_1 = __importDefault(require("./JavascriptTranslateVisitor.cjs"));
+const PythonTranslateVisitor_js_1 = __importDefault(require("./PythonTranslateVisitor.cjs"));
+const GoTranslateVisitor_js_1 = __importDefault(require("./GoTranslateVisitor.cjs"));
+const DotNetTranslateVisitor_js_1 = __importDefault(require("./DotNetTranslateVisitor.cjs"));
+const JavaTranslateVisitor_js_1 = __importDefault(require("./JavaTranslateVisitor.cjs"));
+const GroovyTranslateVisitor_js_1 = __importDefault(require("./GroovyTranslateVisitor.cjs"));
+const AnonymizedTranslateVisitor_js_1 = __importDefault(require("./AnonymizedTranslateVisitor.cjs"));
+/**
+ * Extensible registry of translator factories. New languages are added here
+ * without modifying any other file.
+ */
+exports.Translator = {
+    CANONICAL: (sourceName) => new TranslateVisitor_js_1.default(sourceName),
+    JAVASCRIPT: (sourceName) => new JavascriptTranslateVisitor_js_1.default(sourceName),
+    PYTHON: (sourceName) => new PythonTranslateVisitor_js_1.default(sourceName),
+    GO: (sourceName) => new GoTranslateVisitor_js_1.default(sourceName),
+    DOTNET: (sourceName) => new DotNetTranslateVisitor_js_1.default(sourceName),
+    JAVA: (sourceName) => new JavaTranslateVisitor_js_1.default(sourceName),
+    GROOVY: (sourceName) => new GroovyTranslateVisitor_js_1.default(sourceName),
+    ANONYMIZED: (sourceName) => new AnonymizedTranslateVisitor_js_1.default(sourceName),
+};

package/build/cjs/language/translator/Translator.d.cts

@@ -0,0 +1,24 @@
+import TranslateVisitor from './TranslateVisitor.cjs';
+import JavascriptTranslateVisitor from './JavascriptTranslateVisitor.cjs';
+import PythonTranslateVisitor from './PythonTranslateVisitor.cjs';
+import GoTranslateVisitor from './GoTranslateVisitor.cjs';
+import DotNetTranslateVisitor from './DotNetTranslateVisitor.cjs';
+import JavaTranslateVisitor from './JavaTranslateVisitor.cjs';
+import GroovyTranslateVisitor from './GroovyTranslateVisitor.cjs';
+import AnonymizedTranslateVisitor from './AnonymizedTranslateVisitor.cjs';
+export type TranslatorFactory = (sourceName: string) => TranslateVisitor;
+/**
+ * Extensible registry of translator factories. New languages are added here
+ * without modifying any other file.
+ */
+export declare const Translator: {
+    CANONICAL: (sourceName: string) => TranslateVisitor;
+    JAVASCRIPT: (sourceName: string) => JavascriptTranslateVisitor;
+    PYTHON: (sourceName: string) => PythonTranslateVisitor;
+    GO: (sourceName: string) => GoTranslateVisitor;
+    DOTNET: (sourceName: string) => DotNetTranslateVisitor;
+    JAVA: (sourceName: string) => JavaTranslateVisitor;
+    GROOVY: (sourceName: string) => GroovyTranslateVisitor;
+    ANONYMIZED: (sourceName: string) => AnonymizedTranslateVisitor;
+};
+export type TranslatorKey = keyof typeof Translator;

package/build/cjs/language/translator/TranslatorException.cjs

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TranslatorException = void 0;
+/**
+ * Thrown when a Gremlin string cannot be translated to the target language.
+ */
+class TranslatorException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TranslatorException';
+    }
+}
+exports.TranslatorException = TranslatorException;

package/build/cjs/language/translator/TranslatorException.d.cts

@@ -0,0 +1,6 @@
+/**
+ * Thrown when a Gremlin string cannot be translated to the target language.
+ */
+export declare class TranslatorException extends Error {
+    constructor(message: string);
+}