@jswork/apply7-frontend-sdk/dist/index.esm.js

Sdk for apply7 frontend.

// src/english-grades/english-converter.ts
function _class_call_check(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
    }
}
function _defineProperties(target, props) {
    for(var i = 0; i < props.length; i++){
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
    }
}
function _create_class(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
}
function _define_property(obj, key, value) {
    if (key in obj) {
        Object.defineProperty(obj, key, {
            value: value,
            enumerable: true,
            configurable: true,
            writable: true
        });
    } else {
        obj[key] = value;
    }
    return obj;
}
function _object_spread(target) {
    for(var i = 1; i < arguments.length; i++){
        var source = arguments[i] != null ? arguments[i] : {};
        var ownKeys = Object.keys(source);
        if (typeof Object.getOwnPropertySymbols === "function") {
            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
            }));
        }
        ownKeys.forEach(function(key) {
            _define_property(target, key, source[key]);
        });
    }
    return target;
}
var ENGLISH_TESTING_TYPES = [
    "ielts",
    "toefl",
    "pte",
    "duolingo_english_test",
    "duolingo"
];
var isEnglishTestingType = function(type) {
    return ENGLISH_TESTING_TYPES.includes(type);
};
var EnglishConverter = /*#__PURE__*/ function() {
    "use strict";
    function EnglishConverter() {
        _class_call_check(this, EnglishConverter);
    }
    _create_class(EnglishConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                return ENGLISH_TESTING_TYPES.map(function(type) {
                    var typeObj = resume["".concat(type, "_test_score")];
                    if (typeObj) return _object_spread({
                        type: type
                    }, typeObj);
                    var total = resume["".concat(type)] || null;
                    var listening = resume["".concat(type, "_listening")] || null;
                    var reading = resume["".concat(type, "_reading")] || null;
                    var writing = resume["".concat(type, "_writing")] || null;
                    var speaking = resume["".concat(type, "_speaking")] || null;
                    return {
                        type: type,
                        total: total,
                        listening: listening,
                        reading: reading,
                        writing: writing,
                        speaking: speaking
                    };
                });
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var resume = {};
                items.forEach(function(item) {
                    var type = item.type, total = item.total, listening = item.listening, reading = item.reading, writing = item.writing, speaking = item.speaking;
                    resume["".concat(type)] = total;
                    resume["".concat(type, "_listening")] = listening;
                    resume["".concat(type, "_reading")] = reading;
                    resume["".concat(type, "_writing")] = writing;
                    resume["".concat(type, "_speaking")] = speaking;
                    resume["".concat(type, "_test_score")] = {
                        total: total,
                        listening: listening,
                        reading: reading,
                        writing: writing,
                        speaking: speaking
                    };
                });
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    toefl: null,
                    pte: null,
                    ielts: null,
                    duolingo_english_test: null,
                    toefl_listening: null,
                    toefl_reading: null,
                    toefl_writing: null,
                    toefl_speaking: null,
                    pte_listening: null,
                    pte_reading: null,
                    pte_writing: null,
                    pte_speaking: null,
                    ielts_listening: null,
                    ielts_reading: null,
                    ielts_writing: null,
                    ielts_speaking: null,
                    duolingo_english_test_listening: null,
                    duolingo_english_test_reading: null,
                    duolingo_english_test_writing: null,
                    duolingo_english_test_speaking: null,
                    // new version[toefl_test_score/pte_score/ielts_score/duolingo_english_test_score]
                    toefl_test_score: {
                        total: null,
                        listening: null,
                        reading: null,
                        writing: null,
                        speaking: null
                    },
                    pte_test_score: {
                        total: null,
                        listening: null,
                        reading: null,
                        writing: null,
                        speaking: null
                    },
                    ielts_test_score: {
                        total: null,
                        listening: null,
                        reading: null,
                        writing: null,
                        speaking: null
                    },
                    duolingo_test_score: {
                        total: null,
                        listening: null,
                        reading: null,
                        writing: null,
                        speaking: null
                    }
                };
            }
        }
    ]);
    return EnglishConverter;
}();
EnglishConverter.is = isEnglishTestingType;
EnglishConverter.isValid = function(item) {
    return item.total > 0 || item.listening > 0 || item.reading > 0 || item.writing > 0 || item.speaking > 0;
};
// src/english-grades/gre-converter.ts
var GRE_TESTING_TYPES = [
    "gre"
];
var isGreTestingType = function(type) {
    return GRE_TESTING_TYPES.includes(type);
};
var _GreConverter = /*#__PURE__*/ function() {
    "use strict";
    function _GreConverter() {
        _class_call_check(this, _GreConverter);
    }
    _create_class(_GreConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                return GRE_TESTING_TYPES.map(function(type) {
                    var typeObj = resume["".concat(type, "_test_score")];
                    if (typeObj) return _object_spread({
                        type: type
                    }, typeObj);
                    var total = resume["".concat(type)] || null;
                    var verbal = resume["".concat(type, "_verbal")] || null;
                    var quantitative = resume["".concat(type, "_quantitative")] || null;
                    return {
                        type: type,
                        total: total,
                        verbal: verbal,
                        quantitative: quantitative
                    };
                });
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(_GreConverter.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var resume = {};
                items.forEach(function(item) {
                    var type = item.type, total = item.total, verbal = item.verbal, quantitative = item.quantitative;
                    resume["".concat(type)] = total;
                    resume["".concat(type, "_verbal")] = verbal;
                    resume["".concat(type, "_quantitative")] = quantitative;
                    resume["".concat(type, "_test_score")] = {
                        total: total,
                        verbal: verbal,
                        quantitative: quantitative
                    };
                });
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    gre: null,
                    gre_verbal: null,
                    gre_quantitative: null,
                    // v2 version
                    gre_test_score: {
                        total: null,
                        verbal: null,
                        quantitative: null
                    }
                };
            }
        }
    ]);
    return _GreConverter;
}();
_GreConverter.is = isGreTestingType;
_GreConverter.isValid = function(item) {
    return item.total > 0 || item.verbal > 0 || item.quantitative > 0;
};
var GreConverter = _GreConverter;
// src/english-grades/gmat-converter.ts
var GMAT_TESTING_TYPES = [
    "gmat"
];
var isGmatTestingType = function(type) {
    return GMAT_TESTING_TYPES.includes(type);
};
var GmatConverter = /*#__PURE__*/ function() {
    "use strict";
    function GmatConverter() {
        _class_call_check(this, GmatConverter);
    }
    _create_class(GmatConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                return GMAT_TESTING_TYPES.map(function(type) {
                    var typeObj = resume["".concat(type, "_test_score")];
                    if (typeObj) return _object_spread({
                        type: type
                    }, typeObj);
                    return {
                        type: type,
                        total: resume[type] || null,
                        quant: resume["".concat(type, "_quant")] || null,
                        data_insights: resume["".concat(type, "_data_insights")] || null
                    };
                });
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                return this.toArray(resume).filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var resume = {};
                items.forEach(function(item) {
                    var type = item.type, total = item.total, quant = item.quant, data_insights = item.data_insights, verbal = item.verbal;
                    resume[type] = total;
                    resume["".concat(type, "_quant")] = quant;
                    resume["".concat(type, "_data_insights")] = data_insights;
                    resume["".concat(type, "_verbal")] = verbal;
                    resume["".concat(type, "_test_score")] = {
                        total: total,
                        quant: quant,
                        data_insights: data_insights,
                        verbal: verbal
                    };
                });
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    gmat: null,
                    gmat_quant: null,
                    gmat_data_insights: null,
                    gmat_verbal: null,
                    // v2
                    gmat_test_score: {
                        total: null,
                        quant: null,
                        data_insights: null,
                        verbal: null
                    }
                };
            }
        }
    ]);
    return GmatConverter;
}();
GmatConverter.is = isGmatTestingType;
GmatConverter.isValid = function(item) {
    return item.total > 0 || item.quant > 0 || item.data_insights > 0 || item.verbal > 0;
};
// src/standardized-grades/act-converter.ts
var ACT_TESTING_TYPES = [
    "act"
];
var isSat = function(type) {
    return ACT_TESTING_TYPES.includes(type);
};
var SatConverter = /*#__PURE__*/ function() {
    "use strict";
    function SatConverter() {
        _class_call_check(this, SatConverter);
    }
    _create_class(SatConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                return ACT_TESTING_TYPES.map(function(type) {
                    return _object_spread({
                        type: type
                    }, resume["act_test_score"]);
                });
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var _this = this;
                var resume = {};
                items.forEach(function(item) {
                    if (_this.is(item.type)) {
                        resume["act_test_score"] = item;
                    }
                });
                return resume;
            }
        },
        {
            key: "toObjectV3",
            value: function toObjectV3(obj) {
                var resume = {};
                resume["act_test_score"] = _object_spread({
                    type: "act"
                }, obj);
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    act_test_score: {
                        total: 0,
                        reading: 0,
                        english: 0,
                        math: 0,
                        science: 0,
                        writing: 0
                    }
                };
            }
        }
    ]);
    return SatConverter;
}();
SatConverter.is = isSat;
SatConverter.isValid = function(item) {
    return item.total > 0 || item.reading > 0 || item.english > 0 || item.math > 0 || item.science > 0 || item.writing > 0;
};
// src/standardized-grades/sat-converter.ts
var SAT_TESTING_TYPES = [
    "sat"
];
var isSat2 = function(type) {
    return SAT_TESTING_TYPES.includes(type);
};
var SatConverter2 = /*#__PURE__*/ function() {
    "use strict";
    function SatConverter2() {
        _class_call_check(this, SatConverter2);
    }
    _create_class(SatConverter2, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                return SAT_TESTING_TYPES.map(function(type) {
                    return _object_spread({
                        type: type
                    }, resume["sat_i_test_score"]);
                }).filter(Boolean);
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var _this = this;
                var resume = {};
                items.forEach(function(item) {
                    if (_this.is(item.type)) {
                        resume["sat_i_test_score"] = item;
                    }
                });
                return resume;
            }
        },
        {
            key: "toObjectV3",
            value: function toObjectV3(obj) {
                var resume = {};
                resume["sat_i_test_score"] = _object_spread({
                    type: "sat"
                }, obj);
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    sat_i_test_score: {
                        total: 0,
                        reading_and_writing: 0,
                        math: 0
                    }
                };
            }
        }
    ]);
    return SatConverter2;
}();
SatConverter2.is = isSat2;
SatConverter2.isValid = function(item) {
    return item.total > 0 || item.reading_and_writing > 0 || item.math > 0;
};
// src/standardized-grades/ap-tests-converter.ts
var SUBJECT_TESTING_TYPES = [
    "ap"
];
var isSubjectTests = function(type) {
    return SUBJECT_TESTING_TYPES.includes(type);
};
var ApTestsConverter = /*#__PURE__*/ function() {
    "use strict";
    function ApTestsConverter() {
        _class_call_check(this, ApTestsConverter);
    }
    _create_class(ApTestsConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                var items = [];
                SUBJECT_TESTING_TYPES.forEach(function(type) {
                    var subjectTests = resume["ap_subject_tests"] || [];
                    subjectTests.forEach(function(subjectTest) {
                        var score = subjectTest.score, subject = subjectTest.subject;
                        items.push({
                            type: type,
                            score: score,
                            subject: subject
                        });
                    });
                });
                return items;
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var results = items.map(function(item) {
                    var score = item.score, subject = item.subject;
                    return {
                        score: score || 0,
                        subject: subject || ""
                    };
                });
                return {
                    ap_subject_tests: results
                };
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    ap_subject_tests: []
                };
            }
        }
    ]);
    return ApTestsConverter;
}();
ApTestsConverter.is = isSubjectTests;
ApTestsConverter.isValid = function(item) {
    return item.score > 0 || Boolean(item.subject);
};
// src/standardized-grades/ib-subject-test-converter.ts
var IB_TESTES = [
    "ib"
];
var isSat3 = function(type) {
    return IB_TESTES.includes(type);
};
var IbSubjectTestConverter = /*#__PURE__*/ function() {
    "use strict";
    function IbSubjectTestConverter() {
        _class_call_check(this, IbSubjectTestConverter);
    }
    _create_class(IbSubjectTestConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                return IB_TESTES.map(function(type) {
                    var target = resume["ib_subject_test"];
                    if (!target) return null;
                    return _object_spread({
                        type: type
                    }, target);
                }).filter(Boolean);
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var _this = this;
                var resume = {};
                items.forEach(function(item) {
                    if (_this.is(item.type)) {
                        resume["ib_subject_test"] = item;
                    }
                });
                return resume;
            }
        },
        {
            key: "toObjectV3",
            value: function toObjectV3(obj) {
                var resume = {};
                resume["ib_subject_test"] = _object_spread({
                    type: "ib"
                }, obj);
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    ib_subject_test: {
                        type: "ib",
                        study_in_language_and_literature: 0,
                        language_acquisition: 0,
                        individuals_and_societies: 0,
                        experimental_science: 0,
                        mathematics: 0,
                        the_arts: 0
                    }
                };
            }
        }
    ]);
    return IbSubjectTestConverter;
}();
IbSubjectTestConverter.is = isSat3;
IbSubjectTestConverter.isValid = function(item) {
    return item.type === "ib" && item.study_in_language_and_literature > 0 && item.language_acquisition > 0 && item.individuals_and_societies > 0 && item.experimental_science > 0 && item.mathematics > 0 && item.the_arts > 0;
};
// src/standardized-grades/a-level-subject-tests-converter.ts
var SUBJECT_TESTING_TYPES2 = [
    "a_level"
];
var isALevelSubjectTests = function(type) {
    return SUBJECT_TESTING_TYPES2.includes(type);
};
var SubjectTestsConverter = /*#__PURE__*/ function() {
    "use strict";
    function SubjectTestsConverter() {
        _class_call_check(this, SubjectTestsConverter);
    }
    _create_class(SubjectTestsConverter, null, [
        {
            key: "toArray",
            value: function toArray(resume) {
                var items = [];
                SUBJECT_TESTING_TYPES2.forEach(function(type) {
                    var subjectTests = resume["".concat(type, "_subject_tests")] || [];
                    subjectTests.forEach(function(subjectTest) {
                        var subject = subjectTest.subject, examination_board = subjectTest.examination_board, level = subjectTest.level;
                        items.push({
                            type: type,
                            subject: subject,
                            examination_board: examination_board,
                            level: level
                        });
                    });
                });
                return items;
            }
        },
        {
            key: "toValidArray",
            value: function toValidArray(resume) {
                var items = this.toArray(resume);
                return items.filter(this.isValid);
            }
        },
        {
            key: "toObject",
            value: function toObject(items) {
                var resume = {};
                items.forEach(function(item) {
                    var type = item.type, subject = item.subject, examination_board = item.examination_board, level = item.level;
                    var subjectTests = resume["".concat(type, "_subject_tests")] || [];
                    subjectTests.push({
                        subject: subject || "",
                        examination_board: examination_board || "",
                        level: level
                    });
                    resume["".concat(type, "_subject_tests")] = subjectTests;
                });
                return resume;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return {
                    a_level_subject_tests: []
                };
            }
        }
    ]);
    return SubjectTestsConverter;
}();
SubjectTestsConverter.is = isALevelSubjectTests;
SubjectTestsConverter.isValid = function(item) {
    return Boolean(item.subject) || Boolean(item.examination_board) || Boolean(item.level);
};
// src/resume/helper.ts
var ResumeHelper = /*#__PURE__*/ function() {
    "use strict";
    function ResumeHelper() {
        _class_call_check(this, ResumeHelper);
    }
    _create_class(ResumeHelper, null, [
        {
            key: "getDefaults",
            value: function getDefaults() {
                return {
                    // common fields
                    gpa: null,
                    gpa_raw: null,
                    gpa_raw_scale: null,
                    class_rank: null,
                    high_school: "",
                    high_school_grade_level: null,
                    summer_school_or_exchange_programs: [],
                    courses: [],
                    undergraduate_courses: [],
                    honors: [],
                    papers: [],
                    extracurricular_activities: [],
                    name: "",
                    languages: [],
                    interested_career_or_major: "",
                    specialties_and_certifications: [],
                    patents: [],
                    target_countries_or_regions: [],
                    interested_majors: [],
                    preference_tags: {},
                    // new undergraduate fields
                    internship_and_work_experiences: [],
                    research_and_project_experiences: [],
                    honors_and_awards: [],
                    other_specialties_activities_experiences: []
                };
            }
        }
    ]);
    return ResumeHelper;
}();
var helper_default = ResumeHelper;
// src/resume/region-tags.ts
import { findItem, findItems } from "@jswork/tree-utils";
var TREE_OPTS = {
    children: "data"
};
var RegionTags = /*#__PURE__*/ function() {
    "use strict";
    function RegionTags() {
        _class_call_check(this, RegionTags);
    }
    _create_class(RegionTags, null, [
        {
            key: "toArray",
            value: function toArray(options) {
                var region_tags = options.region_tags, preference_tags = options.preference_tags;
                var result = [];
                for(var region in preference_tags){
                    for(var type in preference_tags[region]){
                        for(var key in preference_tags[region][type]){
                            var value = preference_tags[region][type][key];
                            var keyItem = findItem(region_tags, key, TREE_OPTS);
                            var valueItems = findItems(region_tags, value, TREE_OPTS);
                            if (valueItems.length) {
                                result.push({
                                    region: region,
                                    type: type,
                                    key: keyItem === null || keyItem === void 0 ? void 0 : keyItem.label,
                                    value: valueItems.map(function(v) {
                                        return v.label;
                                    }).join(", ")
                                });
                            }
                        }
                    }
                }
                return result;
            }
        }
    ]);
    return RegionTags;
}();
var region_tags_default = RegionTags;
// src/profile/helper.ts
var ProfileHelper = /*#__PURE__*/ function() {
    "use strict";
    function ProfileHelper() {
        _class_call_check(this, ProfileHelper);
    }
    _create_class(ProfileHelper, null, [
        {
            key: "getDefaults",
            value: function getDefaults() {
                return {
                    name: "",
                    city: ""
                };
            }
        }
    ]);
    return ProfileHelper;
}();
var helper_default2 = ProfileHelper;
// src/standardized-grades/converter-manager.ts
var ConverterManager = /*#__PURE__*/ function() {
    "use strict";
    function ConverterManager() {
        _class_call_check(this, ConverterManager);
    }
    _create_class(ConverterManager, null, [
        {
            key: "getConverter",
            value: function getConverter(type) {
                if (SubjectTestsConverter.is(type)) return SubjectTestsConverter;
                if (SatConverter.is(type)) return SatConverter;
                if (ApTestsConverter.is(type)) return ApTestsConverter;
                if (SatConverter2.is(type)) return SatConverter2;
            }
        },
        {
            key: "defaults",
            value: function defaults() {
                return _object_spread({}, SubjectTestsConverter.defaults(), SatConverter.defaults(), ApTestsConverter.defaults(), SatConverter2.defaults());
            }
        }
    ]);
    return ConverterManager;
}();
// src/english-grades/minmax.ts
import nx from "@jswork/next";
var dlgConfig = {
    total: {
        min: 40,
        max: 160
    },
    listening: {
        min: 10,
        max: 160
    },
    reading: {
        min: 10,
        max: 160
    },
    writing: {
        min: 10,
        max: 160
    },
    speaking: {
        min: 10,
        max: 160
    }
};
var defaults = {
    toefl: {
        total: {
            min: 0,
            max: 120
        },
        listening: {
            min: 0,
            max: 30
        },
        reading: {
            min: 0,
            max: 30
        },
        writing: {
            min: 0,
            max: 30
        },
        speaking: {
            min: 0,
            max: 30
        }
    },
    ielts: {
        total: {
            min: 4,
            max: 9
        },
        listening: {
            min: 4,
            max: 9
        },
        reading: {
            min: 4,
            max: 9
        },
        writing: {
            min: 4,
            max: 9
        },
        speaking: {
            min: 4,
            max: 9
        }
    },
    gre: {
        total: {
            min: 260,
            max: 340
        },
        verbal: {
            min: 130,
            max: 170
        },
        quantitative: {
            min: 130,
            max: 170
        }
    },
    gmat: {
        total: {
            min: 205,
            max: 805
        },
        verbal: {
            min: 60,
            max: 90
        },
        quant: {
            min: 60,
            max: 90
        },
        data_insights: {
            min: 60,
            max: 90
        }
    },
    pte: {
        total: {
            min: 20,
            max: 90
        },
        listening: {
            min: 20,
            max: 90
        },
        reading: {
            min: 20,
            max: 90
        },
        writing: {
            min: 20,
            max: 90
        },
        speaking: {
            min: 20,
            max: 90
        }
    },
    duolingo: dlgConfig,
    // 冗余兼容设计
    duolingo_english_test: dlgConfig
};
var minmax_default = function(type, field) {
    return nx.get(defaults, "".concat(type, ".").concat(field));
};
// src/english-grades/en-step.ts
var en_step_default = function(model) {
    if (!(model === null || model === void 0 ? void 0 : model.type)) return 1;
    return (model === null || model === void 0 ? void 0 : model.type) === "ielts" ? 0.1 : 1;
};
// src/standardized-grades/minmax.ts
import nx2 from "@jswork/next";
var defaults2 = {
    sat: {
        total: {
            min: 400,
            max: 1600
        },
        reading_and_writing: {
            min: 200,
            max: 800
        },
        math: {
            min: 200,
            max: 800
        }
    },
    act: {
        total: {
            min: 1,
            max: 36
        },
        english: {
            min: 1,
            max: 36
        },
        math: {
            min: 1,
            max: 36
        },
        reading: {
            min: 1,
            max: 36
        },
        science: {
            min: 1,
            max: 36
        },
        writing: {
            min: 1,
            max: 36
        }
    },
    ap: {
        score: {
            min: 1,
            max: 5
        }
    },
    ib: {
        total: {
            min: 0,
            max: 45
        },
        studies_in_language_and_literature: {
            min: 0,
            max: 7
        },
        language_acquisition: {
            min: 0,
            max: 7
        },
        individuals_and_societies: {
            min: 0,
            max: 7
        },
        experimental_science: {
            min: 0,
            max: 7
        },
        mathematics: {
            min: 0,
            max: 7
        },
        the_arts: {
            min: 0,
            max: 7
        }
    }
};
var minmax_default2 = function(type, field) {
    return nx2.get(defaults2, "".concat(type, ".").concat(field));
};
export { SubjectTestsConverter as ALevelSubjectTestsConverter, SatConverter as ActConverter, ApTestsConverter, EnglishConverter, GmatConverter, GreConverter, IbSubjectTestConverter, helper_default2 as ProfileHelper, region_tags_default as RegionTags, helper_default as ResumeHelper, SatConverter2 as SatConverter, ConverterManager as StandardizedGradeManager, en_step_default as enStep, minmax_default as minmax, minmax_default2 as stdMinMax };
//# sourceMappingURL=index.esm.js.map