@fgv/ts-bcp47 0.5.0

package/bcp47/languageTagParser.js

@@ -0,0 +1,310 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageTagParser = void 0;
+const Iana = __importStar(require("../iana"));
+const ts_utils_1 = require("@fgv/ts-utils");
+const bcp47Subtags_1 = require("./bcp47Subtags");
+/**
+ * @public
+ */
+class LanguageTagParser {
+    // istanbul ignore next
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    constructor() { }
+    /**
+     * Parses a string representation of a BCP-47 ({@link https://www.rfc-editor.org/rfc/rfc5646.html | RFC 5646})
+     * language tag, to produce a {@link Bcp47.Subtags | Subtags} object which
+     * breaks out each of the subtags.
+     * @param tag - The `string` language tag to be parsed.
+     * @param iana - Optional {@link Iana.LanguageRegistries | IANA language registries}
+     * to be used.
+     * @returns `Success` with the resulting {@link Bcp47.Subtags | subtags}
+     * or `Failure` with details if an error occurs.
+     * @public
+     */
+    static parse(tag, iana) {
+        // istanbul ignore next
+        iana = iana !== null && iana !== void 0 ? iana : Iana.DefaultRegistries.languageRegistries;
+        const status = {
+            tag,
+            iana,
+            subtags: tag.split('-'),
+            parsedSubtags: {},
+        };
+        status.next = status.subtags.shift();
+        return (0, ts_utils_1.allSucceed)([
+            this._parseGrandfatheredTag(status),
+            this._parsePrimaryLanguage(status),
+            this._parseExtlang(status),
+            this._parseScript(status),
+            this._parseRegion(status),
+            this._parseVariants(status),
+            this._parseExtensions(status),
+            this._parsePrivateSubtags(status),
+            this._parseTagEnd(status),
+        ], status).onSuccess(() => {
+            return (0, ts_utils_1.succeed)(status.parsedSubtags);
+        });
+    }
+    /**
+     * Determines if the entire tag matches a registered grandfathered tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with the updated {@link Bcp47.Subtags | subtags}
+     * if a grandfathered tag is found, or `Success` with the supplied subtags
+     * if no matching grandfathered tag is found.
+     * @
+     * @internal
+     */
+    static _parseGrandfatheredTag(state) {
+        const grandfathered = state.iana.subtags.grandfathered.tryGet(state.tag);
+        if (grandfathered) {
+            state.parsedSubtags.grandfathered = state.tag;
+            // we consumed the whole thing
+            state.subtags.splice(0, state.subtags.length);
+            state.next = undefined;
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Parses the primary language subtag of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the primary language subtag, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parsePrimaryLanguage(state) {
+        // primary language subtag is required unless the entire tag is grandfathered or consists
+        // of only private tags
+        if (state.iana.subtags.languages.isWellFormed(state.next)) {
+            state.parsedSubtags.primaryLanguage = state.next;
+            state.next = state.subtags.shift();
+            return (0, ts_utils_1.succeed)(state.parsedSubtags);
+        }
+        else if (state.parsedSubtags.grandfathered !== undefined) {
+            return (0, ts_utils_1.succeed)(state.parsedSubtags);
+        }
+        else if (bcp47Subtags_1.Validate.privateUsePrefix.isWellFormed(state.next)) {
+            // just return with no primary language and the private tag
+            // parser will be invoked by the parent flow.
+            return (0, ts_utils_1.succeed)(state.parsedSubtags);
+        }
+        return (0, ts_utils_1.fail)(`${state.tag}: no primary language subtag`);
+    }
+    /**
+     * Parses the extlang subtag(s) of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include extlang subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseExtlang(state) {
+        // optional extlangs subtags
+        while (state.iana.subtags.extlangs.isWellFormed(state.next)) {
+            if (state.parsedSubtags.extlangs === undefined) {
+                state.parsedSubtags.extlangs = [state.next];
+            }
+            else if (state.parsedSubtags.extlangs.length < 3) {
+                state.parsedSubtags.extlangs.push(state.next);
+            }
+            else {
+                return (0, ts_utils_1.fail)(`${state.next}: too many extlang subtags`);
+            }
+            state.next = state.subtags.shift();
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Parses the script subtag of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the script subtag if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseScript(state) {
+        // optional script subtag
+        if (state.iana.subtags.scripts.isWellFormed(state.next)) {
+            state.parsedSubtags.script = state.next;
+            state.next = state.subtags.shift();
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Parses the region subtag of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the region subtag if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseRegion(state) {
+        // optional region subtag
+        if (state.iana.subtags.regions.isWellFormed(state.next)) {
+            state.parsedSubtags.region = state.next;
+            state.next = state.subtags.shift();
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Parses the variant subtag(s) of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the variant subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseVariants(state) {
+        // optional variant subtags
+        while (state.iana.subtags.variants.isWellFormed(state.next)) {
+            if (state.parsedSubtags.variants === undefined) {
+                state.parsedSubtags.variants = [state.next];
+            }
+            else {
+                state.parsedSubtags.variants.push(state.next);
+            }
+            state.next = state.subtags.shift();
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Parses the extension subtag(s) of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the extension subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parseExtensions(state) {
+        // optional extension subtags
+        while (state.next !== undefined && bcp47Subtags_1.Validate.extensionSingleton.isWellFormed(state.next)) {
+            const singleton = state.next;
+            const values = [];
+            state.next = state.subtags.shift();
+            while (bcp47Subtags_1.Validate.extensionSubtag.isWellFormed(state.next)) {
+                values.push(state.next);
+                state.next = state.subtags.shift();
+            }
+            if (state.next !== undefined &&
+                !bcp47Subtags_1.Validate.extensionSingleton.isWellFormed(state.next) &&
+                !bcp47Subtags_1.Validate.extensionSingleton.isWellFormed(state.next)) {
+                return (0, ts_utils_1.fail)(`${state.next}: malformed extension subtag`);
+            }
+            else if (values.length < 1) {
+                return (0, ts_utils_1.fail)(`${state.tag}: extension '${singleton}' must have at least one subtag.`);
+            }
+            const value = values.join('-');
+            if (state.parsedSubtags.extensions === undefined) {
+                state.parsedSubtags.extensions = [{ singleton, value }];
+            }
+            else {
+                state.parsedSubtags.extensions.push({ singleton, value });
+            }
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Parses the private use subtags of a supplied language tag.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}
+     * updated to include the private-use subtags if present, or `Failure` with details if an error
+     * occurs.
+     * @internal
+     */
+    static _parsePrivateSubtags(state) {
+        // optional private use subtags
+        while (state.next != undefined && bcp47Subtags_1.Validate.privateUsePrefix.isWellFormed(state.next)) {
+            const values = [];
+            state.next = state.subtags.shift();
+            while (state.next &&
+                !bcp47Subtags_1.Validate.privateUsePrefix.isWellFormed(state.next) &&
+                Iana.LanguageSubtags.Validate.extendedLanguageRange.isWellFormed(state.next)) {
+                values.push(state.next);
+                state.next = state.subtags.shift();
+            }
+            if (state.next !== undefined && !bcp47Subtags_1.Validate.privateUsePrefix.isWellFormed(state.next)) {
+                return (0, ts_utils_1.fail)(`${state.next}: malformed private-use subtag`);
+            }
+            else if (values.length < 1) {
+                return (0, ts_utils_1.fail)(`${state.tag}: private-use tag must have at least one subtag.`);
+            }
+            const value = values.join('-');
+            if (state.parsedSubtags.privateUse === undefined) {
+                state.parsedSubtags.privateUse = [value];
+            }
+            else {
+                state.parsedSubtags.privateUse.push(value);
+            }
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+    /**
+     * Verifies {@link Bcp47.ParserState | parser state} at the end of a parse operation.
+     * @param state - The {@link Bcp47.ParserState | current state} of the
+     * parse operation.
+     * @returns `Success` if the tag was fully consumed, or `Failure` with details
+     * if unexpected subtags remain to be parsed.
+     * @internal
+     */
+    static _parseTagEnd(state) {
+        if (state.next !== undefined) {
+            return (0, ts_utils_1.fail)(`${state.next}: unexpected subtag`);
+        }
+        return (0, ts_utils_1.succeed)(state.parsedSubtags);
+    }
+}
+exports.LanguageTagParser = LanguageTagParser;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"languageTagParser.js","sourceRoot":"","sources":["../../src/bcp47/languageTagParser.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2022 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as Iana from '../iana';\n\nimport { Result, Success, allSucceed, fail, succeed } from '@fgv/ts-utils';\n\nimport { ExtensionSubtag } from './bcp47Subtags/model';\nimport { Subtags } from './common';\nimport { Validate } from './bcp47Subtags';\n\n/**\n * @internal\n */\ninterface ParserState {\n    readonly iana: Iana.LanguageRegistries;\n    readonly tag: string;\n    readonly subtags: string[];\n    readonly parsedSubtags: Subtags;\n    next?: string;\n}\n\n/**\n * @public\n */\nexport class LanguageTagParser {\n    // istanbul ignore next\n    // eslint-disable-next-line @typescript-eslint/no-empty-function\n    private constructor() {}\n\n    /**\n     * Parses a string representation of a BCP-47 ({@link https://www.rfc-editor.org/rfc/rfc5646.html | RFC 5646})\n     * language tag, to produce a {@link Bcp47.Subtags | Subtags} object which\n     * breaks out each of the subtags.\n     * @param tag - The `string` language tag to be parsed.\n     * @param iana - Optional {@link Iana.LanguageRegistries | IANA language registries}\n     * to be used.\n     * @returns `Success` with the resulting {@link Bcp47.Subtags | subtags}\n     * or `Failure` with details if an error occurs.\n     * @public\n     */\n    public static parse(tag: string, iana?: Iana.LanguageRegistries): Result<Subtags> {\n        // istanbul ignore next\n        iana = iana ?? Iana.DefaultRegistries.languageRegistries;\n        const status: ParserState = {\n            tag,\n            iana,\n            subtags: tag.split('-'),\n            parsedSubtags: {},\n        };\n        status.next = status.subtags.shift();\n\n        return allSucceed(\n            [\n                this._parseGrandfatheredTag(status),\n                this._parsePrimaryLanguage(status),\n                this._parseExtlang(status),\n                this._parseScript(status),\n                this._parseRegion(status),\n                this._parseVariants(status),\n                this._parseExtensions(status),\n                this._parsePrivateSubtags(status),\n                this._parseTagEnd(status),\n            ],\n            status\n        ).onSuccess(() => {\n            return succeed(status.parsedSubtags);\n        });\n    }\n\n    /**\n     * Determines if the entire tag matches a registered grandfathered tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with the updated {@link Bcp47.Subtags | subtags}\n     * if a grandfathered tag is found, or `Success` with the supplied subtags\n     * if no matching grandfathered tag is found.\n     * @\n     * @internal\n     */\n    protected static _parseGrandfatheredTag(state: ParserState): Success<Subtags> {\n        const grandfathered = state.iana.subtags.grandfathered.tryGet(state.tag);\n        if (grandfathered) {\n            state.parsedSubtags.grandfathered = state.tag as Iana.LanguageSubtags.GrandfatheredTag;\n            // we consumed the whole thing\n            state.subtags.splice(0, state.subtags.length);\n            state.next = undefined;\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Parses the primary language subtag of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include the primary language subtag, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parsePrimaryLanguage(state: ParserState): Result<Subtags> {\n        // primary language subtag is required unless the entire tag is grandfathered or consists\n        // of only private tags\n        if (state.iana.subtags.languages.isWellFormed(state.next)) {\n            state.parsedSubtags.primaryLanguage = state.next;\n            state.next = state.subtags.shift();\n            return succeed(state.parsedSubtags);\n        } else if (state.parsedSubtags.grandfathered !== undefined) {\n            return succeed(state.parsedSubtags);\n        } else if (Validate.privateUsePrefix.isWellFormed(state.next)) {\n            // just return with no primary language and the private tag\n            // parser will be invoked by the parent flow.\n            return succeed(state.parsedSubtags);\n        }\n        return fail(`${state.tag}: no primary language subtag`);\n    }\n\n    /**\n     * Parses the extlang subtag(s) of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include extlang subtags if present, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parseExtlang(state: ParserState): Result<Subtags> {\n        // optional extlangs subtags\n        while (state.iana.subtags.extlangs.isWellFormed(state.next)) {\n            if (state.parsedSubtags.extlangs === undefined) {\n                state.parsedSubtags.extlangs = [state.next];\n            } else if (state.parsedSubtags.extlangs.length < 3) {\n                state.parsedSubtags.extlangs.push(state.next);\n            } else {\n                return fail(`${state.next}: too many extlang subtags`);\n            }\n            state.next = state.subtags.shift();\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Parses the script subtag of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include the script subtag if present, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parseScript(state: ParserState): Result<Subtags> {\n        // optional script subtag\n        if (state.iana.subtags.scripts.isWellFormed(state.next)) {\n            state.parsedSubtags.script = state.next;\n            state.next = state.subtags.shift();\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Parses the region subtag of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include the region subtag if present, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parseRegion(state: ParserState): Result<Subtags> {\n        // optional region subtag\n        if (state.iana.subtags.regions.isWellFormed(state.next)) {\n            state.parsedSubtags.region = state.next;\n            state.next = state.subtags.shift();\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Parses the variant subtag(s) of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include the variant subtags if present, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parseVariants(state: ParserState): Result<Subtags> {\n        // optional variant subtags\n        while (state.iana.subtags.variants.isWellFormed(state.next)) {\n            if (state.parsedSubtags.variants === undefined) {\n                state.parsedSubtags.variants = [state.next];\n            } else {\n                state.parsedSubtags.variants.push(state.next);\n            }\n            state.next = state.subtags.shift();\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Parses the extension subtag(s) of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include the extension subtags if present, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parseExtensions(state: ParserState): Result<Subtags> {\n        // optional extension subtags\n        while (state.next !== undefined && Validate.extensionSingleton.isWellFormed(state.next)) {\n            const singleton = state.next;\n            const values: ExtensionSubtag[] = [];\n            state.next = state.subtags.shift();\n\n            while (Validate.extensionSubtag.isWellFormed(state.next)) {\n                values.push(state.next);\n                state.next = state.subtags.shift();\n            }\n            if (\n                state.next !== undefined &&\n                !Validate.extensionSingleton.isWellFormed(state.next) &&\n                !Validate.extensionSingleton.isWellFormed(state.next)\n            ) {\n                return fail(`${state.next}: malformed extension subtag`);\n            } else if (values.length < 1) {\n                return fail(`${state.tag}: extension '${singleton}' must have at least one subtag.`);\n            }\n\n            const value = values.join('-') as ExtensionSubtag;\n            if (state.parsedSubtags.extensions === undefined) {\n                state.parsedSubtags.extensions = [{ singleton, value }];\n            } else {\n                state.parsedSubtags.extensions.push({ singleton, value });\n            }\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Parses the private use subtags of a supplied language tag.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` with supplied {@link Bcp47.Subtags | subtags}\n     * updated to include the private-use subtags if present, or `Failure` with details if an error\n     * occurs.\n     * @internal\n     */\n    protected static _parsePrivateSubtags(state: ParserState): Result<Subtags> {\n        // optional private use subtags\n        while (state.next != undefined && Validate.privateUsePrefix.isWellFormed(state.next)) {\n            const values: string[] = [];\n            state.next = state.subtags.shift();\n\n            while (\n                state.next &&\n                !Validate.privateUsePrefix.isWellFormed(state.next) &&\n                Iana.LanguageSubtags.Validate.extendedLanguageRange.isWellFormed(state.next)\n            ) {\n                values.push(state.next);\n                state.next = state.subtags.shift();\n            }\n\n            if (state.next !== undefined && !Validate.privateUsePrefix.isWellFormed(state.next)) {\n                return fail(`${state.next}: malformed private-use subtag`);\n            } else if (values.length < 1) {\n                return fail(`${state.tag}: private-use tag must have at least one subtag.`);\n            }\n\n            const value = values.join('-') as Iana.LanguageSubtags.ExtendedLanguageRange;\n            if (state.parsedSubtags.privateUse === undefined) {\n                state.parsedSubtags.privateUse = [value];\n            } else {\n                state.parsedSubtags.privateUse.push(value);\n            }\n        }\n        return succeed(state.parsedSubtags);\n    }\n\n    /**\n     * Verifies {@link Bcp47.ParserState | parser state} at the end of a parse operation.\n     * @param state - The {@link Bcp47.ParserState | current state} of the\n     * parse operation.\n     * @returns `Success` if the tag was fully consumed, or `Failure` with details\n     * if unexpected subtags remain to be parsed.\n     * @internal\n     */\n    protected static _parseTagEnd(state: ParserState): Result<Subtags> {\n        if (state.next !== undefined) {\n            return fail(`${state.next}: unexpected subtag`);\n        }\n        return succeed(state.parsedSubtags);\n    }\n}\n"]}

package/bcp47/match/chooser.d.ts

@@ -0,0 +1,70 @@
+import * as Iana from '../../iana';
+import { LanguageSimilarityMatcher } from './similarity';
+import { LanguageTag } from '../languageTag';
+import { Subtags } from '../common';
+/**
+ * Represents a single matching filtered language.
+ * @public
+ */
+export interface MatchingLanguage {
+    /**
+     * Numeric indication of how well the language matches,
+     * from perfect (`1.0`) to not at all (`0.0`).  When
+     * matching an ordered list, languages at the front of
+     * the desired language list are always higher quality.
+     */
+    quality: number;
+    /**
+     * The `string` tag of the matched language.
+     */
+    tag: string;
+    /**
+     * The matched {@link Bcp47.LanguageTag | language tag}.
+     */
+    languageTag: LanguageTag;
+}
+/**
+ * Options for {@link Bcp47.filter | language tag list filter} functions.
+ * @public
+ */
+export interface LanguageChooserOptions {
+    /**
+     * Indicates whether to return the matching language from the
+     * desired list or the available list. Default is `'availableLanguage'`.
+     */
+    use?: 'desiredLanguage' | 'availableLanguage';
+    /**
+     * Indicates how to filter the language list - `'primaryLanguage'`
+     * indicates the each primary language should appear only once in
+     * the list in its most similar form.  A filter value of `'none'`
+     * reports all matching variants of any primary language in order
+     * of similarity.  Default is `'primaryLanguage'`
+     */
+    filter?: 'primaryLanguage' | 'none';
+    /**
+     * An optional {@link Bcp47.LanguageSpec | language specification}
+     * indicating a language to be returned if the filter call would
+     * otherwise return an empty list (i.e. no languages match).
+     */
+    ultimateFallback?: string | Subtags | LanguageTag;
+}
+/**
+ * Default values for a{@link Bcp47.LanguageFilterOptions}.
+ * @public
+ */
+export declare const defaultLanguageChooserOptions: LanguageChooserOptions;
+/**
+ * Helper to compare a list of 'desired' languages to a list of 'available' language
+ * and return the intersection in order of preference, taking tag semantics into account.
+ * @public
+ */
+export declare class LanguageChooser {
+    /**
+     * @internal
+     */
+    protected readonly _matcher: LanguageSimilarityMatcher;
+    constructor(iana?: Iana.LanguageRegistries);
+    chooseLanguageTagsWithDetails(desiredLanguages: LanguageTag[], availableLanguages: LanguageTag[], options?: LanguageChooserOptions): MatchingLanguage[];
+    filterLanguageTags(desiredLanguages: LanguageTag[], availableLanguages: LanguageTag[], options?: LanguageChooserOptions): LanguageTag[];
+}
+//# sourceMappingURL=chooser.d.ts.map

package/bcp47/match/chooser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chooser.d.ts","sourceRoot":"","sources":["../../../src/bcp47/match/chooser.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,IAAI,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC7B;;;;;OAKG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,WAAW,EAAE,WAAW,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACnC;;;OAGG;IACH,GAAG,CAAC,EAAE,iBAAiB,GAAG,mBAAmB,CAAC;IAE9C;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAAC;IAEpC;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,CAAC;CACrD;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,EAAE,sBAG1C,CAAC;AAEH;;;;GAIG;AACH,qBAAa,eAAe;IACxB;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,yBAAyB,CAAC;gBAEpC,IAAI,CAAC,EAAE,IAAI,CAAC,kBAAkB;IAI1C,6BAA6B,CAChC,gBAAgB,EAAE,WAAW,EAAE,EAC/B,kBAAkB,EAAE,WAAW,EAAE,EACjC,OAAO,CAAC,EAAE,sBAAsB,GACjC,gBAAgB,EAAE;IAgDd,kBAAkB,CACrB,gBAAgB,EAAE,WAAW,EAAE,EAC/B,kBAAkB,EAAE,WAAW,EAAE,EACjC,OAAO,CAAC,EAAE,sBAAsB,GACjC,WAAW,EAAE;CAGnB"}

package/bcp47/match/chooser.js

@@ -0,0 +1,92 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LanguageChooser = exports.defaultLanguageChooserOptions = void 0;
+const similarity_1 = require("./similarity");
+const languageTag_1 = require("../languageTag");
+/**
+ * Default values for a{@link Bcp47.LanguageFilterOptions}.
+ * @public
+ */
+exports.defaultLanguageChooserOptions = Object.freeze({
+    use: 'availableLanguage',
+    filter: 'primaryLanguage',
+});
+/**
+ * Helper to compare a list of 'desired' languages to a list of 'available' language
+ * and return the intersection in order of preference, taking tag semantics into account.
+ * @public
+ */
+class LanguageChooser {
+    constructor(iana) {
+        this._matcher = new similarity_1.LanguageSimilarityMatcher(iana);
+    }
+    chooseLanguageTagsWithDetails(desiredLanguages, availableLanguages, options) {
+        var _a;
+        const matched = new Map();
+        const decrement = desiredLanguages.length < 10 ? 0.1 : 1.0 / desiredLanguages.length;
+        let base = 1.0;
+        // fill any missing fields from the default
+        options = { ...exports.defaultLanguageChooserOptions, ...options };
+        for (const want of desiredLanguages) {
+            base -= decrement;
+            for (const have of availableLanguages) {
+                const similarity = this._matcher.matchLanguageTags(want, have);
+                if (similarity > 0.0) {
+                    const quality = base + similarity * decrement;
+                    const languageTag = options.use === 'availableLanguage' ? have : want;
+                    const tag = languageTag.tag;
+                    const key = options.filter === 'primaryLanguage' ? (_a = languageTag.subtags.primaryLanguage) !== null && _a !== void 0 ? _a : tag : tag;
+                    const match = {
+                        quality,
+                        tag,
+                        languageTag,
+                    };
+                    const existing = matched.get(key);
+                    if (!existing || existing.quality < quality) {
+                        matched.set(key, match);
+                    }
+                }
+            }
+        }
+        const values = Array.from(matched.values());
+        if (values.length > 1) {
+            // want descending order
+            values.sort((m1, m2) => m2.quality - m1.quality);
+        }
+        else if (values.length === 0 && options.ultimateFallback) {
+            const languageTag = options.ultimateFallback instanceof languageTag_1.LanguageTag
+                ? options.ultimateFallback
+                : languageTag_1.LanguageTag.create(options.ultimateFallback).orDefault();
+            if (languageTag) {
+                return [{ languageTag, tag: languageTag.tag, quality: 0 }];
+            }
+        }
+        return values;
+    }
+    filterLanguageTags(desiredLanguages, availableLanguages, options) {
+        return this.chooseLanguageTagsWithDetails(desiredLanguages, availableLanguages, options).map((t) => t.languageTag);
+    }
+}
+exports.LanguageChooser = LanguageChooser;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chooser.js","sourceRoot":"","sources":["../../../src/bcp47/match/chooser.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2022 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as Iana from '../../iana';\n\nimport { LanguageSimilarityMatcher } from './similarity';\nimport { LanguageTag } from '../languageTag';\nimport { Subtags } from '../common';\n\n/**\n * Represents a single matching filtered language.\n * @public\n */\nexport interface MatchingLanguage {\n    /**\n     * Numeric indication of how well the language matches,\n     * from perfect (`1.0`) to not at all (`0.0`).  When\n     * matching an ordered list, languages at the front of\n     * the desired language list are always higher quality.\n     */\n    quality: number;\n    /**\n     * The `string` tag of the matched language.\n     */\n    tag: string;\n    /**\n     * The matched {@link Bcp47.LanguageTag | language tag}.\n     */\n    languageTag: LanguageTag;\n}\n\n/**\n * Options for {@link Bcp47.filter | language tag list filter} functions.\n * @public\n */\nexport interface LanguageChooserOptions {\n    /**\n     * Indicates whether to return the matching language from the\n     * desired list or the available list. Default is `'availableLanguage'`.\n     */\n    use?: 'desiredLanguage' | 'availableLanguage';\n\n    /**\n     * Indicates how to filter the language list - `'primaryLanguage'`\n     * indicates the each primary language should appear only once in\n     * the list in its most similar form.  A filter value of `'none'`\n     * reports all matching variants of any primary language in order\n     * of similarity.  Default is `'primaryLanguage'`\n     */\n    filter?: 'primaryLanguage' | 'none';\n\n    /**\n     * An optional {@link Bcp47.LanguageSpec | language specification}\n     * indicating a language to be returned if the filter call would\n     * otherwise return an empty list (i.e. no languages match).\n     */\n    ultimateFallback?: string | Subtags | LanguageTag;\n}\n\n/**\n * Default values for a{@link Bcp47.LanguageFilterOptions}.\n * @public\n */\nexport const defaultLanguageChooserOptions: LanguageChooserOptions = Object.freeze({\n    use: 'availableLanguage',\n    filter: 'primaryLanguage',\n});\n\n/**\n * Helper to compare a list of 'desired' languages to a list of 'available' language\n * and return the intersection in order of preference, taking tag semantics into account.\n * @public\n */\nexport class LanguageChooser {\n    /**\n     * @internal\n     */\n    protected readonly _matcher: LanguageSimilarityMatcher;\n\n    public constructor(iana?: Iana.LanguageRegistries) {\n        this._matcher = new LanguageSimilarityMatcher(iana);\n    }\n\n    public chooseLanguageTagsWithDetails(\n        desiredLanguages: LanguageTag[],\n        availableLanguages: LanguageTag[],\n        options?: LanguageChooserOptions\n    ): MatchingLanguage[] {\n        const matched = new Map<string, MatchingLanguage>();\n        const decrement = desiredLanguages.length < 10 ? 0.1 : 1.0 / desiredLanguages.length;\n        let base = 1.0;\n\n        // fill any missing fields from the default\n        options = { ...defaultLanguageChooserOptions, ...options };\n\n        for (const want of desiredLanguages) {\n            base -= decrement;\n            for (const have of availableLanguages) {\n                const similarity = this._matcher.matchLanguageTags(want, have);\n                if (similarity > 0.0) {\n                    const quality = base + similarity * decrement;\n                    const languageTag = options.use === 'availableLanguage' ? have : want;\n                    const tag = languageTag.tag;\n                    const key = options.filter === 'primaryLanguage' ? languageTag.subtags.primaryLanguage ?? tag : tag;\n\n                    const match: MatchingLanguage = {\n                        quality,\n                        tag,\n                        languageTag,\n                    };\n\n                    const existing = matched.get(key);\n                    if (!existing || existing.quality < quality) {\n                        matched.set(key, match);\n                    }\n                }\n            }\n        }\n\n        const values = Array.from(matched.values());\n        if (values.length > 1) {\n            // want descending order\n            values.sort((m1, m2) => m2.quality - m1.quality);\n        } else if (values.length === 0 && options.ultimateFallback) {\n            const languageTag =\n                options.ultimateFallback instanceof LanguageTag\n                    ? options.ultimateFallback\n                    : LanguageTag.create(options.ultimateFallback).orDefault();\n            if (languageTag) {\n                return [{ languageTag, tag: languageTag.tag, quality: 0 }];\n            }\n        }\n        return values;\n    }\n\n    public filterLanguageTags(\n        desiredLanguages: LanguageTag[],\n        availableLanguages: LanguageTag[],\n        options?: LanguageChooserOptions\n    ): LanguageTag[] {\n        return this.chooseLanguageTagsWithDetails(desiredLanguages, availableLanguages, options).map((t) => t.languageTag);\n    }\n}\n"]}

package/bcp47/match/common.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Common levels of match quality for a single language match.
+ * @public
+ */
+export declare const tagSimilarity: {
+    exact: number;
+    variant: number;
+    region: number;
+    macroRegion: number;
+    neutralRegion: number;
+    preferredAffinity: number;
+    affinity: number;
+    preferredRegion: number;
+    sibling: number;
+    undetermined: number;
+    none: number;
+};
+/**
+ * Numeric representation of the quality of a language match.
+ * Range is 0 (no match) to 1 (exact match).
+ * @public
+ */
+export type TagSimilarity = keyof typeof tagSimilarity;
+//# sourceMappingURL=common.d.ts.map

package/bcp47/match/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/bcp47/match/common.ts"],"names":[],"mappings":"AAsBA;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;CAYzB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,aAAa,CAAC"}

package/bcp47/match/common.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Copyright (c) 2022 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tagSimilarity = void 0;
+/**
+ * Common levels of match quality for a single language match.
+ * @public
+ */
+exports.tagSimilarity = {
+    exact: 1.0,
+    variant: 0.9,
+    region: 0.8,
+    macroRegion: 0.7,
+    neutralRegion: 0.6,
+    preferredAffinity: 0.55,
+    affinity: 0.5,
+    preferredRegion: 0.4,
+    sibling: 0.3,
+    undetermined: 0.2,
+    none: 0,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/bcp47/match/index.d.ts

@@ -0,0 +1,4 @@
+export * from './common';
+export { LanguageSimilarityMatcher } from './similarity';
+export { MatchingLanguage, LanguageChooser as LanguageFilter, LanguageChooserOptions as LanguageFilterOptions } from './chooser';
+//# sourceMappingURL=index.d.ts.map

package/bcp47/match/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/bcp47/match/index.ts"],"names":[],"mappings":"AAuBA,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,eAAe,IAAI,cAAc,EAAE,sBAAsB,IAAI,qBAAqB,EAAE,MAAM,WAAW,CAAC"}