ezmedicationinput 0.1.44 → 0.1.45

package/dist/advice.js

@@ -1,1375 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAdditionalInstructions = parseAdditionalInstructions;
-exports.findAdditionalInstructionDefinitionByCoding = findAdditionalInstructionDefinitionByCoding;
-exports.buildAdditionalInstructionFramesFromCoding = buildAdditionalInstructionFramesFromCoding;
-const advice_terminology_json_1 = __importDefault(require("./advice-terminology.json"));
-const advice_rules_json_1 = __importDefault(require("./advice-rules.json"));
-const lex_1 = require("./lexer/lex");
-const types_1 = require("./types");
-const text_1 = require("./utils/text");
-const SNOMED_SYSTEM = "http://snomed.info/sct";
-const ADVICE_TERMINOLOGY = advice_terminology_json_1.default;
-const ADVICE_RULES = advice_rules_json_1.default;
-const DEFAULT_INSTRUCTION_CONTEXT = {
-    defaultPredicate: "take",
-    defaultForce: types_1.AdviceForce.Instruction,
-    allowFreeTextFallback: false
-};
-const LEADING_NOISE_WORDS = new Set(["and", "please"]);
-const ADMINISTRATION_PREDICATES = new Set(["apply", "take", "use"]);
-const NEGATOR_WORDS = new Set(["not", "no", "dont", "don't", "mustnt", "mustn't"]);
-const VERB_CONNECTOR_WORDS = new Set(["and", "or"]);
-const SIMPLE_TIME_WORDS = new Set(["morning", "evening", "night", "bedtime"]);
-const DURATION_UNIT_WORDS = new Set([
-    "second",
-    "seconds",
-    "sec",
-    "secs",
-    "minute",
-    "minutes",
-    "min",
-    "mins",
-    "hour",
-    "hours",
-    "hr",
-    "hrs",
-    "day",
-    "days"
-]);
-const LEXEMES_BY_SURFACE = Object.create(null);
-const CONCEPTS_BY_SURFACE = Object.create(null);
-const CONCEPT_KEYS_BY_ID = Object.create(null);
-const LEXEME_LIST = [];
-const CONCEPT_LIST = [];
-let MAX_LEXEME_WORDS = 1;
-let MAX_CONCEPT_WORDS = 1;
-function normalizeAdditionalInstructionKey(value) {
-    let prepared = "";
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        const previous = index > 0 ? value[index - 1] : "";
-        const next = index + 1 < value.length ? value[index + 1] : "";
-        if (char === "." && /\d/.test(previous) && /\d/.test(next)) {
-            prepared += "decimalpoint";
-            continue;
-        }
-        prepared += char;
-    }
-    return (0, text_1.normalizeLoosePhraseKey)(prepared).replace(/decimalpoint/g, ".");
-}
-function countWords(value) {
-    if (!value) {
-        return 0;
-    }
-    let count = 0;
-    let inWord = false;
-    for (const char of value) {
-        if (char === " ") {
-            if (inWord) {
-                count += 1;
-                inWord = false;
-            }
-            continue;
-        }
-        inWord = true;
-    }
-    if (inWord) {
-        count += 1;
-    }
-    return count;
-}
-function pushLexeme(surfaceKey, entry) {
-    const bucket = LEXEMES_BY_SURFACE[surfaceKey];
-    if (bucket) {
-        bucket.push(entry);
-        return;
-    }
-    LEXEMES_BY_SURFACE[surfaceKey] = [entry];
-}
-function pushConcept(surfaceKey, entry) {
-    const bucket = CONCEPTS_BY_SURFACE[surfaceKey];
-    if (bucket) {
-        bucket.push(entry);
-        return;
-    }
-    CONCEPTS_BY_SURFACE[surfaceKey] = [entry];
-}
-function pushConceptKeyById(conceptId, surfaceKey) {
-    const bucket = CONCEPT_KEYS_BY_ID[conceptId];
-    if (bucket) {
-        bucket.push(surfaceKey);
-        return;
-    }
-    CONCEPT_KEYS_BY_ID[conceptId] = [surfaceKey];
-}
-for (const entry of ADVICE_TERMINOLOGY.lexemes) {
-    const surfaceKey = normalizeAdditionalInstructionKey(entry.surface);
-    if (!surfaceKey) {
-        continue;
-    }
-    LEXEME_LIST.push(entry);
-    pushLexeme(surfaceKey, entry);
-    const wordCount = countWords(surfaceKey);
-    if (wordCount > MAX_LEXEME_WORDS) {
-        MAX_LEXEME_WORDS = wordCount;
-    }
-}
-for (const entry of ADVICE_TERMINOLOGY.concepts) {
-    const surfaceKey = normalizeAdditionalInstructionKey(entry.surface);
-    if (!surfaceKey) {
-        continue;
-    }
-    CONCEPT_LIST.push(entry);
-    pushConcept(surfaceKey, entry);
-    pushConceptKeyById(entry.conceptId, surfaceKey);
-    const wordCount = countWords(surfaceKey);
-    if (wordCount > MAX_CONCEPT_WORDS) {
-        MAX_CONCEPT_WORDS = wordCount;
-    }
-}
-function collapseWhitespace(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
-function cleanFreeText(value) {
-    let start = 0;
-    let end = value.length;
-    while (start < end) {
-        const char = value[start];
-        if (/\s/.test(char) || char === "," || char === ";" || char === ":" || char === "-" || char === ".") {
-            start += 1;
-            continue;
-        }
-        break;
-    }
-    while (end > start) {
-        const char = value[end - 1];
-        if (/\s/.test(char) || char === "," || char === ";" || char === ":" || char === "-" || char === ".") {
-            end -= 1;
-            continue;
-        }
-        break;
-    }
-    return collapseWhitespace(value.slice(start, end));
-}
-function createDefinitionFromSource(source) {
-    return {
-        coding: {
-            system: SNOMED_SYSTEM,
-            code: source.code,
-            display: source.display
-        },
-        text: source.text,
-        i18n: { th: source.thai }
-    };
-}
-function mapAdviceForce(value) {
-    switch (value) {
-        case types_1.AdviceForce.Instruction:
-            return types_1.AdviceForce.Instruction;
-        case types_1.AdviceForce.Warning:
-            return types_1.AdviceForce.Warning;
-        case types_1.AdviceForce.Caution:
-            return types_1.AdviceForce.Caution;
-        case types_1.AdviceForce.Sequence:
-            return types_1.AdviceForce.Sequence;
-        default:
-            throw new Error(`Unsupported advice force: ${value}`);
-    }
-}
-function mapAdvicePolarity(value) {
-    if (!value) {
-        return undefined;
-    }
-    switch (value) {
-        case types_1.AdvicePolarity.Affirm:
-            return types_1.AdvicePolarity.Affirm;
-        case types_1.AdvicePolarity.Negate:
-            return types_1.AdvicePolarity.Negate;
-        default:
-            throw new Error(`Unsupported advice polarity: ${value}`);
-    }
-}
-function mapAdviceRelation(value) {
-    if (!value) {
-        return undefined;
-    }
-    switch (value) {
-        case types_1.AdviceRelation.With:
-            return types_1.AdviceRelation.With;
-        case types_1.AdviceRelation.Without:
-            return types_1.AdviceRelation.Without;
-        case types_1.AdviceRelation.Before:
-            return types_1.AdviceRelation.Before;
-        case types_1.AdviceRelation.After:
-            return types_1.AdviceRelation.After;
-        case types_1.AdviceRelation.During:
-            return types_1.AdviceRelation.During;
-        case types_1.AdviceRelation.Then:
-            return types_1.AdviceRelation.Then;
-        case types_1.AdviceRelation.Until:
-            return types_1.AdviceRelation.Until;
-        case types_1.AdviceRelation.For:
-            return types_1.AdviceRelation.For;
-        case types_1.AdviceRelation.In:
-            return types_1.AdviceRelation.In;
-        case types_1.AdviceRelation.On:
-            return types_1.AdviceRelation.On;
-        default:
-            throw new Error(`Unsupported advice relation: ${value}`);
-    }
-}
-function mapAdviceArgumentRole(value) {
-    switch (value) {
-        case types_1.AdviceArgumentRole.Theme:
-            return types_1.AdviceArgumentRole.Theme;
-        case types_1.AdviceArgumentRole.Object:
-            return types_1.AdviceArgumentRole.Object;
-        case types_1.AdviceArgumentRole.Substance:
-            return types_1.AdviceArgumentRole.Substance;
-        case types_1.AdviceArgumentRole.MealState:
-            return types_1.AdviceArgumentRole.MealState;
-        case types_1.AdviceArgumentRole.Activity:
-            return types_1.AdviceArgumentRole.Activity;
-        case types_1.AdviceArgumentRole.Material:
-            return types_1.AdviceArgumentRole.Material;
-        case types_1.AdviceArgumentRole.Site:
-            return types_1.AdviceArgumentRole.Site;
-        case types_1.AdviceArgumentRole.Amount:
-            return types_1.AdviceArgumentRole.Amount;
-        case types_1.AdviceArgumentRole.Duration:
-            return types_1.AdviceArgumentRole.Duration;
-        case types_1.AdviceArgumentRole.Time:
-            return types_1.AdviceArgumentRole.Time;
-        case types_1.AdviceArgumentRole.Free:
-            return types_1.AdviceArgumentRole.Free;
-        default:
-            throw new Error(`Unsupported advice argument role: ${value}`);
-    }
-}
-function buildAdviceFrameTemplateArgument(source) {
-    return {
-        role: mapAdviceArgumentRole(source.role),
-        text: source.text,
-        conceptId: source.conceptId
-    };
-}
-function buildAdviceFrameTemplate(source) {
-    const args = [];
-    for (const arg of source.args) {
-        args.push(buildAdviceFrameTemplateArgument(arg));
-    }
-    return {
-        force: mapAdviceForce(source.force),
-        polarity: mapAdvicePolarity(source.polarity),
-        predicate: {
-            lemma: source.predicate.lemma,
-            semanticClass: source.predicate.semanticClass
-        },
-        relation: mapAdviceRelation(source.relation),
-        args
-    };
-}
-function buildAdviceArgConceptMatcher(source) {
-    return {
-        conceptIds: source.conceptIds.slice(),
-        role: source.role ? mapAdviceArgumentRole(source.role) : undefined
-    };
-}
-function buildAdviceFrameMatcher(source) {
-    const argConcepts = [];
-    if (source.argConcepts) {
-        for (const argConcept of source.argConcepts) {
-            argConcepts.push(buildAdviceArgConceptMatcher(argConcept));
-        }
-    }
-    const relations = [];
-    if (source.relations) {
-        for (const relation of source.relations) {
-            const mapped = mapAdviceRelation(relation);
-            if (mapped) {
-                relations.push(mapped);
-            }
-        }
-    }
-    return {
-        predicateLemmas: source.predicateLemmas ? source.predicateLemmas.slice() : undefined,
-        predicateSemanticClasses: source.predicateSemanticClasses
-            ? source.predicateSemanticClasses.slice()
-            : undefined,
-        relations: relations.length ? relations : undefined,
-        force: source.force ? mapAdviceForce(source.force) : undefined,
-        polarity: mapAdvicePolarity(source.polarity),
-        argConcepts: argConcepts.length ? argConcepts : undefined
-    };
-}
-function buildAdviceMatcher(source) {
-    if ("allOf" in source) {
-        const allOf = [];
-        for (const item of source.allOf) {
-            allOf.push(buildAdviceMatcher(item));
-        }
-        return { allOf };
-    }
-    if ("anyOf" in source) {
-        const anyOf = [];
-        for (const item of source.anyOf) {
-            anyOf.push(buildAdviceMatcher(item));
-        }
-        return { anyOf };
-    }
-    if ("not" in source) {
-        return { not: buildAdviceMatcher(source.not) };
-    }
-    if ("frame" in source) {
-        return { frame: buildAdviceFrameMatcher(source.frame) };
-    }
-    if ("argConcept" in source) {
-        return { argConcept: buildAdviceArgConceptMatcher(source.argConcept) };
-    }
-    const normalizedTexts = [];
-    for (const value of source.normalizedTexts) {
-        const normalized = normalizeAdditionalInstructionKey(value);
-        if (normalized) {
-            normalizedTexts.push(normalized);
-        }
-    }
-    return { normalizedTexts };
-}
-function buildAdviceCodingRule(source) {
-    const frames = [];
-    for (const frame of source.frames) {
-        frames.push(buildAdviceFrameTemplate(frame));
-    }
-    return {
-        id: source.id,
-        definition: createDefinitionFromSource(source.definition),
-        frames,
-        matcher: buildAdviceMatcher(source.matcher)
-    };
-}
-const ADDITIONAL_INSTRUCTION_RULES = [];
-for (const sourceRule of ADVICE_RULES.rules) {
-    ADDITIONAL_INSTRUCTION_RULES.push(buildAdviceCodingRule(sourceRule));
-}
-function frameHasArgConcept(frame, matcher) {
-    for (const arg of frame.args) {
-        if (matcher.role && arg.role !== matcher.role) {
-            continue;
-        }
-        for (const conceptId of matcher.conceptIds) {
-            if (arg.conceptId === conceptId) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function frameMatches(frame, matcher) {
-    if (matcher.force && frame.force !== matcher.force) {
-        return false;
-    }
-    if (matcher.polarity && frame.polarity !== matcher.polarity) {
-        return false;
-    }
-    if (matcher.relations) {
-        let relationMatched = false;
-        for (const relation of matcher.relations) {
-            if (frame.relation === relation) {
-                relationMatched = true;
-                break;
-            }
-        }
-        if (!relationMatched) {
-            return false;
-        }
-    }
-    if (matcher.predicateLemmas) {
-        let predicateMatched = false;
-        for (const lemma of matcher.predicateLemmas) {
-            if (frame.predicate.lemma === lemma) {
-                predicateMatched = true;
-                break;
-            }
-        }
-        if (!predicateMatched) {
-            return false;
-        }
-    }
-    if (matcher.predicateSemanticClasses) {
-        let semanticClassMatched = false;
-        for (const semanticClass of matcher.predicateSemanticClasses) {
-            if (frame.predicate.semanticClass === semanticClass) {
-                semanticClassMatched = true;
-                break;
-            }
-        }
-        if (!semanticClassMatched) {
-            return false;
-        }
-    }
-    if (matcher.argConcepts) {
-        for (const argConcept of matcher.argConcepts) {
-            if (!frameHasArgConcept(frame, argConcept)) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-function matchesAdviceMatcher(frames, normalizedText, matcher) {
-    if ("allOf" in matcher) {
-        for (const item of matcher.allOf) {
-            if (!matchesAdviceMatcher(frames, normalizedText, item)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if ("anyOf" in matcher) {
-        for (const item of matcher.anyOf) {
-            if (matchesAdviceMatcher(frames, normalizedText, item)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    if ("not" in matcher) {
-        return !matchesAdviceMatcher(frames, normalizedText, matcher.not);
-    }
-    if ("frame" in matcher) {
-        for (const frame of frames) {
-            if (frameMatches(frame, matcher.frame)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    if ("argConcept" in matcher) {
-        for (const frame of frames) {
-            if (frameHasArgConcept(frame, matcher.argConcept)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    for (const value of matcher.normalizedTexts) {
-        if (normalizedText === value) {
-            return true;
-        }
-    }
-    return false;
-}
-function findRuleByCoding(system, code) {
-    var _a, _b;
-    for (const rule of ADDITIONAL_INSTRUCTION_RULES) {
-        if (((_a = rule.definition.coding) === null || _a === void 0 ? void 0 : _a.system) !== system) {
-            continue;
-        }
-        if (((_b = rule.definition.coding) === null || _b === void 0 ? void 0 : _b.code) !== code) {
-            continue;
-        }
-        return rule;
-    }
-    return undefined;
-}
-function createArgument(role, text, normalized, conceptId) {
-    return {
-        role,
-        text,
-        normalized,
-        conceptId
-    };
-}
-function createFrame(sourceText, span, force, predicateLemma, predicateSemanticClass, args, sequenceIndex, relation, polarity, modality) {
-    return {
-        force,
-        polarity,
-        modality,
-        predicate: {
-            lemma: predicateLemma,
-            semanticClass: predicateSemanticClass
-        },
-        relation,
-        args,
-        span,
-        sourceText,
-        sequenceIndex
-    };
-}
-function instantiateTemplateFrames(templates, sourceText, span) {
-    const frames = [];
-    let index = 0;
-    for (const template of templates) {
-        const args = [];
-        for (const templateArg of template.args) {
-            args.push(createArgument(templateArg.role, templateArg.text, normalizeAdditionalInstructionKey(templateArg.text), templateArg.conceptId));
-        }
-        frames.push(createFrame(sourceText, span, template.force, template.predicate.lemma, template.predicate.semanticClass, args, index, template.relation, template.polarity));
-        index += 1;
-    }
-    return frames;
-}
-function findNormalizedLexeme(surface, partOfSpeech) {
-    const key = normalizeAdditionalInstructionKey(surface);
-    const bucket = LEXEMES_BY_SURFACE[key];
-    if (!bucket) {
-        return undefined;
-    }
-    for (const entry of bucket) {
-        if (partOfSpeech && entry.partOfSpeech !== partOfSpeech) {
-            continue;
-        }
-        return entry;
-    }
-    return undefined;
-}
-function findContainedConcept(normalized) {
-    let best;
-    let bestLength = 0;
-    for (const entry of CONCEPT_LIST) {
-        const key = normalizeAdditionalInstructionKey(entry.surface);
-        if (!key) {
-            continue;
-        }
-        if (normalized !== key && !normalized.includes(key)) {
-            continue;
-        }
-        if (key.length <= bestLength) {
-            continue;
-        }
-        best = entry;
-        bestLength = key.length;
-    }
-    return best;
-}
-function findExactConcept(normalized) {
-    const bucket = CONCEPTS_BY_SURFACE[normalized];
-    if (!bucket) {
-        return undefined;
-    }
-    for (const entry of bucket) {
-        return entry;
-    }
-    return undefined;
-}
-function findVerbLexeme(word) {
-    return findNormalizedLexeme(word, "verb");
-}
-function findVerbLemma(word) {
-    var _a;
-    return (_a = findVerbLexeme(word)) === null || _a === void 0 ? void 0 : _a.lemma;
-}
-function findModalLexeme(word) {
-    const entry = findNormalizedLexeme(word, "modifier");
-    if (!entry || entry.semanticClass !== "modal") {
-        return undefined;
-    }
-    return entry;
-}
-function mapModalLemmaToModality(lemma) {
-    switch (lemma) {
-        case types_1.AdviceModality.May:
-            return types_1.AdviceModality.May;
-        case types_1.AdviceModality.Can:
-            return types_1.AdviceModality.Can;
-        case types_1.AdviceModality.Might:
-            return types_1.AdviceModality.Might;
-        case types_1.AdviceModality.Could:
-            return types_1.AdviceModality.Could;
-        case types_1.AdviceModality.Should:
-            return types_1.AdviceModality.Should;
-        case types_1.AdviceModality.Must:
-            return types_1.AdviceModality.Must;
-        default:
-            return undefined;
-    }
-}
-function containsConceptId(normalized, conceptId) {
-    const keys = CONCEPT_KEYS_BY_ID[conceptId];
-    if (!keys) {
-        return false;
-    }
-    for (const key of keys) {
-        if (normalized === key || normalized.includes(key)) {
-            return true;
-        }
-    }
-    return false;
-}
-function containsVerbLemma(words, lemma) {
-    for (const word of words) {
-        if (findVerbLemma(word) === lemma) {
-            return true;
-        }
-    }
-    return false;
-}
-function containsVerbSequence(words, leadLemma, targetLemma) {
-    for (let index = 0; index + 1 < words.length; index += 1) {
-        if (findVerbLemma(words[index]) !== leadLemma) {
-            continue;
-        }
-        if (findVerbLemma(words[index + 1]) === targetLemma) {
-            return true;
-        }
-    }
-    return false;
-}
-function consumeNegationPrefix(words, start) {
-    if (start >= words.length) {
-        return undefined;
-    }
-    const first = words[start];
-    const second = start + 1 < words.length ? words[start + 1] : undefined;
-    switch (first) {
-        case "do":
-            return second === "not" ? start + 2 : undefined;
-        case "don":
-            return second === "t" ? start + 2 : undefined;
-        case "must":
-            return second === "not" ? start + 2 : undefined;
-        case "mustn":
-            return second === "t" ? start + 2 : undefined;
-        default:
-            return NEGATOR_WORDS.has(first) ? start + 1 : undefined;
-    }
-}
-function parseLeadingClauseFeatures(words) {
-    let cursor = skipLeadingNoise(words);
-    if (cursor >= words.length) {
-        return undefined;
-    }
-    let modality;
-    const modalLexeme = findModalLexeme(words[cursor]);
-    if (modalLexeme) {
-        modality = mapModalLemmaToModality(modalLexeme.lemma);
-        cursor += 1;
-    }
-    if (cursor >= words.length) {
-        return { cursor, modality };
-    }
-    const negationEnd = consumeNegationPrefix(words, cursor);
-    if (negationEnd === undefined) {
-        return {
-            cursor,
-            modality
-        };
-    }
-    switch (words[cursor]) {
-        case "mustn":
-            modality = types_1.AdviceModality.Must;
-            break;
-        default:
-            break;
-    }
-    return {
-        cursor: negationEnd,
-        modality,
-        polarity: types_1.AdvicePolarity.Negate
-    };
-}
-function deriveClauseForce(sequenceCount, context, predicateLemma, predicateSemanticClass, polarity, modality) {
-    var _a;
-    if (sequenceCount > 1) {
-        return types_1.AdviceForce.Sequence;
-    }
-    switch (predicateSemanticClass) {
-        case "effect":
-            return types_1.AdviceForce.Warning;
-        default:
-            break;
-    }
-    switch (modality) {
-        case types_1.AdviceModality.May:
-        case types_1.AdviceModality.Can:
-        case types_1.AdviceModality.Might:
-        case types_1.AdviceModality.Could:
-            return types_1.AdviceForce.Warning;
-        case types_1.AdviceModality.Should:
-            return types_1.AdviceForce.Caution;
-        default:
-            break;
-    }
-    switch (predicateLemma) {
-        case "avoid":
-            return types_1.AdviceForce.Warning;
-        default:
-            break;
-    }
-    switch (polarity) {
-        case types_1.AdvicePolarity.Negate:
-            return types_1.AdviceForce.Warning;
-        default:
-            break;
-    }
-    return (_a = context.defaultForce) !== null && _a !== void 0 ? _a : types_1.AdviceForce.Instruction;
-}
-function containsNegatedVerb(words, lemma) {
-    for (let index = 0; index < words.length; index += 1) {
-        const nextIndex = consumeNegationPrefix(words, index);
-        if (nextIndex !== undefined && nextIndex < words.length && findVerbLemma(words[nextIndex]) === lemma) {
-            return true;
-        }
-    }
-    return false;
-}
-function mapSemanticClassToRole(semanticClass) {
-    switch (semanticClass) {
-        case "meal_state":
-            return types_1.AdviceArgumentRole.MealState;
-        case "activity":
-            return types_1.AdviceArgumentRole.Activity;
-        case "material":
-            return types_1.AdviceArgumentRole.Material;
-        case "site":
-            return types_1.AdviceArgumentRole.Site;
-        case "amount_style":
-            return types_1.AdviceArgumentRole.Amount;
-        case "manner_style":
-            return types_1.AdviceArgumentRole.Free;
-        case "duration":
-            return types_1.AdviceArgumentRole.Duration;
-        case "time":
-            return types_1.AdviceArgumentRole.Time;
-        case "substance":
-            return types_1.AdviceArgumentRole.Substance;
-        default:
-            return types_1.AdviceArgumentRole.Object;
-    }
-}
-function classifyArgument(text) {
-    const cleaned = cleanFreeText(text);
-    const normalized = normalizeAdditionalInstructionKey(cleaned);
-    if (!normalized) {
-        return createArgument(types_1.AdviceArgumentRole.Free, cleaned, normalized);
-    }
-    const concept = findContainedConcept(normalized);
-    if (concept) {
-        return createArgument(mapSemanticClassToRole(concept.semanticClass), cleaned, normalized, concept.conceptId);
-    }
-    const parts = normalized.split(" ");
-    if (parts.length >= 2) {
-        const first = parts[0];
-        const second = parts[1];
-        if (/^[0-9]+(?:\.[0-9]+)?$/.test(first) && DURATION_UNIT_WORDS.has(second)) {
-            return createArgument(types_1.AdviceArgumentRole.Duration, cleaned, normalized);
-        }
-    }
-    if (SIMPLE_TIME_WORDS.has(normalized)) {
-        return createArgument(types_1.AdviceArgumentRole.Time, cleaned, normalized, normalized);
-    }
-    return createArgument(types_1.AdviceArgumentRole.Object, cleaned, normalized);
-}
-function trimSegment(text, start, end) {
-    while (start < end) {
-        const char = text[start];
-        if (/\s/.test(char) || char === "," || char === ";" || char === ":" || char === "-" || char === ".") {
-            start += 1;
-            continue;
-        }
-        break;
-    }
-    while (end > start) {
-        const char = text[end - 1];
-        if (/\s/.test(char) || char === "," || char === ";" || char === ":" || char === "-" || char === ".") {
-            end -= 1;
-            continue;
-        }
-        break;
-    }
-    if (end <= start) {
-        return undefined;
-    }
-    return {
-        text: text.slice(start, end),
-        range: { start, end }
-    };
-}
-function splitInstructionSegments(sourceText, baseRange) {
-    const segments = [];
-    let segmentStart = 0;
-    for (let index = 0; index < sourceText.length; index++) {
-        const char = sourceText[index];
-        if (char !== ";" && char !== "." && char !== "\n" && char !== "\r") {
-            continue;
-        }
-        if (char === ".") {
-            const previous = index > 0 ? sourceText[index - 1] : "";
-            const next = index + 1 < sourceText.length ? sourceText[index + 1] : "";
-            if (/\d/.test(previous) && /\d/.test(next)) {
-                continue;
-            }
-        }
-        const trimmed = trimSegment(sourceText, segmentStart, index);
-        if (trimmed) {
-            segments.push({
-                text: trimmed.text,
-                range: {
-                    start: baseRange.start + trimmed.range.start,
-                    end: baseRange.start + trimmed.range.end
-                }
-            });
-        }
-        segmentStart = index + 1;
-    }
-    const finalTrimmed = trimSegment(sourceText, segmentStart, sourceText.length);
-    if (finalTrimmed) {
-        segments.push({
-            text: finalTrimmed.text,
-            range: {
-                start: baseRange.start + finalTrimmed.range.start,
-                end: baseRange.start + finalTrimmed.range.end
-            }
-        });
-    }
-    if (segments.length) {
-        return segments;
-    }
-    const single = trimSegment(sourceText, 0, sourceText.length);
-    if (!single) {
-        return [];
-    }
-    return [
-        {
-            text: single.text,
-            range: {
-                start: baseRange.start + single.range.start,
-                end: baseRange.start + single.range.end
-            }
-        }
-    ];
-}
-function splitSequenceSegments(sourceText, baseRange) {
-    const tokens = (0, lex_1.lexInput)(sourceText);
-    if (!tokens.length) {
-        return [];
-    }
-    const segments = [];
-    let segmentStart = 0;
-    for (const token of tokens) {
-        if (normalizeAdditionalInstructionKey(token.original) !== "then") {
-            continue;
-        }
-        const trimmed = trimSegment(sourceText, segmentStart, token.sourceStart);
-        if (trimmed) {
-            segments.push({
-                text: trimmed.text,
-                range: {
-                    start: baseRange.start + trimmed.range.start,
-                    end: baseRange.start + trimmed.range.end
-                }
-            });
-        }
-        segmentStart = token.sourceEnd;
-    }
-    const finalTrimmed = trimSegment(sourceText, segmentStart, sourceText.length);
-    if (finalTrimmed) {
-        segments.push({
-            text: finalTrimmed.text,
-            range: {
-                start: baseRange.start + finalTrimmed.range.start,
-                end: baseRange.start + finalTrimmed.range.end
-            }
-        });
-    }
-    if (segments.length > 1) {
-        return segments;
-    }
-    return [
-        {
-            text: sourceText,
-            range: baseRange
-        }
-    ];
-}
-function isKnownVerb(word) {
-    const entry = findNormalizedLexeme(word, "verb");
-    return Boolean(entry);
-}
-function isAdministrationWord(word) {
-    return ADMINISTRATION_PREDICATES.has(word);
-}
-function isRelationWord(word) {
-    const entry = findNormalizedLexeme(word, "relation");
-    if (!entry) {
-        return undefined;
-    }
-    switch (entry.lemma) {
-        case "with":
-            return types_1.AdviceRelation.With;
-        case "without":
-            return types_1.AdviceRelation.Without;
-        case "before":
-            return types_1.AdviceRelation.Before;
-        case "after":
-            return types_1.AdviceRelation.After;
-        case "during":
-            return types_1.AdviceRelation.During;
-        case "then":
-            return types_1.AdviceRelation.Then;
-        case "until":
-            return types_1.AdviceRelation.Until;
-        case "for":
-            return types_1.AdviceRelation.For;
-        case "in":
-            return types_1.AdviceRelation.In;
-        case "on":
-            return types_1.AdviceRelation.On;
-        default:
-            return undefined;
-    }
-}
-function parseAdviceRelation(value) {
-    switch (value) {
-        case types_1.AdviceRelation.With:
-            return types_1.AdviceRelation.With;
-        case types_1.AdviceRelation.Without:
-            return types_1.AdviceRelation.Without;
-        case types_1.AdviceRelation.Before:
-            return types_1.AdviceRelation.Before;
-        case types_1.AdviceRelation.After:
-            return types_1.AdviceRelation.After;
-        case types_1.AdviceRelation.During:
-            return types_1.AdviceRelation.During;
-        case types_1.AdviceRelation.Then:
-            return types_1.AdviceRelation.Then;
-        case types_1.AdviceRelation.Until:
-            return types_1.AdviceRelation.Until;
-        case types_1.AdviceRelation.For:
-            return types_1.AdviceRelation.For;
-        case types_1.AdviceRelation.In:
-            return types_1.AdviceRelation.In;
-        case types_1.AdviceRelation.On:
-            return types_1.AdviceRelation.On;
-        default:
-            return undefined;
-    }
-}
-function normalizeWords(text) {
-    const normalized = normalizeAdditionalInstructionKey(text);
-    if (!normalized) {
-        return [];
-    }
-    return normalized.split(" ");
-}
-function skipLeadingNoise(words) {
-    let cursor = 0;
-    while (cursor < words.length && LEADING_NOISE_WORDS.has(words[cursor])) {
-        cursor += 1;
-    }
-    if (cursor + 1 < words.length &&
-        isAdministrationWord(words[cursor]) &&
-        isRelationWord(words[cursor + 1])) {
-        cursor += 1;
-    }
-    if (cursor + 2 < words.length &&
-        /^[0-9]+(?:\.[0-9]+)?$/.test(words[cursor]) &&
-        DURATION_UNIT_WORDS.has(words[cursor + 1]) &&
-        isRelationWord(words[cursor + 2])) {
-        cursor += 2;
-    }
-    return cursor;
-}
-function createDefaultForce(sequenceCount, sequenceIndex, context) {
-    var _a;
-    if (sequenceCount > 1 || sequenceIndex > 0) {
-        return types_1.AdviceForce.Sequence;
-    }
-    return (_a = context.defaultForce) !== null && _a !== void 0 ? _a : types_1.AdviceForce.Instruction;
-}
-function tryParseRelationInstruction(sourceText, span, context, sequenceIndex, sequenceCount) {
-    const words = normalizeWords(sourceText);
-    if (!words.length) {
-        return undefined;
-    }
-    let cursor = skipLeadingNoise(words);
-    const relation = cursor < words.length ? isRelationWord(words[cursor]) : undefined;
-    if (!relation) {
-        return undefined;
-    }
-    cursor += 1;
-    if (cursor >= words.length) {
-        return undefined;
-    }
-    const objectText = words.slice(cursor).join(" ");
-    if (!objectText) {
-        return undefined;
-    }
-    const force = createDefaultForce(sequenceCount, sequenceIndex, context);
-    const args = [classifyArgument(objectText)];
-    return [
-        createFrame(sourceText, span, force, context.defaultPredicate, "administration", args, sequenceIndex, relation)
-    ];
-}
-function tryParseImplicitConceptInstruction(sourceText, span, context, sequenceIndex, sequenceCount) {
-    const words = normalizeWords(sourceText);
-    if (!words.length) {
-        return undefined;
-    }
-    const cursor = skipLeadingNoise(words);
-    if (cursor >= words.length) {
-        return undefined;
-    }
-    if (isRelationWord(words[cursor]) || isKnownVerb(words[cursor])) {
-        return undefined;
-    }
-    const conceptText = words.slice(cursor).join(" ");
-    if (!conceptText) {
-        return undefined;
-    }
-    const concept = findExactConcept(conceptText);
-    if (!concept) {
-        return undefined;
-    }
-    const relation = parseAdviceRelation(concept.implicitRelation);
-    if (!relation) {
-        return undefined;
-    }
-    return [
-        createFrame(sourceText, span, createDefaultForce(sequenceCount, sequenceIndex, context), context.defaultPredicate, "administration", [
-            createArgument(mapSemanticClassToRole(concept.semanticClass), conceptText, conceptText, concept.conceptId)
-        ], sequenceIndex, relation)
-    ];
-}
-function parseEmbeddedAvoidanceFrames(words, normalized, sourceText, span, sequenceIndex, sequenceCount) {
-    const frames = [];
-    const force = sequenceCount > 1 ? types_1.AdviceForce.Sequence : types_1.AdviceForce.Warning;
-    if (containsConceptId(normalized, "alcohol") &&
-        (containsVerbLemma(words, "avoid") ||
-            containsNegatedVerb(words, "drink") ||
-            (words.length >= 2 && words[0] === "no"))) {
-        frames.push(createFrame(sourceText, span, force, "avoid", "avoidance", [createArgument(types_1.AdviceArgumentRole.Substance, "alcohol", "alcohol", "alcohol")], sequenceIndex));
-    }
-    if (containsVerbSequence(words, "avoid", "drive") || containsNegatedVerb(words, "drive")) {
-        frames.push(createFrame(sourceText, span, force, "drive", "activity", [], sequenceIndex, undefined, types_1.AdvicePolarity.Negate));
-    }
-    return frames;
-}
-function tryParseNoObjectInstruction(sourceText, span, sequenceIndex, sequenceCount) {
-    const words = normalizeWords(sourceText);
-    if (words.length < 2) {
-        return undefined;
-    }
-    const cursor = skipLeadingNoise(words);
-    if (cursor >= words.length || words[cursor] !== "no") {
-        return undefined;
-    }
-    const objectText = words.slice(cursor + 1).join(" ");
-    const argument = classifyArgument(objectText);
-    if (argument.role === types_1.AdviceArgumentRole.Substance) {
-        return [
-            createFrame(sourceText, span, sequenceCount > 1 ? types_1.AdviceForce.Sequence : types_1.AdviceForce.Warning, "drink", "ingest", [argument], sequenceIndex, undefined, types_1.AdvicePolarity.Negate)
-        ];
-    }
-    const objectWords = normalizeWords(objectText);
-    if (objectWords.length === 1) {
-        const verbLexeme = findVerbLexeme(objectWords[0]);
-        if (verbLexeme) {
-            return [
-                createFrame(sourceText, span, sequenceCount > 1 ? types_1.AdviceForce.Sequence : types_1.AdviceForce.Warning, verbLexeme.lemma, verbLexeme.semanticClass, [], sequenceIndex, undefined, types_1.AdvicePolarity.Negate)
-            ];
-        }
-    }
-    return undefined;
-}
-function tryParseStyleInstruction(sourceText, span, context, sequenceIndex, sequenceCount) {
-    const normalized = normalizeAdditionalInstructionKey(sourceText);
-    if (!normalized) {
-        return undefined;
-    }
-    let styleText = normalized;
-    if (normalized.startsWith("apply ")) {
-        styleText = normalized.slice("apply ".length);
-    }
-    const lexeme = findNormalizedLexeme(styleText);
-    if (!lexeme ||
-        (lexeme.semanticClass !== "amount_style" && lexeme.semanticClass !== "manner_style")) {
-        return undefined;
-    }
-    const concept = findContainedConcept(styleText);
-    return [
-        createFrame(sourceText, span, createDefaultForce(sequenceCount, sequenceIndex, context), context.defaultPredicate, "administration", [
-            createArgument(mapSemanticClassToRole(lexeme.semanticClass), styleText, styleText, concept === null || concept === void 0 ? void 0 : concept.conceptId)
-        ], sequenceIndex)
-    ];
-}
-function tryParseClauseInstruction(sourceText, span, context, sequenceIndex, sequenceCount) {
-    const words = normalizeWords(sourceText);
-    if (!words.length) {
-        return undefined;
-    }
-    const prefix = parseLeadingClauseFeatures(words);
-    if (!prefix || prefix.cursor >= words.length) {
-        return undefined;
-    }
-    const verbEntries = [];
-    let remainderStart = prefix.cursor;
-    while (remainderStart < words.length) {
-        const verbEntry = findVerbLexeme(words[remainderStart]);
-        if (!verbEntry) {
-            break;
-        }
-        verbEntries.push(verbEntry);
-        remainderStart += 1;
-        if (remainderStart < words.length &&
-            VERB_CONNECTOR_WORDS.has(words[remainderStart]) &&
-            remainderStart + 1 < words.length &&
-            isKnownVerb(words[remainderStart + 1])) {
-            remainderStart += 1;
-            continue;
-        }
-        break;
-    }
-    if (!verbEntries.length) {
-        return undefined;
-    }
-    let relation;
-    const args = [];
-    const remainderWords = words.slice(remainderStart);
-    const primaryVerb = verbEntries[0];
-    switch (primaryVerb.lemma) {
-        case "leave":
-            if (remainderWords[0] === "on") {
-                args.push(createArgument(types_1.AdviceArgumentRole.Theme, "on", "on"));
-                if (remainderWords.length > 1) {
-                    const nextRelation = isRelationWord(remainderWords[1]);
-                    if (nextRelation) {
-                        relation = nextRelation;
-                        const afterRelation = remainderWords.slice(2).join(" ");
-                        if (afterRelation) {
-                            args.push(classifyArgument(afterRelation));
-                        }
-                    }
-                    else {
-                        const tail = remainderWords.slice(1).join(" ");
-                        if (tail) {
-                            args.push(classifyArgument(tail));
-                        }
-                    }
-                }
-                break;
-            }
-            relation = remainderWords.length ? isRelationWord(remainderWords[0]) : undefined;
-            {
-                const objectText = remainderWords.slice(relation ? 1 : 0).join(" ");
-                if (objectText) {
-                    args.push(classifyArgument(objectText));
-                }
-            }
-            break;
-        default:
-            relation = remainderWords.length ? isRelationWord(remainderWords[0]) : undefined;
-            {
-                const objectText = remainderWords.slice(relation ? 1 : 0).join(" ");
-                if (objectText) {
-                    args.push(classifyArgument(objectText));
-                }
-            }
-            break;
-    }
-    if (!args.length &&
-        !relation &&
-        ADMINISTRATION_PREDICATES.has(primaryVerb.lemma)) {
-        return undefined;
-    }
-    const frames = [];
-    for (const verbEntry of verbEntries) {
-        frames.push(createFrame(sourceText, span, deriveClauseForce(sequenceCount, context, verbEntry.lemma, verbEntry.semanticClass, prefix.polarity, prefix.modality), verbEntry.lemma, verbEntry.semanticClass, args, sequenceIndex, relation, prefix.polarity, prefix.modality));
-    }
-    if (frames.length === 1 &&
-        frames[0].predicate.lemma === "cause" &&
-        frames[0].args.length === 1 &&
-        frames[0].args[0].conceptId === "drowsiness") {
-        const embedded = parseEmbeddedAvoidanceFrames(words, words.join(" "), sourceText, span, sequenceIndex, sequenceCount);
-        if (embedded.length) {
-            for (const frame of embedded) {
-                frames.push(frame);
-            }
-        }
-    }
-    return frames;
-}
-function parseSequenceFrames(sourceText, span, context) {
-    var _a, _b, _c, _d;
-    const sequenceSegments = splitSequenceSegments(sourceText, span);
-    if (!sequenceSegments.length) {
-        return [];
-    }
-    const frames = [];
-    for (let index = 0; index < sequenceSegments.length; index++) {
-        const segment = sequenceSegments[index];
-        const parsed = (_d = (_c = (_b = (_a = tryParseRelationInstruction(segment.text, segment.range, context, index, sequenceSegments.length)) !== null && _a !== void 0 ? _a : tryParseImplicitConceptInstruction(segment.text, segment.range, context, index, sequenceSegments.length)) !== null && _b !== void 0 ? _b : tryParseStyleInstruction(segment.text, segment.range, context, index, sequenceSegments.length)) !== null && _c !== void 0 ? _c : tryParseNoObjectInstruction(segment.text, segment.range, index, sequenceSegments.length)) !== null && _d !== void 0 ? _d : tryParseClauseInstruction(segment.text, segment.range, context, index, sequenceSegments.length);
-        if (!parsed) {
-            return [];
-        }
-        for (const frame of parsed) {
-            frames.push(frame);
-        }
-    }
-    return frames;
-}
-function matchAdviceCodingRule(frames, normalizedText) {
-    for (const rule of ADDITIONAL_INSTRUCTION_RULES) {
-        if (matchesAdviceMatcher(frames, normalizedText, rule.matcher)) {
-            return rule;
-        }
-    }
-    return undefined;
-}
-function cloneDefinitionCoding(coding, i18n) {
-    if (!(coding === null || coding === void 0 ? void 0 : coding.code) && !(coding === null || coding === void 0 ? void 0 : coding.display) && !(coding === null || coding === void 0 ? void 0 : coding.system)) {
-        return undefined;
-    }
-    return {
-        code: coding.code,
-        display: coding.display,
-        system: coding.system,
-        i18n
-    };
-}
-function shouldAllowFallbackText(sourceText, allowFreeTextFallback) {
-    return Boolean(allowFreeTextFallback && cleanFreeText(sourceText));
-}
-function capitalizeSentence(value) {
-    if (!value) {
-        return value;
-    }
-    return value.charAt(0).toUpperCase() + value.slice(1);
-}
-function realizeAdviceModality(modality) {
-    switch (modality) {
-        case types_1.AdviceModality.May:
-            return "May";
-        case types_1.AdviceModality.Can:
-            return "Can";
-        case types_1.AdviceModality.Might:
-            return "Might";
-        case types_1.AdviceModality.Could:
-            return "Could";
-        case types_1.AdviceModality.Should:
-            return "Should";
-        case types_1.AdviceModality.Must:
-            return "Must";
-        default:
-            return undefined;
-    }
-}
-function joinAdviceArgumentTexts(args) {
-    let text = "";
-    let added = 0;
-    for (const arg of args) {
-        const trimmed = cleanFreeText(arg.text);
-        if (!trimmed) {
-            continue;
-        }
-        if (added > 0) {
-            text += added === 1 ? " and " : ", ";
-        }
-        text += trimmed;
-        added += 1;
-    }
-    return text || undefined;
-}
-function realizeSingleAdviceFrame(frame) {
-    const argText = joinAdviceArgumentTexts(frame.args);
-    const modalityText = realizeAdviceModality(frame.modality);
-    switch (frame.polarity) {
-        case types_1.AdvicePolarity.Negate: {
-            let text = `${modalityText === "Must" ? "Must not" : "Do not"} ${frame.predicate.lemma}`;
-            if (frame.relation) {
-                text += ` ${frame.relation}`;
-            }
-            if (argText) {
-                text += ` ${argText}`;
-            }
-            return text;
-        }
-        default:
-            break;
-    }
-    switch (frame.predicate.lemma) {
-        case "avoid":
-            if (!modalityText) {
-                return argText ? `Avoid ${argText}` : "Avoid";
-            }
-            return argText ? `${modalityText} avoid ${argText}` : `${modalityText} avoid`;
-        case "cause":
-            if (!modalityText) {
-                return argText ? "May cause " + argText : "May cause";
-            }
-            return argText ? `${modalityText} cause ${argText}` : `${modalityText} cause`;
-        default: {
-            let text = modalityText ? `${modalityText} ${frame.predicate.lemma}` : capitalizeSentence(frame.predicate.lemma);
-            if (frame.relation) {
-                text += ` ${frame.relation}`;
-            }
-            if (argText) {
-                text += ` ${argText}`;
-            }
-            return text;
-        }
-    }
-}
-function realizeAdviceFramesText(frames) {
-    if (frames.length !== 1) {
-        return undefined;
-    }
-    const realized = realizeSingleAdviceFrame(frames[0]);
-    return realized ? capitalizeSentence(realized) : undefined;
-}
-function parseAdditionalInstructions(sourceText, span, context) {
-    var _a, _b, _c, _d, _e;
-    const effectiveContext = {
-        defaultPredicate: (_a = context === null || context === void 0 ? void 0 : context.defaultPredicate) !== null && _a !== void 0 ? _a : DEFAULT_INSTRUCTION_CONTEXT.defaultPredicate,
-        defaultForce: (_b = context === null || context === void 0 ? void 0 : context.defaultForce) !== null && _b !== void 0 ? _b : DEFAULT_INSTRUCTION_CONTEXT.defaultForce,
-        allowFreeTextFallback: (_c = context === null || context === void 0 ? void 0 : context.allowFreeTextFallback) !== null && _c !== void 0 ? _c : DEFAULT_INSTRUCTION_CONTEXT.allowFreeTextFallback
-    };
-    const instructions = [];
-    const segments = splitInstructionSegments(sourceText, span);
-    for (const segment of segments) {
-        const cleanedText = cleanFreeText(segment.text);
-        if (!cleanedText) {
-            continue;
-        }
-        const normalizedText = normalizeAdditionalInstructionKey(cleanedText);
-        const frames = parseSequenceFrames(cleanedText, segment.range, effectiveContext);
-        const rule = normalizedText
-            ? matchAdviceCodingRule(frames, normalizedText)
-            : undefined;
-        if (frames.length || rule) {
-            const realizedText = rule ? undefined : realizeAdviceFramesText(frames);
-            instructions.push({
-                text: (_e = (_d = rule === null || rule === void 0 ? void 0 : rule.definition.text) !== null && _d !== void 0 ? _d : realizedText) !== null && _e !== void 0 ? _e : cleanedText,
-                coding: cloneDefinitionCoding(rule === null || rule === void 0 ? void 0 : rule.definition.coding, rule === null || rule === void 0 ? void 0 : rule.definition.i18n),
-                frames
-            });
-            continue;
-        }
-        if (!shouldAllowFallbackText(cleanedText, effectiveContext.allowFreeTextFallback)) {
-            continue;
-        }
-        instructions.push({
-            text: cleanedText,
-            frames: []
-        });
-    }
-    return instructions;
-}
-function findAdditionalInstructionDefinitionByCoding(system, code) {
-    var _a;
-    return (_a = findRuleByCoding(system, code)) === null || _a === void 0 ? void 0 : _a.definition;
-}
-function buildAdditionalInstructionFramesFromCoding(system, code, sourceText, span) {
-    var _a, _b, _c;
-    const rule = findRuleByCoding(system, code);
-    if (!rule) {
-        return undefined;
-    }
-    const resolvedText = (_c = (_a = sourceText !== null && sourceText !== void 0 ? sourceText : rule.definition.text) !== null && _a !== void 0 ? _a : (_b = rule.definition.coding) === null || _b === void 0 ? void 0 : _b.display) !== null && _c !== void 0 ? _c : "";
-    const resolvedSpan = span !== null && span !== void 0 ? span : { start: 0, end: resolvedText.length };
-    return instantiateTemplateFrames(rule.frames, resolvedText, resolvedSpan);
-}