lingui-po-translate 1.0.0 → 1.0.1

package/dist/core/core-definitions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSourceOverride = void 0;
+/**
+ * Parse source override string into a map
+ */
+function parseSourceOverride(sourceOverride) {
+    const map = new Map();
+    if (!sourceOverride) {
+        return map;
+    }
+    const pairs = sourceOverride.split(",");
+    for (const pair of pairs) {
+        const [target, source] = pair.split(":").map((s) => s.trim());
+        if (target && source) {
+            map.set(target, source);
+        }
+    }
+    return map;
+}
+exports.parseSourceOverride = parseSourceOverride;

package/dist/core/core-util.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getElementPosition = exports.insertAt = exports.readTFileCore = exports.writeTFileCore = exports.logCoreResults = void 0;
+const util_1 = require("../util/util");
+const file_format_definitions_1 = require("../file-formats/file-format-definitions");
+function logCoreResults(args, results) {
+    var _a, _b;
+    const changeSet = results.changeSet;
+    const countAdded = changeSet.added.size;
+    if (countAdded) {
+        console.info(`Add ${countAdded} new translations`);
+    }
+    const countUpdated = changeSet.updated.size;
+    if (countUpdated) {
+        console.info(`Update ${countUpdated} existing translations`);
+    }
+    const countDeleted = (_b = (_a = changeSet.deleted) === null || _a === void 0 ? void 0 : _a.size) !== null && _b !== void 0 ? _b : 0;
+    if (countDeleted) {
+        console.info(`Delete ${countDeleted} stale translations`);
+    }
+    const countSkipped = changeSet.skipped.size;
+    if (countSkipped) {
+        console.info(`Warning: Skipped ${countSkipped} translations`);
+    }
+}
+exports.logCoreResults = logCoreResults;
+async function writeTFileCore(args) {
+    args.tSet.forEach((value, key) => {
+        if (value === null) {
+            args.tSet.set(key, "");
+        }
+    });
+    const module = await (0, file_format_definitions_1.instantiateTFileFormat)(args.format);
+    module.writeTFile(args);
+}
+exports.writeTFileCore = writeTFileCore;
+async function readTFileCore(fileFormat, args) {
+    const module = await (0, file_format_definitions_1.instantiateTFileFormat)(fileFormat);
+    const rawTSet = await module.readTFile(args);
+    const tSet = new Map();
+    rawTSet.forEach((value, key) => {
+        const replacedKey = key;
+        tSet.set(replacedKey, value);
+    });
+    return tSet;
+}
+exports.readTFileCore = readTFileCore;
+function insertAt(array, index, ...elementsArray) {
+    if (index >= array.length) {
+        array.push(...elementsArray);
+    }
+    else {
+        array.splice(index, 0, ...elementsArray);
+    }
+}
+exports.insertAt = insertAt;
+function getElementPosition(args) {
+    for (let idx = 0; idx < args.array.length; idx++) {
+        if (args.array[idx] === args.element) {
+            return idx;
+        }
+    }
+    (0, util_1.logFatal)(`Did not find element ${args.element} in ${args.array}`);
+}
+exports.getElementPosition = getElementPosition;

package/dist/core/invoke-translation-service.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invokeTranslationService = void 0;
+const matcher_definitions_1 = require("../matchers/matcher-definitions");
+const service_definitions_1 = require("../services/service-definitions");
+const po_files_1 = require("../file-formats/po/po-files");
+async function invokeTranslationService(serviceInputs, args) {
+    if (args.prompt && !["openai", "typechat"].includes(args.service)) {
+        console.warn(`Warning: The '--prompt' parameter is only supported by 'openai' and 'typechat' services. Your prompt will be ignored when using '${args.service}'.`);
+    }
+    /**
+     * Some translation services throw errors if they see empty strings.
+     * Therefore, we bypass empty strings without changing them.
+     */
+    const rawInputs = [];
+    const results = new Map();
+    serviceInputs.forEach((value, key) => {
+        if (args.service != 'key-as-translation' && (!value || !value.trim().length)) {
+            results.set(key, value);
+        }
+        else {
+            rawInputs.push({
+                key,
+                value: value !== null && value !== void 0 ? value : "",
+            });
+        }
+    });
+    if (results.size) {
+        console.info(`Bypass ${results.size} strings because they are empty...`);
+    }
+    let translateResults = [];
+    if (rawInputs.length) {
+        translateResults = await runTranslationService(rawInputs, args);
+    }
+    translateResults.forEach((tResult) => {
+        results.set(tResult.key, tResult.translated);
+    });
+    return {
+        inputs: serviceInputs,
+        results,
+    };
+}
+exports.invokeTranslationService = invokeTranslationService;
+async function runTranslationService(rawInputs, args) {
+    const matcher = (0, matcher_definitions_1.instantiateTMatcher)(args.matcher);
+    const replacers = new Map();
+    rawInputs.forEach((rawString) => {
+        const replacer = (0, matcher_definitions_1.replaceInterpolations)(rawString.value, matcher);
+        replacers.set(rawString.key, replacer);
+    });
+    // Get parsed comments for context
+    const parsedComments = (0, po_files_1.getParsedComments)(args.srcFile);
+    const replacedInputs = rawInputs.map((rawString) => {
+        const parsed = parsedComments.get(rawString.key);
+        return {
+            key: rawString.key,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            value: replacers.get(rawString.key).clean,
+            context: parsed === null || parsed === void 0 ? void 0 : parsed.context,
+        };
+    });
+    const serviceArgs = {
+        strings: replacedInputs,
+        srcLng: args.srcLng,
+        targetLng: args.targetLng,
+        serviceConfig: args.serviceConfig,
+        prompt: args.prompt,
+        baseUrl: args.baseUrl,
+    };
+    console.info(`Invoke '${args.service}' from '${args.srcLng}' to '${args.targetLng}' with ${serviceArgs.strings.length} inputs...`);
+    const translationService = await (0, service_definitions_1.instantiateTService)(args.service);
+    const rawResults = await translationService.translateStrings(serviceArgs);
+    return rawResults.map((rawResult) => {
+        const cleanResult = (0, matcher_definitions_1.reInsertInterpolations)(rawResult.translated, 
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        replacers.get(rawResult.key).replacements);
+        return {
+            key: rawResult.key,
+            translated: cleanResult,
+        };
+    });
+}

package/dist/core/translate-cli.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateCli = exports.formatCliOptions = void 0;
+const tslib_1 = require("tslib");
+const translate_core_1 = require("./translate-core");
+const fs_1 = require("fs");
+const core_definitions_1 = require("./core-definitions");
+const tset_ops_1 = require("./tset-ops");
+const util_1 = require("../util/util");
+const core_util_1 = require("./core-util");
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const file_format_definitions_1 = require("../file-formats/file-format-definitions");
+const service_definitions_1 = require("../services/service-definitions");
+const matcher_definitions_1 = require("../matchers/matcher-definitions");
+async function resolveOldTarget(args, targetFileFormat) {
+    const targetPath = path_1.default.resolve(args.targetFile);
+    const targetDir = path_1.default.dirname(targetPath);
+    (0, util_1.checkDir)(targetDir, { errorHint: "Target path" });
+    if ((0, fs_1.existsSync)(targetPath)) {
+        return await (0, core_util_1.readTFileCore)(targetFileFormat, {
+            path: args.targetFile,
+            lng: args.targetLng,
+            format: targetFileFormat,
+        });
+    }
+    else {
+        return null;
+    }
+}
+function formatCliOptions(options) {
+    return `${options.map((o) => `"${o}"`).join(", ")}`;
+}
+exports.formatCliOptions = formatCliOptions;
+async function translateCli(cliArgs) {
+    var _a, _b, _c;
+    checkForEmptyStringOptions(cliArgs);
+    const fileFormats = (0, file_format_definitions_1.getTFileFormatList)();
+    const services = (0, service_definitions_1.getTServiceList)();
+    const matchers = (0, matcher_definitions_1.getTMatcherList)();
+    if (!services.includes(cliArgs.service)) {
+        (0, util_1.logFatal)(`Unknown service "${cliArgs.service}". Available services: ${formatCliOptions(services)}`);
+    }
+    if (!matchers.includes(cliArgs.matcher)) {
+        (0, util_1.logFatal)(`Unknown matcher "${cliArgs.matcher}". Available matchers: ${formatCliOptions(matchers)}`);
+    }
+    if (!fileFormats.includes(cliArgs.srcFormat)) {
+        (0, util_1.logFatal)(`Unknown source format "${cliArgs.srcFormat}". Available formats: ${formatCliOptions(fileFormats)}`);
+    }
+    const srcFileFormat = cliArgs.srcFormat;
+    if (!fileFormats.includes(cliArgs.targetFormat)) {
+        (0, util_1.logFatal)(`Unknown target format "${cliArgs.targetFormat}". Available formats: ${formatCliOptions(fileFormats)}`);
+    }
+    const targetFileFormat = cliArgs.targetFormat;
+    (0, util_1.checkNotDir)(cliArgs.srcFile, { errorHint: "srcFile" });
+    const src = await (0, core_util_1.readTFileCore)(srcFileFormat, {
+        path: cliArgs.srcFile,
+        lng: cliArgs.srcLng,
+        format: srcFileFormat,
+    });
+    if (!src.size) {
+        (0, util_1.logFatal)(`${(0, util_1.getDebugPath)(cliArgs.srcFile)} does not contain any translatable content`);
+    }
+    const oldTarget = await resolveOldTarget(cliArgs, targetFileFormat);
+    const coreArgs = {
+        src,
+        srcLng: cliArgs.srcLng,
+        srcFile: cliArgs.srcFile,
+        oldTarget,
+        targetLng: cliArgs.targetLng,
+        service: cliArgs.service,
+        serviceConfig: (_a = cliArgs.serviceConfig) !== null && _a !== void 0 ? _a : null,
+        matcher: cliArgs.matcher,
+        prompt: (_b = cliArgs.prompt) !== null && _b !== void 0 ? _b : "",
+        sourceOverride: (0, core_definitions_1.parseSourceOverride)(cliArgs.sourceOverride),
+        baseUrl: (_c = cliArgs.baseUrl) !== null && _c !== void 0 ? _c : null,
+    };
+    const result = await (0, translate_core_1.translateCore)(coreArgs);
+    const flushTarget = !oldTarget || !(0, tset_ops_1.areEqual)(oldTarget, result.newTarget);
+    if (flushTarget) {
+        console.info(`Write target ${(0, util_1.getDebugPath)(cliArgs.targetFile)}`);
+        await (0, core_util_1.writeTFileCore)({
+            path: cliArgs.targetFile,
+            tSet: result.newTarget,
+            lng: cliArgs.targetLng,
+            changeSet: result.changeSet,
+            format: targetFileFormat,
+        });
+    }
+    if (!flushTarget) {
+        console.info(`Target is up-to-date: '${cliArgs.targetFile}'`);
+    }
+}
+exports.translateCli = translateCli;
+// function parseBooleanOption(rawOption: string, optionKey: string): boolean {
+//   const option = rawOption.trim().toLowerCase();
+//   if (option === "true") {
+//     return true;
+//   } else if (option === "false") {
+//     return false;
+//   } else {
+//     logFatal(
+//       `Invalid option '--${optionKey}=${rawOption}'. Should be either true or false.`
+//     );
+//   }
+// }
+function checkForEmptyStringOptions(args) {
+    Object.keys(args).forEach((key) => {
+        const arg = args[key];
+        if (typeof arg === "string" && (arg === "" || !arg.trim().length)) {
+            (0, util_1.logFatal)(`option '--${key}' is empty -> Either omit it or provide a value`);
+        }
+    });
+}

package/dist/core/translate-core.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateCore = void 0;
+const tslib_1 = require("tslib");
+const tset_ops_1 = require("./tset-ops");
+const core_util_1 = require("./core-util");
+const util_1 = require("../util/util");
+const invoke_translation_service_1 = require("./invoke-translation-service");
+const po_files_1 = require("../file-formats/po/po-files");
+const comment_parser_1 = require("../file-formats/po/comment-parser");
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+/**
+ * Filter entries based on @manual marking
+ */
+function filterByManualMarking(inputs, args) {
+    var _a;
+    const parsedComments = (0, po_files_1.getParsedComments)(args.srcFile);
+    const overrideSourceLng = (_a = args.sourceOverride) === null || _a === void 0 ? void 0 : _a.get(args.targetLng);
+    const toTranslate = new Map();
+    const toSkip = new Map();
+    const toCopyOriginal = new Map();
+    const toTranslateFromOverride = new Map();
+    inputs.forEach((value, key) => {
+        const parsed = parsedComments.get(key);
+        if (!parsed || !(0, comment_parser_1.hasManualMarking)(parsed)) {
+            // No @manual marking, translate normally
+            toTranslate.set(key, value);
+            return;
+        }
+        if ((0, comment_parser_1.shouldSkipForManual)(parsed, args.targetLng)) {
+            // Target language is in @manual list, skip
+            toSkip.set(key, value);
+            return;
+        }
+        // Has @manual but target not in list
+        if (overrideSourceLng) {
+            // Has source override, translate from override source
+            toTranslateFromOverride.set(key, value);
+        }
+        else {
+            // No override, copy original text
+            toCopyOriginal.set(key, value);
+        }
+    });
+    return { toTranslate, toSkip, toCopyOriginal, toTranslateFromOverride };
+}
+/**
+ * Infer override source file path from current source file path
+ * e.g., /path/to/en.po with override zh-Hans -> /path/to/zh-Hans.po
+ */
+function inferOverrideSourcePath(srcFile, overrideLng) {
+    const dir = path_1.default.dirname(srcFile);
+    const ext = path_1.default.extname(srcFile);
+    return path_1.default.join(dir, `${overrideLng}${ext}`);
+}
+/**
+ * Read translations from override source file
+ */
+async function readOverrideSource(srcFile, overrideLng) {
+    const overridePath = inferOverrideSourcePath(srcFile, overrideLng);
+    try {
+        const result = await (0, core_util_1.readTFileCore)("po", {
+            path: overridePath,
+            lng: overrideLng,
+            format: "po",
+        });
+        return result;
+    }
+    catch (e) {
+        console.warn(`Warning: Could not read override source file ${overridePath}`);
+        return null;
+    }
+}
+function extractStringsToTranslate(args) {
+    const src = args.src;
+    if (!src.size) {
+        (0, util_1.logFatal)("Did not find any source translations");
+    }
+    const oldTarget = args.oldTarget;
+    if (!oldTarget) {
+        // Translate everything if an old target does not yet exist.
+        return src;
+    }
+    else {
+        // Translate values whose keys are not in the target.
+        return (0, tset_ops_1.selectLeftDistinct)(src, oldTarget, "COMPARE_KEYS_AND_NULL_VALUES");
+    }
+}
+function extractStaleTranslations(args) {
+    if (args.oldTarget) {
+        return (0, tset_ops_1.leftMinusRight)(args.oldTarget, args.src);
+    }
+    else {
+        return null;
+    }
+}
+function computeChangeSet(args, serviceInvocation) {
+    const deleted = extractStaleTranslations(args);
+    if (!serviceInvocation) {
+        return {
+            added: new Map(),
+            updated: new Map(),
+            skipped: new Map(),
+            deleted,
+        };
+    }
+    const skipped = (0, tset_ops_1.selectLeftDistinct)(serviceInvocation.inputs, serviceInvocation.results, "COMPARE_KEYS");
+    if (!args.oldTarget) {
+        return {
+            added: serviceInvocation.results,
+            updated: new Map(),
+            skipped,
+            deleted,
+        };
+    }
+    const added = (0, tset_ops_1.selectLeftDistinct)(serviceInvocation.results, args.oldTarget, "COMPARE_KEYS");
+    const updated = (0, tset_ops_1.selectLeftDistinct)(serviceInvocation.results, args.oldTarget, "COMPARE_VALUES");
+    return {
+        added,
+        updated,
+        skipped,
+        deleted,
+    };
+}
+function computeNewTarget(args, changeSet, serviceInvocation) {
+    const oldTargetRef = args.oldTarget && changeSet.deleted
+        ? (0, tset_ops_1.leftMinusRight)(args.oldTarget, changeSet.deleted)
+        : args.oldTarget;
+    if (!serviceInvocation) {
+        return oldTargetRef !== null && oldTargetRef !== void 0 ? oldTargetRef : new Map();
+    }
+    if (!oldTargetRef) {
+        return serviceInvocation.results;
+    }
+    return (0, tset_ops_1.joinResultsPreserveOrder)({
+        translateResults: serviceInvocation.results,
+        changeSet,
+        oldTarget: oldTargetRef,
+        src: args.src,
+    });
+}
+function computeCoreResults(args, serviceInvocation, changeSet) {
+    return {
+        changeSet,
+        serviceInvocation,
+        newTarget: computeNewTarget(args, changeSet, serviceInvocation),
+    };
+}
+async function translateCore(args) {
+    const rawServiceInputs = extractStringsToTranslate(args);
+    // Filter entries based on @manual marking
+    const filtered = filterByManualMarking(rawServiceInputs, args);
+    // Log what we're doing
+    if (filtered.toSkip.size > 0) {
+        console.info(`Skip ${filtered.toSkip.size} entries marked as @manual:${args.targetLng}`);
+    }
+    if (filtered.toCopyOriginal.size > 0) {
+        console.info(`Copy original text for ${filtered.toCopyOriginal.size} entries with @manual (no override)`);
+    }
+    if (filtered.toTranslateFromOverride.size > 0) {
+        const overrideLng = args.sourceOverride.get(args.targetLng);
+        console.info(`Translate ${filtered.toTranslateFromOverride.size} entries from override source ${overrideLng}`);
+    }
+    let serviceInvocation = null;
+    // Translate entries without @manual marking
+    if (filtered.toTranslate.size >= 1) {
+        serviceInvocation = await (0, invoke_translation_service_1.invokeTranslationService)(filtered.toTranslate, args);
+    }
+    // Handle entries that need to copy original text
+    if (filtered.toCopyOriginal.size > 0) {
+        if (!serviceInvocation) {
+            serviceInvocation = { inputs: new Map(), results: new Map() };
+        }
+        filtered.toCopyOriginal.forEach((value, key) => {
+            serviceInvocation.inputs.set(key, value);
+            serviceInvocation.results.set(key, value); // Copy original
+        });
+    }
+    // Handle entries that need to translate from override source
+    if (filtered.toTranslateFromOverride.size > 0) {
+        const overrideLng = args.sourceOverride.get(args.targetLng);
+        if (overrideLng) {
+            const overrideSource = await readOverrideSource(args.srcFile, overrideLng);
+            if (overrideSource) {
+                // Create inputs from override source
+                const overrideInputs = new Map();
+                filtered.toTranslateFromOverride.forEach((_, key) => {
+                    const overrideValue = overrideSource.get(key);
+                    if (overrideValue) {
+                        overrideInputs.set(key, overrideValue);
+                    }
+                });
+                if (overrideInputs.size > 0) {
+                    // Translate from override source
+                    const overrideArgs = {
+                        ...args,
+                        src: overrideInputs,
+                        srcLng: overrideLng,
+                    };
+                    const overrideResult = await (0, invoke_translation_service_1.invokeTranslationService)(overrideInputs, overrideArgs);
+                    // Merge results
+                    if (!serviceInvocation) {
+                        serviceInvocation = { inputs: new Map(), results: new Map() };
+                    }
+                    overrideResult.inputs.forEach((value, key) => {
+                        serviceInvocation.inputs.set(key, value);
+                    });
+                    overrideResult.results.forEach((value, key) => {
+                        serviceInvocation.results.set(key, value);
+                    });
+                }
+            }
+            else {
+                // Fallback: copy original if override source not available
+                if (!serviceInvocation) {
+                    serviceInvocation = { inputs: new Map(), results: new Map() };
+                }
+                filtered.toTranslateFromOverride.forEach((value, key) => {
+                    serviceInvocation.inputs.set(key, value);
+                    serviceInvocation.results.set(key, value);
+                });
+            }
+        }
+    }
+    const changeSet = computeChangeSet(args, serviceInvocation);
+    const results = computeCoreResults(args, serviceInvocation, changeSet);
+    (0, core_util_1.logCoreResults)(args, results);
+    return results;
+}
+exports.translateCore = translateCore;

package/dist/core/tset-ops.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEqual = exports.leftMinusRight = exports.joinResultsPreserveOrder = exports.selectLeftDistinct = void 0;
+const core_util_1 = require("./core-util");
+function selectLeftDistinct(left, right, strategy) {
+    const leftDistinct = new Map();
+    left.forEach((leftValue, key) => {
+        const rightValue = right.get(key);
+        const distinct = compareLeftRight({ leftValue, rightValue, strategy });
+        if (distinct) {
+            leftDistinct.set(key, leftValue);
+        }
+    });
+    return leftDistinct;
+}
+exports.selectLeftDistinct = selectLeftDistinct;
+function compareLeftRight(args) {
+    switch (args.strategy) {
+        case "COMPARE_KEYS":
+            return args.rightValue === undefined;
+        case "COMPARE_KEYS_AND_NULL_VALUES":
+            return (args.rightValue === undefined ||
+                (args.rightValue === null && args.leftValue !== null));
+        case "COMPARE_VALUES":
+            return (args.rightValue !== undefined && args.leftValue !== args.rightValue);
+    }
+}
+function joinResultsPreserveOrder(args) {
+    // To prevent file-scrambling, we have to preserve the order of the old target.
+    const targetOrder = [];
+    args.oldTarget.forEach((value, key) => {
+        targetOrder.push(key);
+    });
+    // Newly added translations are more flexible in its position.
+    // Therefore, we try to mimic the order of src.
+    injectNewKeysIntoTargetOrder({
+        targetOrder,
+        newlyAdded: args.changeSet.added,
+        oldTarget: args.oldTarget,
+        src: args.src,
+    });
+    // Create an in-order map out of the determined targetOrder
+    const joinResult = new Map();
+    targetOrder.forEach((key) => {
+        const freshResult = args.translateResults.get(key);
+        const oldResult = args.oldTarget.get(key);
+        if (freshResult !== undefined) {
+            joinResult.set(key, freshResult);
+        }
+        else if (oldResult !== undefined) {
+            joinResult.set(key, oldResult);
+        }
+    });
+    // Add any remaining newly added translations whose target order was not determined.
+    args.changeSet.added.forEach((value, key) => {
+        if (!joinResult.has(key)) {
+            joinResult.set(key, value);
+        }
+    });
+    return joinResult;
+}
+exports.joinResultsPreserveOrder = joinResultsPreserveOrder;
+function injectNewKeysIntoTargetOrder(args) {
+    let injectPosition = 0;
+    args.src.forEach((srcValue, srcKey) => {
+        if (args.oldTarget.get(srcKey) !== undefined) {
+            injectPosition =
+                1 +
+                    (0, core_util_1.getElementPosition)({
+                        array: args.targetOrder,
+                        element: srcKey,
+                    });
+        }
+        if (args.newlyAdded.get(srcKey) !== undefined) {
+            (0, core_util_1.insertAt)(args.targetOrder, injectPosition, srcKey);
+            injectPosition++;
+        }
+    });
+}
+function leftMinusRight(left, right) {
+    const leftRemaining = new Map();
+    left.forEach((value, key) => {
+        if (!right.has(key)) {
+            leftRemaining.set(key, value);
+        }
+    });
+    return leftRemaining;
+}
+exports.leftMinusRight = leftMinusRight;
+function areEqual(set1, set2) {
+    if (set1.size !== set2.size) {
+        return false;
+    }
+    for (const key1 of set1.keys()) {
+        const value1 = set1.get(key1);
+        const value2 = set2.get(key1);
+        if (value1 !== value2) {
+            return false;
+        }
+    }
+    for (const key2 of set2.keys()) {
+        const value1 = set1.get(key2);
+        const value2 = set2.get(key2);
+        if (value1 !== value2) {
+            return false;
+        }
+    }
+    return true;
+}
+exports.areEqual = areEqual;