@memoarchitect/tools 0.6.7 → 0.7.2

package/packages/tools/lib/sysml-ir/generated/sysml-derivations.js

@@ -0,0 +1,315 @@
+// GENERATED from SysML.ecore by scripts/generate-sysml-ir.mjs. DO NOT EDIT.
+//
+// The specification OCL, verbatim, from release 2026-05 commit fa709f2.
+//
+// This is a **citation index, not an implementation**. The OCL here is spec
+// prose in a code font: it carries typos, unlabelled assignments, and empty
+// bodies at seven load-bearing operations. Nothing translates it automatically
+// (plan §1.5.1 rule 2) — the resolution core implements each clause by hand and
+// quotes it, and this module is what it quotes from.
+//
+// Kept out of `sysml-metamodel.ts` on purpose: it is roughly the same size
+// again as the structural metamodel, and only the resolution core reads it.
+/** Feature derivations, keyed `Metaclass/feature`. */
+export const SYSML_FEATURE_DERIVATIONS = {
+    "AcceptActionUsage/payloadArgument": "payloadArgument = argument(1)",
+    "AcceptActionUsage/payloadParameter": "payloadParameter = \n if parameter->isEmpty() then null\n else parameter->first() endif",
+    "AcceptActionUsage/receiverArgument": "receiverArgument = argument(2)",
+    "ActionDefinition/action": "action = usage->selectByKind(ActionUsage)",
+    "AllocationDefinition/allocation": "allocation = usage->selectAsKind(AllocationUsage)",
+    "AnalysisCaseDefinition/resultExpression": "resultExpression =\n    let results : OrderedSet(ResultExpressionMembership) =\n        featureMembersip->\n            selectByKind(ResultExpressionMembership) in\n    if results->isEmpty() then null\n    else results->first().ownedResultExpression\n    endif",
+    "AnalysisCaseUsage/resultExpression": "resultExpression =\n    let results : OrderedSet(ResultExpressionMembership) =\n        featureMembersip->\n            selectByKind(ResultExpressionMembership) in\n    if results->isEmpty() then null\n    else results->first().ownedResultExpression\n    endif",
+    "AnnotatingElement/annotatedElement": "annotatedElement = \n if annotation->notEmpty() then annotation.annotatedElement\n else Sequence{owningNamespace} endif",
+    "AnnotatingElement/annotation": "annotation = \n    if owningAnnotatingRelationship = null then ownedAnnotatingRelationship\n    else owningAnnotatingRelationship->prepend(owningAnnotatingRelationship)\n    endif",
+    "AnnotatingElement/ownedAnnotatingRelationship": "ownedAnnotatingRelationship = ownedRelationship->\n    selectByKind(Annotation)->\n    select(a | a.annotatedElement <> self)",
+    "Annotation/annotatingElement": "annotatingElement =\n    if ownedAnnotatingElement <> null then ownedAnnotatingElement\n    else owningAnnotatingElement\n    endif",
+    "Annotation/ownedAnnotatingElement": "ownedAnnotatingElement =\n    let ownedAnnotatingElements : Sequence(AnnotatingElement) = \n        ownedRelatedElement->selectByKind(AnnotatingElement) in\n    if ownedAnnotatingElements->isEmpty() then null\n    else ownedAnnotatingElements->first()\n    endif",
+    "AssertConstraintUsage/assertedConstraint": "assertedConstraint =\n    if referencedFeatureTarget() = null then self\n    else if referencedFeatureTarget().oclIsKindOf(ConstraintUsage) then\n        referencedFeatureTarget().oclAsType(ConstraintUsage)\n    else null\n    endif endif",
+    "AssignmentActionUsage/referent": "referent =\n    let unownedFeatures : Sequence(Feature) = ownedMembership->\n        reject(oclIsKindOf(FeatureMembership)).memberElement->\n        select(oclIsKindOf(Feature) and \n               not oclIsKindOf(MetadataFeature)) in\n    if unownedFeatures->isEmpty() then null\n    else unownedFeatures->first().oclAsType(Feature)\n    endif",
+    "AssignmentActionUsage/targetArgument": "targetArgument = argument(1)",
+    "AssignmentActionUsage/valueExpression": "valueExpression = argument(2)",
+    "Association/relatedType": "relatedType = associationEnd.type",
+    "Association/sourceType": "sourceType =\n    if relatedType->isEmpty() then null\n    else relatedType->first() endif",
+    "Association/targetType": "targetType =\n    if relatedType->size() < 2 then OrderedSet{}\n    else \n        relatedType->\n            subSequence(2, relatedType->size())->\n            asOrderedSet() \n    endif",
+    "Behavior/step": "step = feature->selectByKind(Step)",
+    "CalculationDefinition/calculation": "calculation = action->selectByKind(CalculationUsage)",
+    "CaseDefinition/actorParameter": "actorParameter = featureMembership->\n    selectByKind(ActorMembership).\n    ownedActorParameter",
+    "CaseDefinition/objectiveRequirement": "objectiveRequirement = \n    let objectives: OrderedSet(RequirementUsage) = \n        featureMembership->\n            selectByKind(ObjectiveMembership).\n            ownedRequirement in\n    if objectives->isEmpty() then null\n    else objectives->first().ownedObjectiveRequirement\n    endif",
+    "CaseDefinition/subjectParameter": "subjectParameter =\n    let subjectMems : OrderedSet(SubjectMembership) = \n        featureMembership->selectByKind(SubjectMembership) in\n    if subjectMems->isEmpty() then null\n    else subjectMems->first().ownedSubjectParameter\n    endif",
+    "CaseUsage/actorParameter": "actorParameter = featureMembership->\n    selectByKind(ActorMembership).\n    ownedActorParameter",
+    "CaseUsage/objectiveRequirement": "objectiveRequirement = \n    let objectives: OrderedSet(RequirementUsage) = \n        featureMembership->\n            selectByKind(ObjectiveMembership).\n            ownedRequirement in\n    if objectives->isEmpty() then null\n    else objectives->first().ownedObjectiveRequirement\n    endif",
+    "CaseUsage/subjectParameter": "subjectParameter =\n    let subjects : OrderedSet(SubjectMembership) = \n        featureMembership->selectByKind(SubjectMembership) in\n    if subjects->isEmpty() then null\n    else subjects->first().ownedSubjectParameter\n    endif",
+    "Classifier/ownedSubclassification": "ownedSubclassification = \n    ownedSpecialization->selectByKind(Subclassification)",
+    "ConjugatedPortTyping/portDefinition": "portDefinition = conjugatedPortDefinition.originalPortDefinition",
+    "Connector/relatedFeature": "relatedFeature = connectorEnd.ownedReferenceSubsetting->\n    select(s | s <> null).subsettedFeature",
+    "Connector/sourceFeature": "sourceFeature = \n    if relatedFeature->isEmpty() then null \n    else relatedFeature->first() \n    endif",
+    "Connector/targetFeature": "targetFeature =\n    if relatedFeature->size() < 2 then OrderedSet{}\n    else \n        relatedFeature->\n            subSequence(2, relatedFeature->size())->\n            asOrderedSet()\n    endif",
+    "Definition/directedUsage": "directedUsage = directedFeature->selectByKind(Usage)",
+    "Definition/ownedAction": "ownedAction = ownedUsage->selectByKind(ActionUsage)",
+    "Definition/ownedAllocation": "ownedAllocation = ownedUsage->selectByKind(AllocationUsage)",
+    "Definition/ownedAnalysisCase": "ownedAnalysisCase = ownedUsage->selectByKind(AnalysisCaseUsage)",
+    "Definition/ownedAttribute": "ownedAttribute = ownedUsage->selectByKind(AttributeUsage)",
+    "Definition/ownedCalculation": "ownedCalculation = ownedUsage->selectByKind(CalculationUsage)",
+    "Definition/ownedCase": "ownedCase = ownedUsage->selectByKind(CaseUsage)",
+    "Definition/ownedConcern": "ownedConcern = ownedUsage->selectByKind(ConcernUsage)",
+    "Definition/ownedConnection": "ownedConnection = ownedUsage->selectByKind(ConnectorAsUsage)",
+    "Definition/ownedConstraint": "ownedConstraint = ownedUsage->selectByKind(ConstraintUsage)",
+    "Definition/ownedEnumeration": "ownedEnumeration = ownedUsage->selectByKind(EnumerationUsage)",
+    "Definition/ownedFlow": "ownedFlow = ownedUsage->selectByKind(FlowUsage)",
+    "Definition/ownedInterface": "ownedInterface = ownedUsage->selectByKind(ReferenceUsage)",
+    "Definition/ownedItem": "ownedItem = ownedUsage->selectByKind(ItemUsage)",
+    "Definition/ownedMetadata": "ownedMetadata = ownedMember->selectByKind(MetadataUsage)",
+    "Definition/ownedOccurrence": "ownedOccurrence = ownedUsage->selectByKind(OccurrenceUsage)",
+    "Definition/ownedPart": "ownedPart = ownedUsage->selectByKind(PartUsage)",
+    "Definition/ownedPort": "ownedPort = ownedUsage->selectByKind(PortUsage)",
+    "Definition/ownedReference": "ownedReference = ownedUsage->selectByKind(ReferenceUsage)",
+    "Definition/ownedRendering": "ownedRendering = ownedUsage->selectByKind(RenderingUsage)",
+    "Definition/ownedRequirement": "ownedRequirement = ownedUsage->selectByKind(RequirementUsage)",
+    "Definition/ownedState": "ownedState = ownedUsage->selectByKind(StateUsage)",
+    "Definition/ownedTransition": "ownedTransition = ownedUsage->selectByKind(TransitionUsage)",
+    "Definition/ownedUsage": "ownedUsage = ownedFeature->selectByKind(Usage)",
+    "Definition/ownedUseCase": "ownedUseCase = ownedUsage->selectByKind(UseCaseUsage)",
+    "Definition/ownedVerificationCase": "ownedVerificationCase = ownedUsage->selectByKind(VerificationCaseUsage)",
+    "Definition/ownedView": "ownedView = ownedUsage->selectByKind(ViewUsage)",
+    "Definition/ownedViewpoint": "ownedViewpoint = ownedUsage->selectByKind(ViewpointUsage)",
+    "Definition/usage": "usage = feature->selectByKind(Usage)",
+    "Definition/variant": "variant = variantMembership.ownedVariantUsage",
+    "Definition/variantMembership": "variantMembership = ownedMembership->selectByKind(VariantMembership)",
+    "Element/documentation": "documentation = ownedElement->selectByKind(Documentation)",
+    "Element/isLibraryElement": "isLibraryElement = libraryNamespace() <> null",
+    "Element/name": "name = effectiveName()",
+    "Element/ownedAnnotation": "ownedAnnotation = ownedRelationship->\n    selectByKind(Annotation)->\n    select(a | a.annotatedElement = self)",
+    "Element/ownedElement": "ownedElement = ownedRelationship.ownedRelatedElement",
+    "Element/owner": "owner = owningRelationship.owningRelatedElement",
+    "Element/owningNamespace": "owningNamespace =\n    if owningMembership = null then null\n    else owningMembership.membershipOwningNamespace\n    endif",
+    "Element/qualifiedName": "qualifiedName =\n    if owningNamespace = null then null\n    else if name <> null and \n        owningNamespace.ownedMember->\n        select(m | m.name = name).indexOf(self) <> 1 then null\n    else if owningNamespace.owner = null then escapedName()\n    else if owningNamespace.qualifiedName = null or \n            escapedName() = null then null\n    else owningNamespace.qualifiedName + '::' + escapedName()\n    endif endif endif endif",
+    "Element/shortName": "shortName = effectiveShortName()",
+    "Element/textualRepresentation": "textualRepresentation = ownedElement->selectByKind(TextualRepresentation)",
+    "EventOccurrenceUsage/eventOccurrence": "eventOccurrence =\n    if referencedFeatureTarget() = null then self\n    else if referencedFeatureTarget().oclIsKindOf(OccurrenceUsage) then\n        referencedFeatureTarget().oclAsType(OccurrenceUsage)\n    else null\n    endif endif",
+    "Expression/isModelLevelEvaluable": "isModelLevelEvaluable = modelLevelEvaluable(Set(Element){})",
+    "Expression/result": "result =\n    let resultParams : Sequence(Feature) =\n        featureMemberships->\n            selectByKind(ReturnParameterMembership).\n            ownedMemberParameter in\n    if resultParams->notEmpty() then resultParams->first()\n    else null\n    endif",
+    "Feature/chainingFeature": "chainingFeature = ownedFeatureChaining.chainingFeature",
+    "Feature/crossFeature": "crossFeature =\n    if ownedCrossSubsetting = null then null\n    else \n        let chainingFeatures: Sequence(Feature) = \n            ownedCrossSubsetting.crossedFeature.chainingFeature in\n        if chainingFeatures->size() < 2 then null\n        else chainingFeatures->at(2)\n    endif",
+    "Feature/featureTarget": "featureTarget = if chainingFeature->isEmpty() then self else chainingFeature->last() endif",
+    "Feature/featuringType": "featuringType =\n    let featuringTypes : OrderedSet(Type) = \n        typeFeaturing.type->asOrderedSet() in\n    if chainingFeature->isEmpty() then featuringTypes\n    else\n        featuringTypes->\n            union(chainingFeature->first().featuringType)->\n            asOrderedSet()\n    endif",
+    "Feature/ownedCrossSubsetting": "ownedCrossSubsetting =\n    let crossSubsettings: Sequence(CrossSubsetting) = \n        ownedSubsetting->selectByKind(CrossSubsetting) in\n    if crossSubsettings->isEmpty() then null\n    else crossSubsettings->first()\n    endif",
+    "Feature/ownedFeatureChaining": "ownedFeatureChaining = ownedRelationship->selectByKind(FeatureChaining)",
+    "Feature/ownedFeatureInverting": "ownedFeatureInverting = ownedRelationship->selectByKind(FeatureInverting)->\n    select(fi | fi.featureInverted = self)",
+    "Feature/ownedRedefinition": "ownedRedefinition = ownedSubsetting->selectByKind(Redefinition)",
+    "Feature/ownedReferenceSubsetting": "ownedReferenceSubsetting =\n    let referenceSubsettings : OrderedSet(ReferenceSubsetting) =\n        ownedSubsetting->selectByKind(ReferenceSubsetting) in\n    if referenceSubsettings->isEmpty() then null\n    else referenceSubsettings->first() endif",
+    "Feature/ownedSubsetting": "ownedSubsetting = ownedSpecialization->selectByKind(Subsetting)",
+    "Feature/ownedTypeFeaturing": "ownedTypeFeaturing = ownedRelationship->selectByKind(TypeFeaturing)->\n    select(tf | tf.featureOfType = self)",
+    "Feature/ownedTyping": "ownedTyping = ownedGeneralization->selectByKind(FeatureTyping)",
+    "Feature/type": "type = \n    let types : OrderedSet(Types) = OrderedSet{self}->\n        -- Note: The closure operation automatically handles circular relationships.\n        closure(typingFeatures()).typing.type->asOrderedSet() in\n    types->reject(t1 | types->exist(t2 | t2 <> t1 and t2.specializes(t1)))",
+    "FeatureChainExpression/targetFeature": "targetFeature =\n    let nonParameterMemberships : Sequence(Membership) = ownedMembership->\n        reject(oclIsKindOf(ParameterMembership)) in\n    if nonParameterMemberships->isEmpty() or\n       not nonParameterMemberships->first().memberElement.oclIsKindOf(Feature)\n    then null\n    else nonParameterMemberships->first().memberElement.oclAsType(Feature)\n    endif",
+    "FeatureReferenceExpression/referent": "referent =\n    let nonParameterMemberships : Sequence(Membership) = ownedMembership->\n        reject(oclIsKindOf(ParameterMembership)) in\n    if nonParameterMemberships->isEmpty() or\n       not nonParameterMemberships->first().memberElement.oclIsKindOf(Feature)\n    then null\n    else nonParameterMemberships->first().memberElement.oclAsType(Feature)\n    endif",
+    "Flow/flowEnd": "flowEnd = connectorEnd->selectByKind(FlowEnd)",
+    "Flow/payloadFeature": "payloadFeature =\n    let payloadFeatures : Sequence(PayloadFeature) =\n        ownedFeature->selectByKind(PayloadFeature) in\n    if payloadFeatures->isEmpty() then null\n    else payloadFeatures->first()\n    endif",
+    "Flow/payloadType": "payloadType =\n    if payloadFeature = null then Sequence{}\n    else payloadFeature.type\n    endif",
+    "Flow/sourceOutputFeature": "sourceOutputFeature =\n    if connectorEnd->isEmpty() or \n        connectorEnd.ownedFeature->isEmpty()\n    then null\n    else connectorEnd.ownedFeature->first()\n    endif",
+    "Flow/targetInputFeature": "targetInputFeature =\n    if connectorEnd->size() < 2 or \n        connectorEnd->at(2).ownedFeature->isEmpty()\n    then null\n    else connectorEnd->at(2).ownedFeature->first()\n    endif",
+    "ForLoopActionUsage/loopVariable": "loopVariable =\n    if ownedFeature->isEmpty() or \n        not ownedFeature->first().oclIsKindOf(ReferenceUsage) then \n        null\n    else \n        ownedFeature->first().oclAsType(ReferenceUsage)\n    endif",
+    "ForLoopActionUsage/seqArgument": "seqArgument = argument(1)",
+    "Function/result": "result =\n    let resultParams : Sequence(Feature) =\n        featureMemberships->\n            selectByKind(ReturnParameterMembership).\n            ownedMemberParameter in\n    if resultParams->notEmpty() then resultParams->first()\n    else null\n    endif",
+    "IfActionUsage/elseAction": "elseAction = \n    let parameter : Feature = inputParameter(3) in\n    if parameter <> null and parameter.oclIsKindOf(ActionUsage) then\n        parameter.oclAsType(ActionUsage)\n    else\n        null\n    endif",
+    "IfActionUsage/ifArgument": "ifArgument = \n    let parameter : Feature = inputParameter(1) in\n    if parameter <> null and parameter.oclIsKindOf(Expression) then\n        parameter.oclAsType(Expression)\n    else\n        null\n    endif",
+    "IfActionUsage/thenAction": "thenAction = \n    let parameter : Feature = inputParameter(2) in\n    if parameter <> null and parameter.oclIsKindOf(ActionUsage) then\n        parameter.oclAsType(ActionUsage)\n    else\n        null\n    endif",
+    "InstantiationExpression/instantiatedType": "instantiatedType = instantiatedType()",
+    "ItemUsage/itemDefinition": "itemDefinition = occurrenceDefinition->selectByKind(Structure)",
+    "LoopActionUsage/bodyAction": "bodyAction =\n    let parameter : Feature = inputParameter(2) in\n    if parameter <> null and parameter.oclIsKindOf(Action) then\n        parameter.oclAsType(Action)\n    else\n        null\n    endif",
+    "Membership/memberElementId": "memberElementId = memberElement.elementId",
+    "MetadataAccessExpression/referencedElement": "referencedElement =\n    let elements : Sequence(Element) = ownedMembership->\n        reject(oclIsKindOf(FeatureMembership)).memberElement in\n    if elements->isEmpty() then null\n    else elements->first()\n    endif",
+    "MetadataFeature/metaclass": "metaclass = \n    let metaclassTypes : Sequence(Type) = type->selectByKind(Metaclass) in\n    if metaclassTypes->isEmpty() then null\n    else metaClassTypes->first()\n    endif",
+    "MultiplicityRange/bound": "bound =\n    if upperBound = null then Sequence{}\n    else if lowerBound = null then Sequence{upperBound}\n    else Sequence{lowerBound, upperBound}\n    endif endif",
+    "MultiplicityRange/lowerBound": "lowerBound =\n    let ownedExpressions : Sequence(Expression) =\n        ownedMember->selectByKind(Expression) in\n    if ownedExpressions->size() < 2 then null\n    else ownedExpressions->first()\n    endif",
+    "MultiplicityRange/upperBound": "upperBound =\n    let ownedExpressions : Sequence(Expression) =\n        ownedMember->selectByKind(Expression) in\n    if ownedExpressions->isEmpty() then null\n    else if ownedExpressions->size() = 1 then ownedExpressions->at(1)\n    else ownedExpressions->at(2)\n    endif endif",
+    "Namespace/importedMembership": "importedMembership = importedMemberships(Set{})",
+    "Namespace/member": "member = membership.memberElement",
+    "Namespace/ownedImport": "ownedImport = ownedRelationship->selectByKind(Import)",
+    "Namespace/ownedMember": "ownedMember = ownedMembership->selectByKind(OwningMembership).ownedMemberElement",
+    "Namespace/ownedMembership": "ownedMembership = ownedRelationship->selectByKind(Membership)",
+    "OccurrenceUsage/individualDefinition": "individualDefinition =\n    let individualDefinitions : OrderedSet(OccurrenceDefinition) = \n        occurrenceDefinition->\n            selectByKind(OccurrenceDefinition)->\n            select(isIndividual) in\n    if individualDefinitions->isEmpty() then null\n    else individualDefinitions->first() endif",
+    "OwningMembership/ownedMemberName": "ownedMemberName = ownedMemberElement.name",
+    "OwningMembership/ownedMemberShortName": "ownedMemberShortName = ownedMemberElement.shortName",
+    "Package/filterCondition": "filterCondition = ownedMembership->\n    selectByKind(ElementFilterMembership).condition",
+    "PortDefinition/conjugatedPortDefinition": "conjugatedPortDefinition =",
+    "Relationship/relatedElement": "relatedElement = source->union(target)",
+    "RenderingDefinition/rendering": "rendering = usages->selectByKind(RenderingUsage)",
+    "RequirementConstraintMembership/referencedConstraint": "referencedConstraint =\n    let referencedFeature : Feature = \n        ownedConstraint.referencedFeatureTarget() in\n    if referencedFeature = null then ownedConstraint\n    else if referencedFeature.oclIsKindOf(ConstraintUsage) then\n        refrencedFeature.oclAsType(ConstraintUsage)\n    else null\n    endif endif",
+    "RequirementDefinition/actorParameter": "actorParameter = featureMembership->\n    selectByKind(ActorMembership).\n    ownedActorParameter",
+    "RequirementDefinition/assumedConstraint": "assumedConstraint = ownedFeatureMembership->\n    selectByKind(RequirementConstraintMembership)->\n    select(kind = RequirementConstraintKind::assumption).\n    ownedConstraint",
+    "RequirementDefinition/framedConcern": "framedConcern = featureMembership->\n    selectByKind(FramedConcernMembership).\n    ownedConcern",
+    "RequirementDefinition/requiredConstraint": "requiredConstraint = ownedFeatureMembership->\n    selectByKind(RequirementConstraintMembership)->\n    select(kind = RequirementConstraintKind::requirement).\n    ownedConstraint",
+    "RequirementDefinition/stakeholderParameter": "stakeholderParameter = featureMembership->\n    selectByKind(StakholderMembership).\n    ownedStakeholderParameter",
+    "RequirementDefinition/subjectParameter": "subjectParameter =\n    let subjects : OrderedSet(SubjectMembership) = \n        featureMembership->selectByKind(SubjectMembership) in\n    if subjects->isEmpty() then null\n    else subjects->first().ownedSubjectParameter\n    endif",
+    "RequirementDefinition/text": "text = documentation.body",
+    "RequirementUsage/actorParameter": "actorParameter = featureMembership->\n    selectByKind(ActorMembership).\n    ownedActorParameter",
+    "RequirementUsage/assumedConstraint": "assumedConstraint = ownedFeatureMembership->\n    selectByKind(RequirementConstraintMembership)->\n    select(kind = RequirementConstraintKind::assumption).\n    ownedConstraint",
+    "RequirementUsage/framedConcern": "framedConcern = featureMembership->\n    selectByKind(FramedConcernMembership).\n    ownedConcern",
+    "RequirementUsage/requiredConstraint": "requiredConstraint = ownedFeatureMembership->\n    selectByKind(RequirementConstraintMembership)->\n    select(kind = RequirementConstraintKind::requirement).\n    ownedConstraint",
+    "RequirementUsage/stakeholderParameter": "stakeholderParameter = featureMembership->\n    selectByKind(AStakholderMembership).\n    ownedStakeholderParameter",
+    "RequirementUsage/subjectParameter": "subjectParameter =\n    let subjects : OrderedSet(SubjectMembership) = \n        featureMembership->selectByKind(SubjectMembership) in\n    if subjects->isEmpty() then null\n    else subjects->first().ownedSubjectParameter\n    endif",
+    "RequirementUsage/text": "text = documentation.body",
+    "SatisfyRequirementUsage/satisfyingFeature": "satisfyingFeature =\n    let bindings: BindingConnector = ownedMember->\n        selectByKind(BindingConnector)->\n        select(b | b.relatedElement->includes(subjectParameter)) in\n    if bindings->isEmpty() or \n       not bindings->first().relatedElement->exits(r | r <> subjectParameter) \n    then null\n    else bindings->first().relatedElement->any(r | r <> subjectParameter)\n    endif",
+    "SendActionUsage/payloadArgument": "payloadArgument = argument(1)",
+    "SendActionUsage/receiverArgument": "receiverArgument = argument(3)",
+    "SendActionUsage/senderArgument": "senderArgument = argument(2)",
+    "StateDefinition/doAction": "doAction =\n    let doMemberships : Sequence(StateSubactionMembership) =\n        ownedMembership->\n            selectByKind(StateSubactionMembership)->\n            select(kind = StateSubactionKind::do) in\n    if doMemberships->isEmpty() then null\n    else doMemberships->at(1)\n    endif",
+    "StateDefinition/entryAction": "entryAction =\n    let entryMemberships : Sequence(StateSubactionMembership) =\n        ownedMembership->\n            selectByKind(StateSubactionMembership)->\n            select(kind = StateSubactionKind::entry) in\n    if entryMemberships->isEmpty() then null\n    else entryMemberships->at(1)\n    endif",
+    "StateDefinition/exitAction": "exitAction = \n    let exitMemberships : Sequence(StateSubactionMembership) =\n        ownedMembership->\n            selectByKind(StateSubactionMembership)->\n            select(kind = StateSubactionKind::exit) in\n    if exitMemberships->isEmpty() then null\n    else exitMemberships->at(1)\n    endif",
+    "StateDefinition/state": "state = action->selectByKind(StateUsage)",
+    "StateUsage/doAction": "doAction =\n    let doMemberships : Sequence(StateSubactionMembership) =\n        ownedMembership->\n            selectByKind(StateSubactionMembership)->\n            select(kind = StateSubactionKind::do) in\n    if doMemberships->isEmpty() then null\n    else doMemberships->at(1)\n    endif",
+    "StateUsage/entryAction": "entryAction =\n    let entryMemberships : Sequence(StateSubactionMembership) =\n        ownedMembership->\n            selectByKind(StateSubactionMembership)->\n            select(kind = StateSubactionKind::entry) in\n    if entryMemberships->isEmpty() then null\n    else entryMemberships->at(1)\n    endif",
+    "StateUsage/exitAction": "exitAction =\n    let exitMemberships : Sequence(StateSubactionMembership) =\n        ownedMembership->\n            selectByKind(StateSubactionMembership)->\n            select(kind = StateSubactionKind::exit) in\n    if exitMemberships->isEmpty() then null\n    else exitMemberships->at(1)\n    endif",
+    "Step/behavior": "behavior = type->selectByKind(Behavior)",
+    "TerminateActionUsage/terminatedOccurrenceArgument": "terminatedOccurrenceArgument = argument(1)",
+    "TransitionUsage/guardExpression": "guardExpression = ownedFeatureMembership->\n    selectByKind(TransitionFeatureMembership)->\n    select(kind = TransitionFeatureKind::trigger).transitionFeature->\n    selectByKind(Expression)",
+    "TransitionUsage/source": "source =\n    let sourceFeature : Feature = sourceFeature() in\n    if sourceFeature = null then null\n    else sourceFeature.featureTarget.oclAsType(ActionUsage)",
+    "TransitionUsage/succession": "succession = ownedMember->selectByKind(Succession)->at(1)",
+    "TransitionUsage/target": "target =\n    if succession.targetFeature->isEmpty() then null\n    else\n        let targetFeature : Feature =\n            succession.targetFeature->first().featureTarget in\n        if not targetFeature.oclIsKindOf(ActionUsage) then null\n        else targetFeature.oclAsType(ActionUsage)\n        endif\n    endif",
+    "TransitionUsage/triggerAction": "triggerAction = ownedFeatureMembership->\n    selectByKind(TransitionFeatureMembership)->\n    select(kind = TransitionFeatureKind::trigger).transitionFeature->\n    selectByKind(AcceptActionUsage)",
+    "Type/differencingType": "differencingType = ownedDifferencing.differencingType",
+    "Type/directedFeature": "directedFeature = feature->select(f | directionOf(f) <> null)",
+    "Type/endFeature": "endFeature = feature->select(isEnd)",
+    "Type/feature": "feature = featureMembership.ownedMemberFeature",
+    "Type/featureMembership": "featureMembership = ownedFeatureMembership->union(\n    inheritedMembership->selectByKind(FeatureMembership))",
+    "Type/inheritedFeature": "inheritedFeature = inheritedMemberships->\n    selectByKind(FeatureMembership).memberFeature",
+    "Type/inheritedMembership": "inheritedMembership = inheritedMemberships(Set{}, Set{}, false)",
+    "Type/input": "input = feature->select(f | \n    let direction: FeatureDirectionKind = directionOf(f) in\n    direction = FeatureDirectionKind::_'in' or\n    direction = FeatureDirectionKind::inout)",
+    "Type/intersectingType": "intersectingType = ownedIntersecting.intersectingType",
+    "Type/multiplicity": "multiplicity = \n    let ownedMultiplicities: Sequence(Multiplicity) =\n        ownedMember->selectByKind(Multiplicity) in\n    if ownedMultiplicities->isEmpty() then null\n    else ownedMultiplicities->first()\n    endif",
+    "Type/output": "output = feature->select(f | \n    let direction: FeatureDirectionKind = directionOf(f) in\n    direction = FeatureDirectionKind::out or\n    direction = FeatureDirectionKind::inout)",
+    "Type/ownedConjugator": "ownedConjugator =\n    let ownedConjugators: Sequence(Conjugator) = \n        ownedRelationship->selectByKind(Conjugation) in\n    if ownedConjugators->isEmpty() then null \n    else ownedConjugators->at(1) endif",
+    "Type/ownedDifferencing": "ownedDifferencing =\n    ownedRelationship->selectByKind(Differencing)",
+    "Type/ownedDisjoining": "ownedDisjoining =\n    ownedRelationship->selectByKind(Disjoining)",
+    "Type/ownedEndFeature": "ownedEndFeature = ownedFeature->select(isEnd)",
+    "Type/ownedFeature": "ownedFeature = ownedFeatureMembership.ownedMemberFeature",
+    "Type/ownedFeatureMembership": "ownedFeatureMembership = ownedRelationship->selectByKind(FeatureMembership)",
+    "Type/ownedSpecialization": "ownedSpecialization = ownedRelationship->selectByKind(Specialization)->\n    select(s | s.special = self)",
+    "Type/ownedUnioning": "ownedUnioning =\n    ownedRelationship->selectByKind(Unioning)",
+    "Type/unioningType": "unioningType = ownedUnioning.unioningType",
+    "Usage/directedUsage": "directedUsage = directedFeature->selectByKind(Usage)",
+    "Usage/isReference": "isReference = not isComposite",
+    "Usage/mayTimeVary": "mayTimeVary =\n    owningType <> null and\n    owningType.specializesFromLibrary('Occurrences::Occurrence') and\n    not (\n        isPortion or\n        specializesFromLibrary('Links::SelfLink') or\n        specializesFromLibrary('Occurrences::HappensLink') or\n        isComposite and specializesFromLibrary('Actions::Action')\n    )",
+    "Usage/nestedAction": "nestedAction = nestedUsage->selectByKind(ActionUsage)",
+    "Usage/nestedAllocation": "nestedAllocation = nestedUsage->selectByKind(AllocationUsage)",
+    "Usage/nestedAnalysisCase": "nestedAnalysisCase = nestedUsage->selectByKind(AnalysisCaseUsage)",
+    "Usage/nestedAttribute": "nestedAttribute = nestedUsage->selectByKind(AttributeUsage)",
+    "Usage/nestedCalculation": "nestedCalculation = nestedUsage->selectByKind(CalculationUsage)",
+    "Usage/nestedCase": "nestedCase = nestedUsage->selectByKind(CaseUsage)",
+    "Usage/nestedConcern": "nestedConcern = nestedUsage->selectByKind(ConcernUsage)",
+    "Usage/nestedConnection": "nestedConnection = nestedUsage->selectByKind(ConnectorAsUsage)",
+    "Usage/nestedConstraint": "nestedConstraint = nestedUsage->selectByKind(ConstraintUsage)",
+    "Usage/nestedFlow": "nestedFlow = nestedUsage->selectByKind(FlowUsage)",
+    "Usage/nestedInterface": "nestedInterface = nestedUsage->selectByKind(ReferenceUsage)",
+    "Usage/nestedItem": "nestedItem = nestedUsage->selectByKind(ItemUsage)",
+    "Usage/nestedMetadata": "nestedMetadata = nestedUsage->selectByKind(MetadataUsage)",
+    "Usage/nestedOccurrence": "nestedOccurrence = nestedUsage->selectByKind(OccurrenceUsage)",
+    "Usage/nestedPart": "nestedPart = nestedUsage->selectByKind(PartUsage)",
+    "Usage/nestedPort": "nestedPort = nestedUsage->selectByKind(PortUsage)",
+    "Usage/nestedReference": "nestedReference = nestedUsage->selectByKind(ReferenceUsage)",
+    "Usage/nestedRendering": "nestedRendering = nestedUsage->selectByKind(RenderingUsage)",
+    "Usage/nestedRequirement": "nestedRequirement = nestedUsage->selectByKind(RequirementUsage)",
+    "Usage/nestedState": "nestedState = nestedUsage->selectByKind(StateUsage)",
+    "Usage/nestedTransition": "nestedTransition = nestedUsage->selectByKind(TransitionUsage)",
+    "Usage/nestedUsage": "nestedUsage = ownedFeature->selectByKind(Usage)",
+    "Usage/nestedUseCase": "nestedUseCase = nestedUsage->selectByKind(UseCaseUsage)",
+    "Usage/nestedVerificationCase": "nestedVerificationCase = nestedUsage->selectByKind(VerificationCaseUsage)",
+    "Usage/nestedView": "nestedView = nestedUsage->selectByKind(ViewUsage)",
+    "Usage/nestedViewpoint": "nestedViewpoint = nestedUsage->selectByKind(ViewpointUsage)",
+    "Usage/usage": "usage = feature->selectByKind(Usage)",
+    "Usage/variant": "variant = variantMembership.ownedVariantUsage",
+    "Usage/variantMembership": "variantMembership = ownedMembership->selectByKind(VariantMembership)",
+    "UseCaseDefinition/includedUseCase": "includedUseCase = ownedUseCase->\n    selectByKind(IncludeUseCaseUsage).\n    useCaseIncluded",
+    "UseCaseUsage/includedUseCase": "includedUseCase = ownedUseCase->\n    selectByKind(IncludeUseCaseUsage).\n    useCaseIncluded",
+    "VerificationCaseDefinition/verifiedRequirement": "verifiedRequirement =\n    if objectiveRequirement = null then OrderedSet{}\n    else \n        objectiveRequirement.featureMembership->\n            selectByKind(RequirementVerificationMembership).\n            verifiedRequirement->asOrderedSet()\n    endif",
+    "VerificationCaseUsage/verifiedRequirement": "verifiedRequirement =\n    if objectiveRequirement = null then OrderedSet{}\n    else \n        objectiveRequirement.featureMembership->\n            selectByKind(RequirementVerificationMembership).\n            verifiedRequirement->asOrderedSet()\n    endif",
+    "ViewDefinition/satisfiedViewpoint": "satisfiedViewpoint = ownedRequirement->\n    selectByKind(ViewpointUsage)->\n    select(isComposite)",
+    "ViewDefinition/view": "view = usage->selectByKind(ViewUsage)",
+    "ViewDefinition/viewCondition": "viewCondition = ownedMembership->\n    selectByKind(ElementFilterMembership).\n    condition",
+    "ViewDefinition/viewRendering": "viewRendering =\n    let renderings: OrderedSet(ViewRenderingMembership) =\n        featureMembership->selectByKind(ViewRenderingMembership) in\n    if renderings->isEmpty() then null\n    else renderings->first().referencedRendering\n    endif",
+    "ViewRenderingMembership/referencedRendering": "referencedRendering =\n    let referencedFeature : Feature = \n        ownedRendering.referencedFeatureTarget() in\n    if referencedFeature = null then ownedRendering\n    else if referencedFeature.oclIsKindOf(RenderingUsage) then\n        refrencedFeature.oclAsType(RenderingUsage)\n    else null\n    endif endif",
+    "ViewUsage/exposedElement": "exposedElement = ownedImport->selectByKind(Expose).\n    importedMemberships(Set{}).memberElement->\n    select(elm | includeAsExposed(elm))->\n    asOrderedSet()",
+    "ViewUsage/satisfiedViewpoint": "satisfiedViewpoint = ownedRequirement->\n    selectByKind(ViewpointUsage)->\n    select(isComposite)",
+    "ViewUsage/viewCondition": "viewCondition = ownedMembership->\n    selectByKind(ElementFilterMembership).\n    condition",
+    "ViewUsage/viewRendering": "viewRendering =\n    let renderings: OrderedSet(ViewRenderingMembership) =\n        featureMembership->selectByKind(ViewRenderingMembership) in\n    if renderings->isEmpty() then null\n    else renderings->first().referencedRendering\n    endif",
+    "ViewpointDefinition/viewpointStakeholder": "viewpointStakeholder = framedConcern.featureMemberhsip->\n    selectByKind(StakeholderMembership).\n    ownedStakeholderParameter",
+    "ViewpointUsage/viewpointStakeholder": "viewpointStakeholder = framedConcern.featureMemberhsip->\n    selectByKind(StakeholderMembership).\n    ownedStakeholderParameter",
+    "WhileLoopActionUsage/untilArgument": "untilArgument =\n    let parameter : Feature = inputParameter(3) in\n    if parameter <> null and parameter.oclIsKindOf(Expression) then\n        parameter.oclAsType(Expression)\n    else\n        null\n    endif",
+    "WhileLoopActionUsage/whileArgument": "whileArgument =\n    let parameter : Feature = inputParameter(1) in\n    if parameter <> null and parameter.oclIsKindOf(Expression) then\n        parameter.oclAsType(Expression)\n    else\n        null\n    endif",
+};
+/** Operation bodies, keyed `Metaclass::operation`. */
+export const SYSML_OPERATION_BODIES = {
+    "AcceptActionUsage::isTriggerAction": "owningType <> null and \nowningType.oclIsKindOf(TransitionUsage) and\nowningType.oclAsType(TransitionUsage).triggerAction->includes(self)",
+    "ActionUsage::argument": "if inputParameter(i) = null then null\nelse\n    let featureValue : Sequence(FeatureValue) = inputParameter(i).\n        ownedMembership->select(oclIsKindOf(FeatureValue)) in\n    if featureValue->isEmpty() then null\n    else featureValue->at(1).value\n    endif\nendif",
+    "ActionUsage::inputParameter": "if inputParameters()->size() < i then null\nelse inputParameters()->at(i)\nendif",
+    "ActionUsage::inputParameters": "input->select(f | f.owner = self)",
+    "ActionUsage::isSubactionUsage": "isComposite and owningType <> null and\n(owningType.oclIsKindOf(ActionDefinition) or\n owningType.oclIsKindOf(ActionUsage)) and\n(owningFeatureMembership.oclIsKindOf(StateSubactionMembership) implies\n owningFeatureMembership.oclAsType(StateSubactionMembership).kind = \n    StateSubactionKind::do)",
+    "ControlNode::multiplicityHasBounds": "mult <> null and\nif mult.oclIsKindOf(MultiplicityRange) then\n    mult.oclAsType(MultiplicityRange).hasBounds(lower, upper)\nelse\n    mult.allSuperTypes()->exists(\n        oclisKindOf(MultiplicityRange) and\n        oclAsType(MultiplicityRange).hasBounds(lower, upper)\nendif",
+    "Element::effectiveName": "declaredName",
+    "Element::effectiveShortName": "declaredShortName",
+    "Element::libraryNamespace": "if owningRelationship <> null then owningRelationship.libraryNamespace()\nelse null endif",
+    "Element::path": "if qualifiedName <> null then qualifiedName\nelse if owningRelationship <> null then\n    owningRelationship.path() + '/' + \n    owningRelationship.ownedRelatedElement->indexOf(self).toString()\n    -- A position index shall be converted to a decimal string representation \n    -- consisting of only decimal digits, with no sign, leading zeros or leading \n    -- or trailing whitespace.\nelse ''\nendif endif",
+    "Expression::checkCondition": "let results: Sequence(Element) = evaluate(target) in\n    result->size() = 1 and\n    results->first().oclIsKindOf(LiteralBoolean) and \n    results->first().oclAsType(LiteralBoolean).value",
+    "Expression::evaluate": "isModelLevelEvaluable\nlet resultExprs : Sequence(Expression) =\n    ownedFeatureMembership->\n        selectByKind(ResultExpressionMembership).\n        ownedResultExpression in\nif resultExpr->isEmpty() then Sequence{}\nelse resultExprs->first().evaluate(target)\nendif",
+    "Expression::modelLevelEvaluable": "ownedSpecialization->forAll(isImplied) and \nownedFeature->forAll(f |\n    (directionOf(f) = FeatureDirectionKind::_'in' or f = result) and\n        f.ownedFeature->isEmpty() and f.valuation = null or\n    f.owningFeatureMembership.oclIsKindOf(ResultExpressionMembership) and\n        f.oclAsType(Expression).modelLevelEvaluable(visited)",
+    "Feature::allRedefinedFeatures": "ownedRedefinition.redefinedFeature->\n    closure(ownedRedefinition.redefinedFeature)->\n    asOrderedSet()->prepend(self)",
+    "Feature::asCartesianProduct": "featuringType->select(t | t.owner <> self)->\n    union(featuringType->select(t | t.owner = self)->\n        selectByKind(Feature).asCartesianProduct())->\n    union(type)",
+    "Feature::canAccess": "let anythingType: Element =\n    subsettingFeature.resolveGlobal('Base::Anything').memberElement in\nlet allFeaturingTypes : Sequence(Type) =\n    featuringTypes->closure(t |\n        if not t.oclIsKindOf(Feature) then Sequence{}\n        else\n            let featuringTypes : OrderedSet(Type) = t.oclAsType(Feature).featuringType in\n            if featuringTypes->isEmpty() then Sequence{anythingType}\n            else featuringTypes\n            endif \n        endif) in\nallFeaturingTypes->exists(t | feature.isFeaturedWithin(t))",
+    "Feature::directionFor": "type.directionOf(self)",
+    "Feature::isCartesianProduct": "type->size() = 1 and\nfeaturingType.size() = 1 and\n(featuringType.first().owner = self implies\n    featuringType.first().oclIsKindOf(Feature) and\n    featuringType.first().oclAsType(Feature).isCartesianProduct())",
+    "Feature::isFeaturedWithin": "if type = null then\n    featuringType->forAll(f | f = resolveGlobal('Base::Anything').memberElement)\nelse\n    featuringType->forAll(f | type.isCompatibleWith(f)) or\n    isVariable and type.specializes(owningType) or\n    chainingFeature->notEmpty() and chainingFeature->first().isVariable and\n        type.specializes(chainingFeature->first().owningType)\nendif",
+    "Feature::isFeaturingType": "owningType <> null and\nif not isVariable then type = owningType\nelse if owningType = resolveGlobal('Occurrences::Occurrence').memberElement then\n    type = resolveGlobal('Occurrences::Occurrence::snapshots').memberElement \nelse \n    type.oclIsKindOf(Feature) and\n    let feature : Feature = type.oclAsType(Feature) in\n    feature.featuringType->includes(owningType) and\n    feature.redefinesFromLibrary('Occurrences::Occurrence::snapshots')\nendif",
+    "Feature::isOwnedCrossFeature": "owningNamespace <> null and \nowningNamespace.oclIsKindOf(Feature) and \nowningNamespace.oclAsType(Feature).ownedCrossFeature() = self",
+    "Feature::namingFeature": "if ownedRedefinition->isEmpty() then\n    null\nelse\n    ownedRedefinition->at(1).redefinedFeature\nendif",
+    "Feature::ownedCrossFeature": "if not isEnd or owningType = null then null\nelse\n    let ownedMemberFeatures: Sequence(Feature) =\n        ownedMember->selectByKind(Feature)->\n            reject(oclIsKindOf(Multiplicity) or \n                   oclIsKindOf(MetadataFeature) or\n                   oclIsKindOf(FeatureValue))->\n            reject(owningMembership.oclIsKindOf(FeatureMembership)) in\n    if ownedMemberFeatures.isEmpty() then null\n    else ownedMemberFeatures->first()\n    endif",
+    "Feature::redefines": "ownedRedefinition.redefinedFeature->includes(redefinedFeature)",
+    "Feature::redefinesFromLibrary": "let mem: Membership = resolveGlobal(libraryFeatureName) in\nmem <> null and mem.memberElement.oclIsKindOf(Feature) and\nredefines(mem.memberElement.oclAsType(Feature))",
+    "Feature::subsetsChain": "allSuperTypes()->selectAsKind(Feature)->\n    exists(f | let n: Integer = f.chainingFeature->size() in\n        n >= 2 and\n        f.chainingFeature->at(n-1) = first and\n        f.chainingFeature->at(n) = second)",
+    "Feature::typingFeatures": "if not isConjugated then\n    let subsettedFeatures : OrderedSet(Feature) = \n        subsetting->reject(s | s.oclIsKindOf(CrossSubsetting)).subsettedFeatures in \n    if chainingFeature->isEmpty() or\n       subsettedFeature->includes(chainingFeature->last())\n    then subsettedFeatures\n    else subsettedFeatures->append(chainingFeature->last())\n    endif\nelse if conjugator.originalType.oclIsKindOf(Feature) then\n    OrderedSet{conjugator.originalType.oclAsType(Feature)}\nelse OrderedSet{}\nendif endif",
+    "FeatureChainExpression::sourceTargetFeature": "let inputParameters : Feature = ownedFeatures->\n    select(direction = _'in') in\nif inputParameters->isEmpty() or \n   inputParameters->first().ownedFeature->isEmpty()\nthen null\nelse inputParameters->first().ownedFeature->first()\nendif",
+    "InstantiationExpression::instantiatedType": "let members : Sequence(Element) = ownedMembership->\n    reject(oclIsKindOf(FeatureMembership)).memberElement in\nif members->isEmpty() or not members->first().oclIsKindOf(Type) then null\nelse typeMembers->first().oclAsType(Type)\nendif",
+    "Membership::isDistinguishableFrom": "not (memberElement.oclKindOf(other.memberElement.oclType()) or\n     other.memberElement.oclKindOf(memberElement.oclType())) or\n(shortMemberName = null or\n    (shortMemberName <> other.shortMemberName and\n     shortMemberName <> other.memberName)) and\n(memberName = null or\n    (memberName <> other.shortMemberName and\n     memberName <> other.memberName)))",
+    "MetadataFeature::evaluateFeature": "let selectedFeatures : Sequence(Feature) = feature->\n    select(closure(ownedRedefinition.redefinedFeature)->\n           includes(baseFeature)) in\nif selectedFeatures->isEmpty() then null\nelse\n    let selectedFeature : Feature = selectedFeatures->first() in\n    let featureValues : FeatureValue = selectedFeature->\n        closure(ownedRedefinition.redefinedFeature).ownedMember->\n        selectAsKind(FeatureValue) in\n    if featureValues->isEmpty() then null\n    else featureValues->first().value.evaluate(self)\n    endif",
+    "MetadataFeature::isSemantic": "specializesFromLibrary('Metaobjects::SemanticMetadata')",
+    "MetadataFeature::isSyntactic": "specializesFromLibrary('KerML::Element')",
+    "MultiplicityRange::hasBounds": "valueOf(upperBound) = upper and\nlet lowerValue: UnlimitedNatural = valueOf(lowerBound) in\n(lowerValue = lower or\n lowerValue = null and \n    (lower = upper or \n     lower = 0 and upper = *))",
+    "MultiplicityRange::valueOf": "if bound = null or not bound.isModelLevelEvaluable then \n    null\nelse\n    let boundEval: Sequence(Element) = bound.evaluate(owningType) in\n    if boundEval->size() <> 1 then null else\n        let valueEval: Element = boundEval->at(1) in\n        if valueEval.oclIsKindOf(LiteralInfinity) then *\n        else if valueEval.oclIsKindOf(LiteralInteger) then\n            let value : Integer = \n                valueEval.oclAsKindOf(LiteralInteger).value in\n            if value >= 0 then value else null endif\n        else null\n        endif endif\n    endif\nendif",
+    "Namespace::importedMemberships": "ownedImport.importedMemberships(excluded->including(self))",
+    "Namespace::membershipsOfVisibility": "ownedMembership->\n    select(mem | visibility = null or mem.visibility = visibility)->\n    union(ownedImport->\n        select(imp | visibility = null or imp.visibility = visibility).\n        importedMemberships(excluded->including(self)))",
+    "Namespace::namesOf": "let elementMemberships : Sequence(Membership) = \n    memberships->select(memberElement = element) in\nmemberships.memberShortName->\n    union(memberships.memberName)->\n    asSet()",
+    "Namespace::resolve": "let qualification : String = qualificationOf(qualifiedName) in\nlet name : String = unqualifiedNameOf(qualifiedName) in\nif qualification = null then resolveLocal(name)\nelse if qualification = '$' then  resolveGlobal(name)\nelse \n    let namespaceMembership : Membership = resolve(qualification) in\n    if namespaceMembership = null or \n       not namespaceMembership.memberElement.oclIsKindOf(Namespace) \n    then null\n    else \n        namespaceMembership.memberElement.oclAsType(Namespace).\n        resolveVisible(name) \n    endif\nendif endif",
+    "Namespace::resolveLocal": "if owningNamespace = null then resolveGlobal(name)\nelse\n    let memberships : Membership = membership->\n        select(memberShortName = name or memberName = name) in\n    if memberships->notEmpty() then memberships->first()\n    else owningNamespace.resolveLocal(name)\n    endif\nendif",
+    "Namespace::resolveVisible": "let memberships : Sequence(Membership) =\n    visibleMemberships(Set{}, false, false)->\n    select(memberShortName = name or memberName = name) in\nif memberships->isEmpty() then null\nelse memberships->first()\nendif",
+    "Namespace::visibilityOf": "if importedMembership->includes(mem) then\n    ownedImport->\n        select(importedMemberships(Set{})->includes(mem)).\n        first().visibility\nelse if memberships->includes(mem) then\n    mem.visibility\nelse\n    VisibilityKind::private\nendif",
+    "Namespace::visibleMemberships": "let visibleMemberships : OrderedSet(Membership) = \n    if includeAll then membershipsOfVisibility(null, excluded)\n    else membershipsOfVisibility(VisibilityKind::public, excluded)\n    endif in\nif not isRecursive then visibleMemberships\nelse visibleMemberships->union(ownedMember->\n    selectAsKind(Namespace).\n    select(includeAll or owningMembership.visibility = VisibilityKind::public)->\n    visibleMemberships(excluded->including(self), true, includeAll))\nendif",
+    "Package::includeAsMember": "let metadataFeatures: Sequence(AnnotatingElement) = \n    element.ownedAnnotation.annotatingElement->\n        selectByKind(MetadataFeature) in\n    self.filterCondition->forAll(cond | \n        metadataFeatures->exists(elem | \n            cond.checkCondition(elem)))",
+    "ParameterMembership::parameterDirection": "FeatureDirectionKind::_'in'",
+    "StateUsage::isSubstateUsage": "isComposite and owningType <> null and\n(owningType.oclIsKindOf(StateDefinition) and\n    owningType.oclAsType(StateDefinition).isParallel = isParallel or\n owningType.oclIsKindOf(StateUsage) and\n    owningType.oclAsType(StateUsage).isParallel = isParallel) and\nnot owningFeatureMembership.oclIsKindOf(StateSubactionMembership)",
+    "TransitionUsage::sourceFeature": "let features : Sequence(Feature) = ownedMembership->\n    reject(oclIsKindOf(FeatureMembership)).memberElement->\n    selectByKind(Feature)->\n    select(featureTarget.oclIsKindOf(ActionUsage)) in\nif features->isEmpty() then null\nelse features->first()\nendif",
+    "TransitionUsage::triggerPayloadParameter": "if triggerAction->isEmpty() then null\nelse triggerAction->first().payloadParameter\nendif",
+    "Type::allRedefinedFeaturesOf": "if not membership.memberElement.oclIsType(Feature) then Set{} \nelse membership.memberElement.oclAsType(Feature).allRedefinedFeatures()\nendif",
+    "Type::allSupertypes": "OrderedSet{self}->closure(supertypes(false))",
+    "Type::directionOf": "directionOfExcluding(f, Set{})",
+    "Type::directionOfExcluding": "let excludedSelf : Set(Type) = excluded->including(self) in \nif feature.owningType = self then feature.direction\nelse\n    let directions : Sequence(FeatureDirectionKind) =\n        supertypes(false)->excluding(excludedSelf).\n        directionOfExcluding(feature, excludedSelf)->\n        select(d | d <> null) in\n    if directions->isEmpty() then null\n else\n    let direction : FeatureDirectionKind = directions->first() in\n    if not isConjugated then direction\n    else if direction = FeatureDirectionKind::_'in' then FeatureDirectionKind::out\n    else if direction = FeatureDirectionKind::out then FeatureDirectionKind::_'in'\n    else direction\n    endif endif endif   endif\nendif",
+    "Type::inheritableMemberships": "let excludingSelf : Set(Type) = excludedType->including(self) in\nsupertypes(excludeImplied)->reject(t | excludingSelf->includes(t)).\n    nonPrivateMemberships(excludedNamespaces, excludingSelf, excludeImplied)",
+    "Type::inheritedMemberships": "removeRedefinedFeatures(\n    inheritableMemberships(excludedNamespaces, excludedTypes, excludeImplied))",
+    "Type::isCompatibleWith": "specializes(otherType)",
+    "Type::multiplicities": "if multiplicity <> null then OrderedSet{multiplicity}\nelse \n    ownedSpecialization.general->closure(t |\n        if t.multiplicity <> null then OrderedSet{}\n        else ownedSpecialization.general\n    )->select(multiplicity <> null).multiplicity->asOrderedSet()\nendif",
+    "Type::nonPrivateMemberships": "let publicMemberships : OrderedSet(Membership) = \n    membershipsOfVisibility(VisibilityKind::public, excludedNamespaces) in\nlet protectedMemberships : OrderedSet(Membership) = \n    membershipsOfVisibility(VisibilityKind::protected, excludedNamespaces) in\nlet inheritedMemberships : OrderedSet(Membership) =\n    inheritedMemberships(excludedNamespaces, excludedTypes, excludeImplied) in\npublicMemberships->\n    union(protectedMemberships)->\n    union(inheritedMemberships)",
+    "Type::removeRedefinedFeatures": "let reducedMemberships : Sequence(Membership) =\n    memberships->reject(mem1 |\n        memberships->excluding(mem1)->\n            exists(mem2 | allRedefinedFeaturesOf(mem2)->\n                includes(mem1.memberElement))) in\nlet redefinedFeatures : Set(Feature) = \n    ownedFeature.redefinition.redefinedFeature->asSet() in\nreducedMemberships->reject(mem | allRedefinedFeaturesOf(mem)->\n    exists(feature | redefinedFeatures->includes(feature)))",
+    "Type::specializes": "if isConjugated then \n    ownedConjugator.originalType.specializes(supertype)\nelse\n    allSupertypes()->includes(supertype)\nendif",
+    "Type::specializesFromLibrary": "let mem : Membership = resolveGlobal(libraryTypeName) in\nmem <> null and mem.memberElement.oclIsKindOf(Type) and\nspecializes(mem.memberElement.oclAsType(Type))",
+    "Type::supertypes": "if isConjugated then Sequence{conjugator.originalType}\nelse if not excludeImplied then ownedSpecialization.general\nelse ownedSpecialization->reject(isImplied).general\nendif\nendif",
+    "Usage::referencedFeatureTarget": "if ownedReferenceSubsetting = null then null\nelse ownedReferenceSubsetting.referencedFeature.featureTarget\nendif",
+    "ViewUsage::includeAsExposed": "let metadataFeatures: Sequence(AnnotatingElement) = \n    element.ownedAnnotation.annotatingElement->\n        select(oclIsKindOf(MetadataFeature)) in\nself.membership->selectByKind(ElementFilterMembership).\n    condition->forAll(cond | \n        metadataFeatures->exists(elem | \n            cond.checkCondition(elem)))",
+};
+/** The clause a derived feature is implemented against, if the metamodel states one. */
+export function derivationOf(metaclass, feature) {
+    return SYSML_FEATURE_DERIVATIONS[`${metaclass}/${feature}`];
+}
+/** The clause an operation is implemented against, if the metamodel states one. */
+export function operationBodyOf(metaclass, operation) {
+    return SYSML_OPERATION_BODIES[`${metaclass}::${operation}`];
+}
+//# sourceMappingURL=sysml-derivations.js.map

package/packages/tools/lib/sysml-ir/generated/sysml-derivations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sysml-derivations.js","sourceRoot":"","sources":["../../../src/sysml-ir/generated/sysml-derivations.ts"],"names":[],"mappings":"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"}