LibAcc: 0.8378=155/185, ProjAcc: 0.6154=32/52, Missing: 126

Module: memento/demo

function 𝓟1{show} (): (𝓟2: 𝓛[ty]10033{Void})
{
 let 𝓟3{state}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 let 𝓟4{originator}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟3{state});
 let 𝓟5{careTaker}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟5{careTaker}.Memento ⟵ 𝓟4{originator}.createMemento();
 𝓟4{originator}.State ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 𝓟4{originator}.setMemento(𝓟5{careTaker}.Memento)
}

Module: memento/memento

function 𝓟6{CONSTRUCTOR} (𝓟7{str}: 𝓛[ty]10051{String}): (𝓟[ty]11{State})
{
 const 𝓟[ty]11{State};
 const 𝓟[ty]11{State};
 𝓟[ty]11{State}.str ⟵ 𝓟7{str};
}
class 𝓟[ty]11{State}{
 𝓟13{str}: 𝓛[ty]10051{String};
 function 𝓟16{Str} (𝓟17{str}: 𝓛[ty]10051{String}): (𝓟18)
 {
 𝓟[ty]11{State}.str ⟵ 𝓟17{str};
 }
}
function 𝓟19{CONSTRUCTOR} (𝓟20{state}: 𝓟[ty]11{State}): (𝓟[ty]24{Originator})
{
 const 𝓟[ty]24{Originator};
 const 𝓟[ty]24{Originator};
 𝓟[ty]24{Originator}.state ⟵ 𝓟20{state};
}
class 𝓟[ty]24{Originator}{
 𝓟26{state}: (𝓛[ty]8655{Number} ≠ 𝓟[ty]11{State});
 function 𝓟29{State} (𝓟30{state}: 𝓟[ty]11{State}): (𝓟31)
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟30{state})
 𝓟[ty]24{Originator}.state ⟵ 𝓟30{state};
 }
 function 𝓟32{createMemento} (): (𝓟33: 𝓟[ty]42{Memento})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 return 𝓟33 = 𝓟37{CONSTRUCTOR}(𝓟[ty]24{Originator}.state)
 }
 function 𝓟34{setMemento} (𝓟35{memento}: 𝓟[ty]42{Memento}): (𝓟36: [miss]𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]24{Originator}.State ⟵ 𝓟35{memento}.State;
 }
}
function 𝓟37{CONSTRUCTOR} (𝓟38{state}: 𝓟[ty]11{State}): (𝓟[ty]42{Memento})
{
 const 𝓟[ty]42{Memento};
 const 𝓟[ty]42{Memento};
 𝓟[ty]42{Memento}.state ⟵ 𝓟38{state};
}
class 𝓟[ty]42{Memento}{
 𝓟44{state}: 𝓟[ty]11{State};
 function 𝓟45{State} (): (𝓟46: (𝓟[ty]42{Memento} ≠ 𝓟[ty]11{State}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 return 𝓟46 = 𝓟[ty]42{Memento}.state
 }
}
function 𝓟47{CONSTRUCTOR} (): (𝓟[ty]51{CareTaker})
{
 const 𝓟[ty]51{CareTaker};
 const 𝓟[ty]51{CareTaker};
}
class 𝓟[ty]51{CareTaker}{
 𝓟53{memento}: 𝓟[ty]42{Memento};
 function 𝓟56{Memento} (𝓟57{memento}: 𝓟[ty]42{Memento}): (𝓟58)
 {
 𝓟[ty]51{CareTaker}.memento ⟵ 𝓟57{memento};
 }
}

Module: flyweight/demo

function 𝓟59{show} (): (𝓟60: 𝓛[ty]10033{Void})
{
 let 𝓟61{factory}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟62{conc1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟61{factory}.getFlyweight(𝓛8743{String}) as 𝓛[ty]2{<UNKNOWN>};
 let 𝓟63{conc2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟61{factory}.getFlyweight(𝓛8743{String}) as 𝓛[ty]2{<UNKNOWN>};
 𝓟62{conc1}.operation(𝓛8743{String})
 𝓟63{conc2}.operation(𝓛8743{String})
}

Module: adapter/demo

function 𝓟64{show} (): (𝓟65: 𝓛[ty]10033{Void})
{
 let 𝓟66{adapter}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟66{adapter}.call()
}

Module: proxy/proxy

type 𝓟[ty]67{Subject} = {doAction: ()->𝓛[ty]10033{Void}}
function 𝓟68{CONSTRUCTOR} (𝓟69{s}: (𝓟[ty]900{Objs} ≠ 𝓛[ty]10051{String})): (𝓟[ty]73{Proxy})
{
 const 𝓟[ty]73{Proxy};
 const 𝓟[ty]73{Proxy};
 𝓟[ty]73{Proxy}.s ⟵ 𝓟69{s};
}
class 𝓟[ty]73{Proxy} extends 𝓟[ty]67{Subject}{
 𝓟75{realSubject}: 𝓟[ty]84{RealSubject};
 𝓟76{s}: 𝓛[ty]10051{String};
 function 𝓟77{doAction} (): (𝓟78: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]73{Proxy}.s,𝓛8743{String})
 if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]73{Proxy}.realSubject,𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]73{Proxy}.realSubject,𝓛12643{undefined})))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]73{Proxy}.realSubject ⟵ 𝓟79{CONSTRUCTOR}(𝓟[ty]73{Proxy}.s);
 }
 𝓟[ty]73{Proxy}.realSubject.doAction()
 }
}
function 𝓟79{CONSTRUCTOR} (𝓟80{s}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String})): (𝓟[ty]84{RealSubject})
{
 const 𝓟[ty]84{RealSubject};
 const 𝓟[ty]84{RealSubject};
 𝓟[ty]84{RealSubject}.s ⟵ 𝓟80{s};
}
class 𝓟[ty]84{RealSubject} extends 𝓟[ty]67{Subject}{
 𝓟86{s}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String});
 function 𝓟87{doAction} (): (𝓟88: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]84{RealSubject}.s,𝓛8743{String})
 }
}

Module: iterator/demo

function 𝓟89{show} (): (𝓟90: 𝓛[ty]10033{Void})
{
 let 𝓟91{nArray}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
 let 𝓟92{numbers}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟91{nArray});
 let 𝓟93{it}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓟92{numbers}.createIterator() as 𝓛[ty]2{<UNKNOWN>};
 while (𝓟93{it}.hasNext())
 {
 𝓛1{<UNKNOWN>}(𝓟93{it}.next())
 }
}

Module: template_method/demo

function 𝓟94{show} (): (𝓟95: 𝓛[ty]10033{Void})
{
 let 𝓟96{c1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟97{c2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟96{c1}.templateMethod()
 𝓟97{c2}.templateMethod()
}

Module: command/command

function 𝓟98{CONSTRUCTOR} (): (𝓟[ty]102{Command})
{
 const 𝓟[ty]102{Command};
 const 𝓟[ty]102{Command};
}
class 𝓟[ty]102{Command}{
 function 𝓟104{execute} (): (𝓟105: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
}
function 𝓟106{CONSTRUCTOR} (𝓟107{receiver}: 𝓟[ty]140{Receiver}): (𝓟[ty]111{ConcreteCommand1})
{
 const 𝓟[ty]111{ConcreteCommand1};
 const 𝓟[ty]111{ConcreteCommand1};
 𝓟[ty]111{ConcreteCommand1}()
 𝓟[ty]111{ConcreteCommand1}.receiver ⟵ 𝓟107{receiver};
}
class 𝓟[ty]111{ConcreteCommand1} extends 𝓟[ty]102{Command}{
 𝓟113{receiver}: 𝓟[ty]140{Receiver};
 function 𝓟114{execute} (): (𝓟115: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]111{ConcreteCommand1}.receiver.action()
 }
}
function 𝓟116{CONSTRUCTOR} (𝓟117{receiver}: 𝓟[ty]140{Receiver}): (𝓟[ty]121{ConcreteCommand2})
{
 const 𝓟[ty]121{ConcreteCommand2};
 const 𝓟[ty]121{ConcreteCommand2};
 𝓟[ty]121{ConcreteCommand2}()
 𝓟[ty]121{ConcreteCommand2}.receiver ⟵ 𝓟117{receiver};
}
class 𝓟[ty]121{ConcreteCommand2} extends 𝓟[ty]102{Command}{
 𝓟123{receiver}: 𝓟[ty]140{Receiver};
 function 𝓟124{execute} (): (𝓟125: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]121{ConcreteCommand2}.receiver.action()
 }
}
function 𝓟126{CONSTRUCTOR} (): (𝓟[ty]130{Invoker})
{
 const 𝓟[ty]130{Invoker};
 const 𝓟[ty]130{Invoker};
 𝓟[ty]130{Invoker}.commands ⟵ 𝓛8757{Array}();
}
class 𝓟[ty]130{Invoker}{
 𝓟132{commands}: 𝓛[ty]8670{Array};
 function 𝓟133{storeAndExecute} (𝓟134{cmd}: (𝓟[ty]51{CareTaker} ≠ 𝓟[ty]102{Command})): (𝓟135: [miss]𝓛[ty]10033{Void})
 {
 𝓟[ty]130{Invoker}.commands.push(𝓟134{cmd})
 𝓟134{cmd}.execute()
 }
}
function 𝓟136{CONSTRUCTOR} (): (𝓟[ty]140{Receiver})
{
 const 𝓟[ty]140{Receiver};
 const 𝓟[ty]140{Receiver};
}
class 𝓟[ty]140{Receiver}{
 function 𝓟142{action} (): (𝓟143: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟144{main} (): (𝓟145: [miss]𝓛[ty]10033{Void})
{
 let 𝓟146{receiver}: 𝓟[ty]140{Receiver} = 𝓟136{CONSTRUCTOR}();
 let 𝓟147{command1}: (𝓟[ty]121{ConcreteCommand2} ≠ 𝓟[ty]102{Command}) = 𝓟106{CONSTRUCTOR}(𝓟146{receiver});
 let 𝓟148{command2}: (𝓟[ty]121{ConcreteCommand2} ≠ 𝓟[ty]102{Command}) = 𝓟116{CONSTRUCTOR}(𝓟146{receiver});
 let 𝓟149{invoker}: 𝓟[ty]130{Invoker} = 𝓟126{CONSTRUCTOR}();
 𝓟149{invoker}.storeAndExecute(𝓟147{command1})
 𝓟149{invoker}.storeAndExecute(𝓟148{command2})
}
𝓟144{main}()

Module: singleton/singleton

const 𝓟150{singleton}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]157{Singleton}) = 𝓛12643{undefined};
function 𝓟151{CONSTRUCTOR} (): (𝓟[ty]157{Singleton})
{
 const 𝓟[ty]157{Singleton};
 const 𝓟[ty]157{Singleton};
}
function 𝓟155{Instance} (): (𝓟156: (𝓟[ty]575{Decorator} ≠ 𝓟[ty]157{Singleton}))
{
 if (𝓛12599{EqualsEqualsToken}(𝓟[ty]157{Singleton}.singleton,𝓛12643{undefined}))
 {
 𝓟[ty]157{Singleton}.singleton ⟵ 𝓟151{CONSTRUCTOR}();
 }
 return 𝓟156 = 𝓟[ty]157{Singleton}.singleton
}
class 𝓟[ty]157{Singleton}{
}

Module: command/demo

function 𝓟159{show} (): (𝓟160: 𝓛[ty]10033{Void})
{
 let 𝓟161{receiver}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟162{command1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟161{receiver});
 let 𝓟163{command2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟161{receiver});
 let 𝓟164{invoker}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟164{invoker}.storeAndExecute(𝓟162{command1})
 𝓟164{invoker}.storeAndExecute(𝓟163{command2})
}

Module: state/demo

function 𝓟165{show} (): (𝓟166: 𝓛[ty]10033{Void})
{
 let 𝓟167{context}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛1{<UNKNOWN>}.CONSTRUCTOR());
 𝓟167{context}.request()
 𝓟167{context}.request()
 𝓟167{context}.request()
 𝓟167{context}.request()
 𝓟167{context}.request()
 𝓟167{context}.request()
 𝓟167{context}.request()
 𝓟167{context}.request()
}

Module: factory_method/factoryMethod

type 𝓟[ty]168{AbstractProduct} = {method: (any)->𝓛[ty]10033{Void}}
function 𝓟169{CONSTRUCTOR} (): (𝓟[ty]176{ConcreteProductA})
{
 const 𝓟[ty]176{ConcreteProductA};
 const 𝓟[ty]176{ConcreteProductA};
 function 𝓟173{$Lambda5} (𝓟174{param}: [OOV]any): (𝓟175: [miss]𝓛[ty]10051{String})
 {
 return 𝓟175 = 𝓛8743{String}
 }
 𝓟[ty]176{ConcreteProductA}.method ⟵ 𝓟173{$Lambda5};
}
class 𝓟[ty]176{ConcreteProductA} extends 𝓟[ty]168{AbstractProduct}{
 𝓟178{method}: [miss]𝓛[ty]8696{Function};
}
function 𝓟179{CONSTRUCTOR} (): (𝓟[ty]186{ConcreteProductB})
{
 const 𝓟[ty]186{ConcreteProductB};
 const 𝓟[ty]186{ConcreteProductB};
 function 𝓟183{$Lambda6} (𝓟184{param}: [OOV]any): (𝓟185: [miss]𝓛[ty]10051{String})
 {
 return 𝓟185 = 𝓛8743{String}
 }
 𝓟[ty]186{ConcreteProductB}.method ⟵ 𝓟183{$Lambda6};
}
class 𝓟[ty]186{ConcreteProductB} extends 𝓟[ty]168{AbstractProduct}{
 𝓟188{method}: [miss]𝓛[ty]8696{Function};
}
function 𝓟189{CONSTRUCTOR} (): (𝓟[ty]196{ProductFactory})
{
 const 𝓟[ty]196{ProductFactory};
 const 𝓟[ty]196{ProductFactory};
}
function 𝓟193{createProduct} (𝓟194{type}: 𝓛[ty]10051{String}): (𝓟195: [OOV]𝓟[ty]168{AbstractProduct})
{
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟194{type},𝓛8743{String}))
 {
 return 𝓟195 = 𝓟169{CONSTRUCTOR}()
 }
 else
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟194{type},𝓛8743{String}))
 {
 return 𝓟195 = 𝓟179{CONSTRUCTOR}()
 }
 }
 return 𝓟195 = 𝓛12643{undefined}
}
class 𝓟[ty]196{ProductFactory}{
}

Module: interpreter/demo

function 𝓟198{show} (): (𝓟199: 𝓛[ty]10033{Void})
{
 let 𝓟200{context}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟201{list}: [miss]𝓛[ty]8670{Array} = 𝓛8757{Array}();
 let 𝓟202{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 let 𝓟203{max};
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟201{list}.push(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 {
 𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}(𝓟202{i},𝓛8745{Number}),𝓛1{<UNKNOWN>}(𝓟203{max},𝓟201{list}.length))
 while (𝓛1{<UNKNOWN>}(𝓟202{i},𝓟203{max}))
 {
 {
 𝓟201{list}.access(𝓟202{i}).interpret(𝓟200{context})
 }
 𝓛12564{FirstCompoundAssignment}(𝓟202{i},𝓛8745{Number})
 }
 }
}

Module: strategy/strategy

type 𝓟[ty]204{Strategy} = {execute: ()->𝓛[ty]10033{Void}}
function 𝓟205{CONSTRUCTOR} (): (𝓟[ty]209{ConcreteStrategy1})
{
 const 𝓟[ty]209{ConcreteStrategy1};
 const 𝓟[ty]209{ConcreteStrategy1};
}
class 𝓟[ty]209{ConcreteStrategy1} extends 𝓟[ty]204{Strategy}{
 function 𝓟211{execute} (): (𝓟212: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟213{CONSTRUCTOR} (): (𝓟[ty]217{ConcreteStrategy2})
{
 const 𝓟[ty]217{ConcreteStrategy2};
 const 𝓟[ty]217{ConcreteStrategy2};
}
class 𝓟[ty]217{ConcreteStrategy2} extends 𝓟[ty]204{Strategy}{
 function 𝓟219{execute} (): (𝓟220: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟221{CONSTRUCTOR} (): (𝓟[ty]225{ConcreteStrategy3})
{
 const 𝓟[ty]225{ConcreteStrategy3};
 const 𝓟[ty]225{ConcreteStrategy3};
}
class 𝓟[ty]225{ConcreteStrategy3} extends 𝓟[ty]204{Strategy}{
 function 𝓟227{execute} (): (𝓟228: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟229{CONSTRUCTOR} (𝓟230{strategy}: [OOV]𝓟[ty]204{Strategy}): (𝓟[ty]234{Context})
{
 const 𝓟[ty]234{Context};
 const 𝓟[ty]234{Context};
 𝓟[ty]234{Context}.strategy ⟵ 𝓟230{strategy};
}
class 𝓟[ty]234{Context}{
 𝓟236{strategy}: [OOV]𝓟[ty]204{Strategy};
 function 𝓟237{executeStrategy} (): (𝓟238: 𝓛[ty]10033{Void})
 {
 𝓟[ty]234{Context}.strategy.execute()
 }
}

Module: abstract_factory/demo

function 𝓟239{show} (): (𝓟240: [miss]𝓛[ty]10033{Void})
{
 let 𝓟241{factory1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟242{tester1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟241{factory1});
 𝓟242{tester1}.test()
 let 𝓟243{factory2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟244{tester2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟243{factory2});
 𝓟244{tester2}.test()
}

Module: singleton/demo

function 𝓟245{show} (): (𝓟246: 𝓛[ty]10033{Void})
{
 let 𝓟247{singleton1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.Instance();
 let 𝓟248{singleton2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.Instance();
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟247{singleton1},𝓟248{singleton2}))
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 else
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}

Module: prototype/prototype

type 𝓟[ty]249{Prototype} = {clone: ()->𝓟[ty]249{Prototype}, toString: ()->𝓛[ty]10051{String}}
function 𝓟250{CONSTRUCTOR} (): (𝓟[ty]254{Concrete1})
{
 const 𝓟[ty]254{Concrete1};
 const 𝓟[ty]254{Concrete1};
}
class 𝓟[ty]254{Concrete1} extends 𝓟[ty]249{Prototype}{
 function 𝓟256{clone} (): (𝓟257: [OOV]𝓟[ty]249{Prototype})
 {
 return 𝓟257 = 𝓟250{CONSTRUCTOR}()
 }
 function 𝓟258{toString} (): (𝓟259: 𝓛[ty]10051{String})
 {
 return 𝓟259 = 𝓛8743{String}
 }
}
function 𝓟260{CONSTRUCTOR} (): (𝓟[ty]264{Concrete2})
{
 const 𝓟[ty]264{Concrete2};
 const 𝓟[ty]264{Concrete2};
}
class 𝓟[ty]264{Concrete2} extends 𝓟[ty]249{Prototype}{
 function 𝓟266{clone} (): (𝓟267: [OOV]𝓟[ty]249{Prototype})
 {
 return 𝓟267 = 𝓟260{CONSTRUCTOR}()
 }
 function 𝓟268{toString} (): (𝓟269: 𝓛[ty]10051{String})
 {
 return 𝓟269 = 𝓛8743{String}
 }
}
function 𝓟270{CONSTRUCTOR} (): (𝓟[ty]274{Concrete3})
{
 const 𝓟[ty]274{Concrete3};
 const 𝓟[ty]274{Concrete3};
}
class 𝓟[ty]274{Concrete3} extends 𝓟[ty]249{Prototype}{
 function 𝓟276{clone} (): (𝓟277: [OOV]𝓟[ty]249{Prototype})
 {
 return 𝓟277 = 𝓟270{CONSTRUCTOR}()
 }
 function 𝓟278{toString} (): (𝓟279: 𝓛[ty]10051{String})
 {
 return 𝓟279 = 𝓛8743{String}
 }
}
function 𝓟280{CONSTRUCTOR} (): (𝓟[ty]284{Builder})
{
 const 𝓟[ty]284{Builder};
 const 𝓟[ty]284{Builder};
 𝓟[ty]284{Builder}.prototypeMap ⟵ {};
 𝓟[ty]284{Builder}.prototypeMap.access(𝓛8743{String}) ⟵ 𝓟250{CONSTRUCTOR}();
 𝓟[ty]284{Builder}.prototypeMap.access(𝓛8743{String}) ⟵ 𝓟260{CONSTRUCTOR}();
 𝓟[ty]284{Builder}.prototypeMap.access(𝓛8743{String}) ⟵ 𝓟270{CONSTRUCTOR}();
}
class 𝓟[ty]284{Builder}{
 𝓟286{prototypeMap}: 𝓛[ty]8642{Object};
 function 𝓟287{createOne} (𝓟288{s}: 𝓛[ty]10051{String}): (𝓟289: [OOV]𝓟[ty]249{Prototype})
 {
 𝓛1{<UNKNOWN>}(𝓟288{s})
 return 𝓟289 = 𝓟[ty]284{Builder}.prototypeMap.access(𝓟288{s}).clone()
 }
}

Module: flyweight/flyweight

type 𝓟[ty]290{Flyweight} = {operation: (𝓛[ty]10051{String})->𝓛[ty]10033{Void}}
function 𝓟291{CONSTRUCTOR} (𝓟292{instrinsicState}: (𝓟[ty]11{State} ≠ 𝓛[ty]10051{String})): (𝓟[ty]296{ConcreteFlyweight})
{
 const 𝓟[ty]296{ConcreteFlyweight};
 const 𝓟[ty]296{ConcreteFlyweight};
 𝓟[ty]296{ConcreteFlyweight}.instrinsicState ⟵ 𝓟292{instrinsicState};
}
class 𝓟[ty]296{ConcreteFlyweight} extends 𝓟[ty]290{Flyweight}{
 𝓟298{instrinsicState}: 𝓛[ty]10051{String};
 function 𝓟299{operation} (𝓟300{s}: 𝓛[ty]10051{String}): (𝓟301: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟300{s},𝓛8743{String})
 }
}
function 𝓟302{CONSTRUCTOR} (𝓟303{allState}: (𝓟[ty]11{State} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]307{UnsharedConcreteFlyweight})
{
 const 𝓟[ty]307{UnsharedConcreteFlyweight};
 const 𝓟[ty]307{UnsharedConcreteFlyweight};
 𝓟[ty]307{UnsharedConcreteFlyweight}.allState ⟵ 𝓟303{allState};
}
class 𝓟[ty]307{UnsharedConcreteFlyweight} extends 𝓟[ty]290{Flyweight}{
 𝓟309{allState}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
 function 𝓟310{operation} (𝓟311{s}: 𝓛[ty]10051{String}): (𝓟312: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟311{s},𝓛8743{String})
 }
}
function 𝓟313{CONSTRUCTOR} (): (𝓟[ty]317{FlyweightFactory})
{
 const 𝓟[ty]317{FlyweightFactory};
 const 𝓟[ty]317{FlyweightFactory};
 𝓟[ty]317{FlyweightFactory}.fliesMap ⟵ {} as any;
}
class 𝓟[ty]317{FlyweightFactory}{
 𝓟319{fliesMap}: 𝓛[ty]8642{Object};
 function 𝓟320{getFlyweight} (𝓟321{key}: 𝓛[ty]10051{String}): (𝓟322: [OOV]𝓟[ty]290{Flyweight})
 {
 if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]317{FlyweightFactory}.fliesMap.access(𝓟321{key}),𝓛12643{undefined}),𝓛12643{undefined}))
 {
 𝓟[ty]317{FlyweightFactory}.fliesMap.access(𝓟321{key}) ⟵ 𝓟291{CONSTRUCTOR}(𝓟321{key});
 }
 return 𝓟322 = 𝓟[ty]317{FlyweightFactory}.fliesMap.access(𝓟321{key})
 }
}

Module: bridge/demo

function 𝓟323{show} (): (𝓟324: 𝓛[ty]10033{Void})
{
 let 𝓟325{abstractionA}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛1{<UNKNOWN>}.CONSTRUCTOR());
 let 𝓟326{abstractionB}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛1{<UNKNOWN>}.CONSTRUCTOR());
 𝓟325{abstractionA}.callIt(𝓛8743{String})
 𝓟326{abstractionB}.callIt(𝓛8743{String})
}

Module: mediator/demo

function 𝓟327{show} (): (𝓟328: 𝓛[ty]10033{Void})
{
 let 𝓟329{cm}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟330{c1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟329{cm});
 let 𝓟331{c2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟329{cm});
 𝓟329{cm}.concreteColleagueA ⟵ 𝓟330{c1};
 𝓟329{cm}.concreteColleagueB ⟵ 𝓟331{c2};
 𝓟330{c1}.send(𝓛8743{String})
 𝓟331{c2}.send(𝓛8743{String})
}

Module: interpreter/interpreter

type 𝓟[ty]332{AbstractExpression} = {interpret: (𝓟[ty]337{Context})->𝓛[ty]10033{Void}}
function 𝓟333{CONSTRUCTOR} (): (𝓟[ty]337{Context})
{
 const 𝓟[ty]337{Context};
 const 𝓟[ty]337{Context};
}
class 𝓟[ty]337{Context}{
}
function 𝓟339{CONSTRUCTOR} (): (𝓟[ty]343{TerminalExpression})
{
 const 𝓟[ty]343{TerminalExpression};
 const 𝓟[ty]343{TerminalExpression};
}
class 𝓟[ty]343{TerminalExpression} extends 𝓟[ty]332{AbstractExpression}{
 function 𝓟345{interpret} (𝓟346{context}: (𝓟[ty]713{Context} ≠ 𝓟[ty]337{Context})): (𝓟347: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟348{CONSTRUCTOR} (): (𝓟[ty]352{NonterminalExpression})
{
 const 𝓟[ty]352{NonterminalExpression};
 const 𝓟[ty]352{NonterminalExpression};
}
class 𝓟[ty]352{NonterminalExpression} extends 𝓟[ty]332{AbstractExpression}{
 function 𝓟354{interpret} (𝓟355{context}: (𝓟[ty]713{Context} ≠ 𝓟[ty]337{Context})): (𝓟356: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}

Module: abstract_factory/abstractFactory

type 𝓟[ty]357{AbstractFactory} = {createProductA: (any)->𝓟[ty]359{AbstractProductA}, createProductB: ()->𝓟[ty]358{AbstractProductB}}
type 𝓟[ty]358{AbstractProductB} = {methodB: ()->𝓛[ty]8655{Number}}
type 𝓟[ty]359{AbstractProductA} = {methodA: ()->𝓛[ty]10051{String}}
function 𝓟360{CONSTRUCTOR} (): (𝓟[ty]366{ProductA1})
{
 const 𝓟[ty]366{ProductA1};
 const 𝓟[ty]366{ProductA1};
 function 𝓟364{$Lambda1} (): (𝓟365: [miss]𝓛[ty]10051{String})
 {
 return 𝓟365 = 𝓛8743{String}
 }
 𝓟[ty]366{ProductA1}.methodA ⟵ 𝓟364{$Lambda1};
}
class 𝓟[ty]366{ProductA1} extends 𝓟[ty]359{AbstractProductA}{
 𝓟368{methodA}: [miss]𝓛[ty]8696{Function};
}
function 𝓟369{CONSTRUCTOR} (): (𝓟[ty]375{ProductB1})
{
 const 𝓟[ty]375{ProductB1};
 const 𝓟[ty]375{ProductB1};
 function 𝓟373{$Lambda2} (): (𝓟374: [miss]𝓛[ty]8655{Number})
 {
 return 𝓟374 = 𝓛8745{Number}
 }
 𝓟[ty]375{ProductB1}.methodB ⟵ 𝓟373{$Lambda2};
}
class 𝓟[ty]375{ProductB1} extends 𝓟[ty]358{AbstractProductB}{
 𝓟377{methodB}: [miss]𝓛[ty]8696{Function};
}
function 𝓟378{CONSTRUCTOR} (): (𝓟[ty]384{ProductA2})
{
 const 𝓟[ty]384{ProductA2};
 const 𝓟[ty]384{ProductA2};
 function 𝓟382{$Lambda3} (): (𝓟383: [miss]𝓛[ty]10051{String})
 {
 return 𝓟383 = 𝓛8743{String}
 }
 𝓟[ty]384{ProductA2}.methodA ⟵ 𝓟382{$Lambda3};
}
class 𝓟[ty]384{ProductA2} extends 𝓟[ty]359{AbstractProductA}{
 𝓟386{methodA}: [miss]𝓛[ty]8696{Function};
}
function 𝓟387{CONSTRUCTOR} (): (𝓟[ty]393{ProductB2})
{
 const 𝓟[ty]393{ProductB2};
 const 𝓟[ty]393{ProductB2};
 function 𝓟391{$Lambda4} (): (𝓟392: [miss]𝓛[ty]8655{Number})
 {
 return 𝓟392 = 𝓛8745{Number}
 }
 𝓟[ty]393{ProductB2}.methodB ⟵ 𝓟391{$Lambda4};
}
class 𝓟[ty]393{ProductB2} extends 𝓟[ty]358{AbstractProductB}{
 𝓟395{methodB}: [miss]𝓛[ty]8696{Function};
}
function 𝓟396{CONSTRUCTOR} (): (𝓟[ty]400{ConcreteFactory1})
{
 const 𝓟[ty]400{ConcreteFactory1};
 const 𝓟[ty]400{ConcreteFactory1};
}
class 𝓟[ty]400{ConcreteFactory1} extends 𝓟[ty]357{AbstractFactory}{
 function 𝓟402{createProductA} (𝓟403{param}: [OOV]any): (𝓟404: [OOV]𝓟[ty]359{AbstractProductA})
 {
 return 𝓟404 = 𝓟360{CONSTRUCTOR}()
 }
 function 𝓟405{createProductB} (𝓟406{param}: [OOV]any): (𝓟407: [OOV]𝓟[ty]358{AbstractProductB})
 {
 return 𝓟407 = 𝓟369{CONSTRUCTOR}()
 }
}
function 𝓟408{CONSTRUCTOR} (): (𝓟[ty]412{ConcreteFactory2})
{
 const 𝓟[ty]412{ConcreteFactory2};
 const 𝓟[ty]412{ConcreteFactory2};
}
class 𝓟[ty]412{ConcreteFactory2} extends 𝓟[ty]357{AbstractFactory}{
 function 𝓟414{createProductA} (𝓟415{param}: [OOV]any): (𝓟416: [OOV]𝓟[ty]359{AbstractProductA})
 {
 return 𝓟416 = 𝓟378{CONSTRUCTOR}()
 }
 function 𝓟417{createProductB} (𝓟418{param}: [OOV]any): (𝓟419: [OOV]𝓟[ty]358{AbstractProductB})
 {
 return 𝓟419 = 𝓟387{CONSTRUCTOR}()
 }
}
function 𝓟420{CONSTRUCTOR} (𝓟421{factory}: [OOV]𝓟[ty]357{AbstractFactory}): (𝓟[ty]425{Tester})
{
 const 𝓟[ty]425{Tester};
 const 𝓟[ty]425{Tester};
 𝓟[ty]425{Tester}.abstractProductA ⟵ 𝓟421{factory}.createProductA();
 𝓟[ty]425{Tester}.abstractProductB ⟵ 𝓟421{factory}.createProductB();
}
class 𝓟[ty]425{Tester}{
 𝓟427{abstractProductA}: [OOV]𝓟[ty]359{AbstractProductA};
 𝓟428{abstractProductB}: [OOV]𝓟[ty]358{AbstractProductB};
 function 𝓟429{test} (): (𝓟430: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓟[ty]425{Tester}.abstractProductA.methodA())
 𝓛1{<UNKNOWN>}(𝓟[ty]425{Tester}.abstractProductB.methodB())
 }
}

Module: composite/composite

type 𝓟[ty]431{Component} = {operation: ()->𝓛[ty]10033{Void}}
function 𝓟432{CONSTRUCTOR} (𝓟433{s}: (𝓟[ty]900{Objs} ≠ 𝓛[ty]10051{String})): (𝓟[ty]437{Composite})
{
 const 𝓟[ty]437{Composite};
 const 𝓟[ty]437{Composite};
 𝓟[ty]437{Composite}.list ⟵ 𝓛8757{Array}();
 𝓟[ty]437{Composite}.s ⟵ 𝓟433{s};
}
class 𝓟[ty]437{Composite} extends 𝓟[ty]431{Component}{
 𝓟439{list}: 𝓛[ty]8670{Array};
 𝓟440{s}: 𝓛[ty]10051{String};
 function 𝓟441{operation} (): (𝓟442: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]437{Composite}.s)
 {
 let 𝓟443{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 while (𝓛1{<UNKNOWN>}(𝓟443{i},𝓟[ty]437{Composite}.list.length))
 {
 {
 𝓟[ty]437{Composite}.list.access(𝓟443{i}).operation()
 }
 𝓛12564{FirstCompoundAssignment}(𝓟443{i},𝓛8745{Number})
 }
 }
 }
 function 𝓟444{add} (𝓟445{c}: [OOV]𝓟[ty]431{Component}): (𝓟446: 𝓛[ty]10033{Void})
 {
 𝓟[ty]437{Composite}.list.push(𝓟445{c})
 }
 function 𝓟447{remove} (𝓟448{i}: 𝓛[ty]8655{Number}): (𝓟449: 𝓛[ty]10033{Void})
 {
 if (𝓛12582{LessThanEqualsToken}(𝓟[ty]437{Composite}.list.length,𝓟448{i}))
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 𝓟[ty]437{Composite}.list.splice(𝓟448{i},𝓛8745{Number})
 }
}
function 𝓟450{CONSTRUCTOR} (𝓟451{s}: (𝓟[ty]900{Objs} ≠ 𝓛[ty]10051{String})): (𝓟[ty]455{Leaf})
{
 const 𝓟[ty]455{Leaf};
 const 𝓟[ty]455{Leaf};
 𝓟[ty]455{Leaf}.s ⟵ 𝓟451{s};
}
class 𝓟[ty]455{Leaf} extends 𝓟[ty]431{Component}{
 𝓟457{s}: 𝓛[ty]10051{String};
 function 𝓟458{operation} (): (𝓟459: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]455{Leaf}.s,𝓛8743{String})
 }
}

Module: mediator/mediator

type 𝓟[ty]460{Mediator} = {send: (𝓛[ty]10051{String},𝓟[ty]466{Colleague})->𝓛[ty]10033{Void}}
function 𝓟461{CONSTRUCTOR} (𝓟462{mediator}: [OOV]𝓟[ty]460{Mediator}): (𝓟[ty]466{Colleague})
{
 const 𝓟[ty]466{Colleague};
 const 𝓟[ty]466{Colleague};
 𝓟[ty]466{Colleague}.mediator ⟵ 𝓟462{mediator};
}
class 𝓟[ty]466{Colleague}{
 𝓟468{mediator}: [OOV]𝓟[ty]460{Mediator};
 function 𝓟469{send} (𝓟470{msg}: 𝓛[ty]10051{String}): (𝓟471: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 function 𝓟472{receive} (𝓟473{msg}: 𝓛[ty]10051{String}): (𝓟474: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
}
function 𝓟475{CONSTRUCTOR} (𝓟476{mediator}: [OOV]𝓟[ty]460{Mediator}): (𝓟[ty]480{ConcreteColleagueA})
{
 const 𝓟[ty]480{ConcreteColleagueA};
 const 𝓟[ty]480{ConcreteColleagueA};
 𝓟[ty]480{ConcreteColleagueA}(𝓟476{mediator})
}
class 𝓟[ty]480{ConcreteColleagueA} extends 𝓟[ty]466{Colleague}{
 function 𝓟482{send} (𝓟483{msg}: 𝓛[ty]10051{String}): (𝓟484: 𝓛[ty]10033{Void})
 {
 𝓟[ty]480{ConcreteColleagueA}.mediator.send(𝓟483{msg},𝓟[ty]480{ConcreteColleagueA})
 }
 function 𝓟485{receive} (𝓟486{msg}: 𝓛[ty]10051{String}): (𝓟487: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓟486{msg},𝓛8743{String})
 }
}
function 𝓟488{CONSTRUCTOR} (𝓟489{mediator}: [OOV]𝓟[ty]460{Mediator}): (𝓟[ty]493{ConcreteColleagueB})
{
 const 𝓟[ty]493{ConcreteColleagueB};
 const 𝓟[ty]493{ConcreteColleagueB};
 𝓟[ty]493{ConcreteColleagueB}(𝓟489{mediator})
}
class 𝓟[ty]493{ConcreteColleagueB} extends 𝓟[ty]466{Colleague}{
 function 𝓟495{send} (𝓟496{msg}: 𝓛[ty]10051{String}): (𝓟497: 𝓛[ty]10033{Void})
 {
 𝓟[ty]493{ConcreteColleagueB}.mediator.send(𝓟496{msg},𝓟[ty]493{ConcreteColleagueB})
 }
 function 𝓟498{receive} (𝓟499{msg}: 𝓛[ty]10051{String}): (𝓟500: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓟499{msg},𝓛8743{String})
 }
}
function 𝓟501{CONSTRUCTOR} (): (𝓟[ty]505{ConcreteMediator})
{
 const 𝓟[ty]505{ConcreteMediator};
 const 𝓟[ty]505{ConcreteMediator};
}
class 𝓟[ty]505{ConcreteMediator} extends 𝓟[ty]460{Mediator}{
 𝓟507{concreteColleagueA}: 𝓟[ty]480{ConcreteColleagueA};
 𝓟508{concreteColleagueB}: 𝓟[ty]493{ConcreteColleagueB};
 function 𝓟509{send} (𝓟510{msg}: 𝓛[ty]10051{String},𝓟511{colleague}: (𝓟[ty]713{Context} ≠ 𝓟[ty]466{Colleague})): (𝓟512: 𝓛[ty]10033{Void})
 {
 if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]505{ConcreteMediator}.concreteColleagueA,𝓟511{colleague}))
 {
 𝓟[ty]505{ConcreteMediator}.concreteColleagueB.receive(𝓟510{msg})
 }
 else
 {
 𝓟[ty]505{ConcreteMediator}.concreteColleagueA.receive(𝓟510{msg})
 }
 }
}

Module: strategy/demo

function 𝓟513{show} (): (𝓟514: 𝓛[ty]10033{Void})
{
 let 𝓟515{context}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛1{<UNKNOWN>}.CONSTRUCTOR());
 𝓟515{context}.executeStrategy()
 𝓟515{context} ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛1{<UNKNOWN>}.CONSTRUCTOR());
 𝓟515{context}.executeStrategy()
 𝓟515{context} ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛1{<UNKNOWN>}.CONSTRUCTOR());
 𝓟515{context}.executeStrategy()
}

Module: template_method/templateMethod

function 𝓟516{CONSTRUCTOR} (): (𝓟[ty]520{AbstractClass})
{
 const 𝓟[ty]520{AbstractClass};
 const 𝓟[ty]520{AbstractClass};
}
class 𝓟[ty]520{AbstractClass}{
 function 𝓟522{method1} (): (𝓟523: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 function 𝓟524{method2} (): (𝓟525: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 function 𝓟526{method3} (): (𝓟527: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
 function 𝓟528{templateMethod} (): (𝓟529: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]520{AbstractClass}.method1()
 𝓟[ty]520{AbstractClass}.method2()
 𝓟[ty]520{AbstractClass}.method3()
 }
}
function 𝓟530{CONSTRUCTOR} (): (𝓟[ty]534{ConcreteClass1})
{
 const 𝓟[ty]534{ConcreteClass1};
 const 𝓟[ty]534{ConcreteClass1};
}
class 𝓟[ty]534{ConcreteClass1} extends 𝓟[ty]520{AbstractClass}{
 function 𝓟536{method1} (): (𝓟537: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟538{method2} (): (𝓟539: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟540{method3} (): (𝓟541: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟542{CONSTRUCTOR} (): (𝓟[ty]546{ConcreteClass2})
{
 const 𝓟[ty]546{ConcreteClass2};
 const 𝓟[ty]546{ConcreteClass2};
}
class 𝓟[ty]546{ConcreteClass2} extends 𝓟[ty]520{AbstractClass}{
 function 𝓟548{method1} (): (𝓟549: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟550{method2} (): (𝓟551: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟552{method3} (): (𝓟553: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}

Module: factory_method/demo

function 𝓟554{show} (): (𝓟555: 𝓛[ty]10033{Void})
{
 let 𝓟556{a}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.createProduct(𝓛8743{String});
 let 𝓟557{b}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.createProduct(𝓛8743{String});
 𝓛1{<UNKNOWN>}(𝓟556{a}.method())
 𝓛1{<UNKNOWN>}(𝓟557{b}.method())
}

Module: decorator/decorator

type 𝓟[ty]558{Component} = {operation: ()->𝓛[ty]10033{Void}}
function 𝓟559{CONSTRUCTOR} (𝓟560{s}: (𝓟[ty]900{Objs} ≠ 𝓛[ty]10051{String})): (𝓟[ty]564{ConcreteComponent})
{
 const 𝓟[ty]564{ConcreteComponent};
 const 𝓟[ty]564{ConcreteComponent};
 𝓟[ty]564{ConcreteComponent}.s ⟵ 𝓟560{s};
}
class 𝓟[ty]564{ConcreteComponent} extends 𝓟[ty]558{Component}{
 𝓟566{s}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]10051{String});
 function 𝓟567{operation} (): (𝓟568: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]564{ConcreteComponent}.s,𝓛8743{String})
 }
}
function 𝓟569{CONSTRUCTOR} (𝓟570{id}: 𝓛[ty]8655{Number},𝓟571{component}: [OOV]𝓟[ty]558{Component}): (𝓟[ty]575{Decorator})
{
 const 𝓟[ty]575{Decorator};
 const 𝓟[ty]575{Decorator};
 𝓟[ty]575{Decorator}.id ⟵ 𝓟570{id};
 𝓟[ty]575{Decorator}.component ⟵ 𝓟571{component};
}
class 𝓟[ty]575{Decorator} extends 𝓟[ty]558{Component}{
 𝓟577{component}: [OOV]𝓟[ty]558{Component};
 𝓟578{id}: 𝓛[ty]8655{Number};
 function 𝓟579{Id} (): (𝓟580: 𝓛[ty]8655{Number})
 {
 return 𝓟580 = 𝓟[ty]575{Decorator}.id
 }
 function 𝓟581{operation} (): (𝓟582: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]575{Decorator}.id,𝓛8743{String})
 𝓟[ty]575{Decorator}.component.operation()
 }
}
function 𝓟583{CONSTRUCTOR} (𝓟584{id}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟585{component}: [OOV]𝓟[ty]558{Component}): (𝓟[ty]589{ConcreteDecorator})
{
 const 𝓟[ty]589{ConcreteDecorator};
 const 𝓟[ty]589{ConcreteDecorator};
 𝓟[ty]589{ConcreteDecorator}(𝓟584{id},𝓟585{component})
}
class 𝓟[ty]589{ConcreteDecorator} extends 𝓟[ty]575{Decorator}{
 function 𝓟591{operation} (): (𝓟592: 𝓛[ty]10033{Void})
 {
 𝓟[ty]589{ConcreteDecorator}.operation()
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]589{ConcreteDecorator}.Id,𝓛8743{String})
 }
}

Module: observer/observer

function 𝓟593{CONSTRUCTOR} (): (𝓟[ty]597{Subject})
{
 const 𝓟[ty]597{Subject};
 const 𝓟[ty]597{Subject};
 𝓟[ty]597{Subject}.observers ⟵ 𝓛8757{Array}();
}
class 𝓟[ty]597{Subject}{
 𝓟599{observers}: 𝓛[ty]8670{Array};
 function 𝓟600{register} (𝓟601{observer}: 𝓟[ty]627{Observer}): (𝓟602: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓟601{observer},𝓛8743{String})
 𝓟[ty]597{Subject}.observers.push(𝓟601{observer})
 }
 function 𝓟603{unregister} (𝓟604{observer}: 𝓟[ty]627{Observer}): (𝓟605: 𝓛[ty]10033{Void})
 {
 let 𝓟606{n}: 𝓛[ty]8655{Number} = 𝓟[ty]597{Subject}.observers.indexOf(𝓟604{observer});
 𝓛1{<UNKNOWN>}(𝓟604{observer},𝓛8743{String})
 𝓟[ty]597{Subject}.observers.splice(𝓟606{n},𝓛8745{Number})
 }
 function 𝓟607{notify} (): (𝓟608: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟[ty]597{Subject}.observers)
 let 𝓟609{i}: 𝓛[ty]8655{Number};
 let 𝓟610{max}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
 {
 𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}(𝓟609{i},𝓛8745{Number}),𝓛1{<UNKNOWN>}(𝓟610{max},𝓟[ty]597{Subject}.observers.length))
 while (𝓛1{<UNKNOWN>}(𝓟609{i},𝓟610{max}))
 {
 {
 𝓟[ty]597{Subject}.observers.access(𝓟609{i}).notify()
 }
 𝓛12564{FirstCompoundAssignment}(𝓟609{i},𝓛8745{Number})
 }
 }
 }
}
function 𝓟611{CONSTRUCTOR} (): (𝓟[ty]615{ConcreteSubject})
{
 const 𝓟[ty]615{ConcreteSubject};
 const 𝓟[ty]615{ConcreteSubject};
}
class 𝓟[ty]615{ConcreteSubject} extends 𝓟[ty]597{Subject}{
 𝓟617{subjectState}: (𝓟[ty]741{Handler} ≠ 𝓛[ty]8655{Number});
 function 𝓟620{SubjectState} (𝓟621{subjectState}: (𝓟[ty]741{Handler} ≠ 𝓛[ty]8655{Number})): (𝓟622)
 {
 𝓟[ty]615{ConcreteSubject}.subjectState ⟵ 𝓟621{subjectState};
 }
}
function 𝓟623{CONSTRUCTOR} (): (𝓟[ty]627{Observer})
{
 const 𝓟[ty]627{Observer};
 const 𝓟[ty]627{Observer};
}
class 𝓟[ty]627{Observer}{
 function 𝓟629{notify} (): (𝓟630: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
}
function 𝓟631{CONSTRUCTOR} (𝓟632{subject}: (𝓟[ty]597{Subject} ≠ 𝓟[ty]615{ConcreteSubject}),𝓟633{name}: 𝓛[ty]10051{String}): (𝓟[ty]637{ConcreteObserver})
{
 const 𝓟[ty]637{ConcreteObserver};
 const 𝓟[ty]637{ConcreteObserver};
 𝓟[ty]637{ConcreteObserver}()
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟633{name},𝓛8743{String})
 𝓟[ty]637{ConcreteObserver}.subject ⟵ 𝓟632{subject};
 𝓟[ty]637{ConcreteObserver}.name ⟵ 𝓟633{name};
}
class 𝓟[ty]637{ConcreteObserver} extends 𝓟[ty]627{Observer}{
 𝓟639{name}: 𝓛[ty]10051{String};
 𝓟640{state}: 𝓛[ty]8655{Number};
 𝓟641{subject}: (𝓛[ty]8670{Array} ≠ 𝓟[ty]615{ConcreteSubject});
 function 𝓟642{notify} (): (𝓟643: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓟[ty]637{ConcreteObserver}.name,𝓟[ty]637{ConcreteObserver}.state)
 𝓟[ty]637{ConcreteObserver}.state ⟵ 𝓟[ty]637{ConcreteObserver}.subject.SubjectState;
 }
 function 𝓟646{Subject} (𝓟647{subject}: (𝓟[ty]597{Subject} ≠ 𝓟[ty]615{ConcreteSubject})): (𝓟648)
 {
 𝓟[ty]637{ConcreteObserver}.subject ⟵ 𝓟647{subject};
 }
}

Module: iterator/iterator

type 𝓟[ty]649{Iterator} = {next: ()->any, hasNext: ()->𝓛[ty]8666{Boolean}}
type 𝓟[ty]650{Aggregator} = {createIterator: ()->𝓟[ty]649{Iterator}}
function 𝓟651{CONSTRUCTOR} (𝓟652{collection}: 𝓛[ty]8670{Array}): (𝓟[ty]656{ConcreteIterator})
{
 const 𝓟[ty]656{ConcreteIterator};
 const 𝓟[ty]656{ConcreteIterator};
 𝓟[ty]656{ConcreteIterator}.position ⟵ 𝓛8745{Number};
 𝓟[ty]656{ConcreteIterator}.collection ⟵ 𝓛8757{Array}();
 𝓟[ty]656{ConcreteIterator}.collection ⟵ 𝓟652{collection};
}
class 𝓟[ty]656{ConcreteIterator} extends 𝓟[ty]649{Iterator}{
 𝓟658{collection}: 𝓛[ty]8670{Array};
 𝓟659{position}: 𝓛[ty]8655{Number};
 function 𝓟660{next} (): (𝓟661: [OOV]any)
 {
 let 𝓟662{result} = 𝓟[ty]656{ConcreteIterator}.collection.access(𝓟[ty]656{ConcreteIterator}.position);
 𝓛12564{FirstCompoundAssignment}(𝓟[ty]656{ConcreteIterator}.position,𝓛8745{Number})
 return 𝓟661 = 𝓟662{result}
 }
 function 𝓟663{hasNext} (): (𝓟664: (𝓟[ty]820{User} ≠ 𝓛[ty]8666{Boolean}))
 {
 return 𝓟664 = 𝓛1{<UNKNOWN>}(𝓟[ty]656{ConcreteIterator}.position,𝓟[ty]656{ConcreteIterator}.collection.length)
 }
}
function 𝓟665{CONSTRUCTOR} (𝓟666{collection}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array})): (𝓟[ty]670{Numbers})
{
 const 𝓟[ty]670{Numbers};
 const 𝓟[ty]670{Numbers};
 𝓟[ty]670{Numbers}.collection ⟵ 𝓛8757{Array}();
 𝓟[ty]670{Numbers}.collection ⟵ 𝓟666{collection};
}
class 𝓟[ty]670{Numbers} extends 𝓟[ty]650{Aggregator}{
 𝓟672{collection}: 𝓛[ty]8670{Array};
 function 𝓟673{createIterator} (): (𝓟674: [OOV]𝓟[ty]649{Iterator})
 {
 return 𝓟674 = 𝓟651{CONSTRUCTOR}(𝓟[ty]670{Numbers}.collection)
 }
}

Module: decorator/demo

function 𝓟675{show} (): (𝓟676: 𝓛[ty]10033{Void})
{
 let 𝓟677{decorator1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8745{Number},𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String}));
 𝓟677{decorator1}.operation()
}

Module: composite/demo

function 𝓟678{show} (): (𝓟679: 𝓛[ty]10033{Void})
{
 let 𝓟680{leaf1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 let 𝓟681{leaf2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 let 𝓟682{leaf3}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 let 𝓟683{composite1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 let 𝓟684{composite2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 𝓟683{composite1}.add(𝓟680{leaf1})
 𝓟683{composite1}.add(𝓟681{leaf2})
 𝓟683{composite1}.add(𝓟682{leaf3})
 𝓟683{composite1}.remove(𝓛8745{Number})
 𝓟684{composite2}.add(𝓟680{leaf1})
 𝓟684{composite2}.add(𝓟682{leaf3})
 𝓟683{composite1}.operation()
 𝓟684{composite2}.operation()
}

Module: prototype/demo

function 𝓟685{show} (): (𝓟686: 𝓛[ty]10033{Void})
{
 let 𝓟687{builder}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟688{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 {
 𝓛1{<UNKNOWN>}(𝓟688{i},𝓛8745{Number})
 while (𝓛12582{LessThanEqualsToken}(𝓟688{i},𝓛8745{Number}))
 {
 {
 𝓛1{<UNKNOWN>}(𝓟687{builder}.createOne(𝓛12641{PlusToken}(𝓛8743{String},𝓟688{i})).toString())
 }
 𝓛12564{FirstCompoundAssignment}(𝓟688{i},𝓛8745{Number})
 }
 }
}

Module: state/state

type 𝓟[ty]689{State} = {handle: (𝓟[ty]713{Context})->𝓛[ty]10033{Void}}
function 𝓟690{CONSTRUCTOR} (): (𝓟[ty]694{ConcreteStateA})
{
 const 𝓟[ty]694{ConcreteStateA};
 const 𝓟[ty]694{ConcreteStateA};
}
class 𝓟[ty]694{ConcreteStateA} extends 𝓟[ty]689{State}{
 function 𝓟696{handle} (𝓟697{context}: 𝓟[ty]713{Context}): (𝓟698: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟697{context}.State ⟵ 𝓟699{CONSTRUCTOR}();
 }
}
function 𝓟699{CONSTRUCTOR} (): (𝓟[ty]703{ConcreteStateB})
{
 const 𝓟[ty]703{ConcreteStateB};
 const 𝓟[ty]703{ConcreteStateB};
}
class 𝓟[ty]703{ConcreteStateB} extends 𝓟[ty]689{State}{
 function 𝓟705{handle} (𝓟706{context}: 𝓟[ty]713{Context}): (𝓟707: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟706{context}.State ⟵ 𝓟690{CONSTRUCTOR}();
 }
}
function 𝓟708{CONSTRUCTOR} (𝓟709{state}: [OOV]𝓟[ty]689{State}): (𝓟[ty]713{Context})
{
 const 𝓟[ty]713{Context};
 const 𝓟[ty]713{Context};
 𝓟[ty]713{Context}.state ⟵ 𝓟709{state};
}
class 𝓟[ty]713{Context}{
 𝓟715{state}: [OOV]𝓟[ty]689{State};
 function 𝓟718{State} (𝓟719{state}: [OOV]𝓟[ty]689{State}): (𝓟720)
 {
 𝓟[ty]713{Context}.state ⟵ 𝓟719{state};
 }
 function 𝓟721{request} (): (𝓟722: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]713{Context}.state.handle(𝓟[ty]713{Context})
 }
}

Module: chain_of_responsibility/demo

function 𝓟723{show} (): (𝓟724: 𝓛[ty]10033{Void})
{
 let 𝓟725{h1}: [OOV]𝓛[ty]2{<UNKNOWN>};
 let 𝓟726{h2}: [OOV]𝓛[ty]2{<UNKNOWN>};
 let 𝓟727{h3}: [OOV]𝓛[ty]2{<UNKNOWN>};
 let 𝓟728{reqs}: 𝓛[ty]8670{Array};
 let 𝓟729{i}: 𝓛[ty]8655{Number};
 let 𝓟730{max}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
 𝓟728{reqs} ⟵ 𝓛8757{Array}(𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number},𝓛8745{Number});
 𝓟725{h1} ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8745{Number});
 𝓟726{h2} ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8745{Number});
 𝓟727{h3} ⟵ 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8745{Number});
 𝓟725{h1}.setHandler(𝓟726{h2})
 𝓟726{h2}.setHandler(𝓟727{h3})
 {
 𝓛1{<UNKNOWN>}(𝓛1{<UNKNOWN>}(𝓟729{i},𝓛8745{Number}),𝓛1{<UNKNOWN>}(𝓟730{max},𝓟728{reqs}.length))
 while (𝓛1{<UNKNOWN>}(𝓟729{i},𝓟730{max}))
 {
 {
 𝓟725{h1}.operation(𝓛8743{String},𝓟728{reqs}.access(𝓟729{i}))
 }
 𝓛12564{FirstCompoundAssignment}(𝓟729{i},𝓛8745{Number})
 }
 }
}

Module: visitor/demo

function 𝓟731{show} (): (𝓟732: 𝓛[ty]10033{Void})
{
 let 𝓟733{objs}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟733{objs}.attach(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 𝓟733{objs}.attach(𝓛1{<UNKNOWN>}.CONSTRUCTOR())
 let 𝓟734{v1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 let 𝓟735{v2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟733{objs}.operate(𝓟734{v1})
 𝓟733{objs}.operate(𝓟735{v2})
}

Module: chain_of_responsibility/chainOfResponsibility

function 𝓟736{CONSTRUCTOR} (𝓟737{req}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]741{Handler})
{
 const 𝓟[ty]741{Handler};
 const 𝓟[ty]741{Handler};
 𝓟[ty]741{Handler}.req ⟵ 𝓟737{req};
}
class 𝓟[ty]741{Handler}{
 𝓟743{handler}: 𝓟[ty]741{Handler};
 𝓟744{req}: 𝓛[ty]8655{Number};
 function 𝓟745{setHandler} (𝓟746{handler}: 𝓟[ty]741{Handler}): (𝓟747: 𝓛[ty]10033{Void})
 {
 𝓟[ty]741{Handler}.handler ⟵ 𝓟746{handler};
 }
 function 𝓟748{operation} (𝓟749{msg}: 𝓛[ty]10051{String},𝓟750{req}: 𝓛[ty]8655{Number}): (𝓟751: 𝓛[ty]10033{Void})
 {
 if (𝓛12582{LessThanEqualsToken}(𝓟750{req},𝓟[ty]741{Handler}.req))
 {
 𝓟[ty]741{Handler}.handlerRequest(𝓟749{msg})
 }
 else
 {
 if (𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟[ty]741{Handler}.handler,𝓛12643{undefined}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟[ty]741{Handler}.handler,𝓛12643{undefined})))
 {
 𝓟[ty]741{Handler}.handler.operation(𝓟749{msg},𝓟750{req})
 }
 }
 }
 function 𝓟752{handlerRequest} (𝓟753{msg}: 𝓛[ty]10051{String}): (𝓟754: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
}
function 𝓟755{CONSTRUCTOR} (𝓟756{req}: (𝓟[ty]597{Subject} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]760{ConcreteHandler1})
{
 const 𝓟[ty]760{ConcreteHandler1};
 const 𝓟[ty]760{ConcreteHandler1};
 𝓟[ty]760{ConcreteHandler1}(𝓟756{req})
}
class 𝓟[ty]760{ConcreteHandler1} extends 𝓟[ty]741{Handler}{
 function 𝓟762{handlerRequest} (𝓟763{msg}: 𝓛[ty]10051{String}): (𝓟764: [miss]𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟763{msg})
 }
}
function 𝓟765{CONSTRUCTOR} (𝓟766{req}: (𝓟[ty]597{Subject} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]770{ConcreteHandler2})
{
 const 𝓟[ty]770{ConcreteHandler2};
 const 𝓟[ty]770{ConcreteHandler2};
 𝓟[ty]770{ConcreteHandler2}(𝓟766{req})
}
class 𝓟[ty]770{ConcreteHandler2} extends 𝓟[ty]741{Handler}{
 function 𝓟772{handlerRequest} (𝓟773{msg}: 𝓛[ty]10051{String}): (𝓟774: [miss]𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟773{msg})
 }
}
function 𝓟775{CONSTRUCTOR} (𝓟776{req}: (𝓟[ty]597{Subject} ≠ 𝓛[ty]8655{Number})): (𝓟[ty]780{ConcreteHandler3})
{
 const 𝓟[ty]780{ConcreteHandler3};
 const 𝓟[ty]780{ConcreteHandler3};
 𝓟[ty]780{ConcreteHandler3}(𝓟776{req})
}
class 𝓟[ty]780{ConcreteHandler3} extends 𝓟[ty]741{Handler}{
 function 𝓟782{handlerRequest} (𝓟783{msg}: 𝓛[ty]10051{String}): (𝓟784: [miss]𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String},𝓟783{msg})
 }
}

Module: builder/builder

function 𝓟785{CONSTRUCTOR} (𝓟786{name}: (𝓟[ty]337{Context} ≠ 𝓛[ty]10051{String})): (𝓟[ty]790{UserBuilder})
{
 const 𝓟[ty]790{UserBuilder};
 const 𝓟[ty]790{UserBuilder};
 𝓟[ty]790{UserBuilder}.name ⟵ 𝓟786{name};
}
class 𝓟[ty]790{UserBuilder}{
 𝓟792{name}: 𝓛[ty]10051{String};
 𝓟793{age}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
 𝓟794{phone}: (𝓟[ty]900{Objs} ≠ 𝓛[ty]10051{String});
 𝓟795{address}: 𝓛[ty]10051{String};
 function 𝓟808{setAddress} (𝓟809{value}: 𝓛[ty]10051{String}): (𝓟810: 𝓟[ty]790{UserBuilder})
 {
 𝓟[ty]790{UserBuilder}.address ⟵ 𝓟809{value};
 return 𝓟810 = 𝓟[ty]790{UserBuilder}
 }
 function 𝓟796{Name} (): (𝓟797)
 {
 return 𝓟797 = 𝓟[ty]790{UserBuilder}.name
 }
 function 𝓟811{Address} (): (𝓟812)
 {
 return 𝓟812 = 𝓟[ty]790{UserBuilder}.address
 }
 function 𝓟798{setAge} (𝓟799{value}: (𝓛[ty]8670{Array} ≠ 𝓛[ty]8655{Number})): (𝓟800: 𝓟[ty]790{UserBuilder})
 {
 𝓟[ty]790{UserBuilder}.age ⟵ 𝓟799{value};
 return 𝓟800 = 𝓟[ty]790{UserBuilder}
 }
 function 𝓟813{build} (): (𝓟814: 𝓟[ty]820{User})
 {
 return 𝓟814 = 𝓟815{CONSTRUCTOR}(𝓟[ty]790{UserBuilder})
 }
 function 𝓟806{Phone} (): (𝓟807)
 {
 return 𝓟807 = 𝓟[ty]790{UserBuilder}.phone
 }
 function 𝓟801{Age} (): (𝓟802)
 {
 return 𝓟802 = 𝓟[ty]790{UserBuilder}.age
 }
 function 𝓟803{setPhone} (𝓟804{value}: (𝓛[ty]8696{Function} ≠ 𝓛[ty]10051{String})): (𝓟805: 𝓟[ty]790{UserBuilder})
 {
 𝓟[ty]790{UserBuilder}.phone ⟵ 𝓟804{value};
 return 𝓟805 = 𝓟[ty]790{UserBuilder}
 }
}
function 𝓟815{CONSTRUCTOR} (𝓟816{builder}: 𝓟[ty]790{UserBuilder}): (𝓟[ty]820{User})
{
 const 𝓟[ty]820{User};
 const 𝓟[ty]820{User};
 𝓟[ty]820{User}.name ⟵ 𝓟816{builder}.Name;
 𝓟[ty]820{User}.age ⟵ 𝓟816{builder}.Age;
 𝓟[ty]820{User}.phone ⟵ 𝓟816{builder}.Phone;
 𝓟[ty]820{User}.address ⟵ 𝓟816{builder}.Address;
}
class 𝓟[ty]820{User}{
 𝓟822{name}: 𝓛[ty]10051{String};
 𝓟823{age}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
 𝓟824{phone}: (𝓟[ty]42{Memento} ≠ 𝓛[ty]10051{String});
 𝓟825{address}: 𝓛[ty]10051{String};
 function 𝓟826{Name} (): (𝓟827)
 {
 return 𝓟827 = 𝓟[ty]820{User}.name
 }
 function 𝓟828{Age} (): (𝓟829)
 {
 return 𝓟829 = 𝓟[ty]820{User}.age
 }
 function 𝓟830{Phone} (): (𝓟831)
 {
 return 𝓟831 = 𝓟[ty]820{User}.phone
 }
 function 𝓟832{Address} (): (𝓟833)
 {
 return 𝓟833 = 𝓟[ty]820{User}.address
 }
}

Module: adapter/adapter

type 𝓟[ty]834{Target} = {call: ()->𝓛[ty]10033{Void}}
function 𝓟835{CONSTRUCTOR} (): (𝓟[ty]839{Adaptee})
{
 const 𝓟[ty]839{Adaptee};
 const 𝓟[ty]839{Adaptee};
}
class 𝓟[ty]839{Adaptee}{
 function 𝓟841{method} (): (𝓟842: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟843{CONSTRUCTOR} (): (𝓟[ty]847{Adapter})
{
 const 𝓟[ty]847{Adapter};
 const 𝓟[ty]847{Adapter};
}
class 𝓟[ty]847{Adapter} extends 𝓟[ty]834{Target}{
 function 𝓟849{call} (): (𝓟850: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 let 𝓟851{adaptee}: 𝓟[ty]839{Adaptee} = 𝓟835{CONSTRUCTOR}();
 𝓟851{adaptee}.method()
 }
}

Module: visitor/visitor

type 𝓟[ty]852{Element} = {operate: (𝓟[ty]853{Visitor})->𝓛[ty]10033{Void}}
type 𝓟[ty]853{Visitor} = {visitConcreteElement1: (𝓟[ty]882{ConcreteElement1})->𝓛[ty]10033{Void}, visitConcreteElement2: (𝓟[ty]891{ConcreteElement2})->𝓛[ty]10033{Void}}
function 𝓟854{CONSTRUCTOR} (): (𝓟[ty]858{ConcreteVisitor1})
{
 const 𝓟[ty]858{ConcreteVisitor1};
 const 𝓟[ty]858{ConcreteVisitor1};
}
class 𝓟[ty]858{ConcreteVisitor1} extends 𝓟[ty]853{Visitor}{
 function 𝓟860{visitConcreteElement1} (𝓟861{concreteElement1}: (𝓟[ty]891{ConcreteElement2} ≠ 𝓟[ty]882{ConcreteElement1})): (𝓟862: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟863{visitConcreteElement2} (𝓟864{concreteElement2}: 𝓟[ty]891{ConcreteElement2}): (𝓟865: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟866{CONSTRUCTOR} (): (𝓟[ty]870{ConcreteVisitor2})
{
 const 𝓟[ty]870{ConcreteVisitor2};
 const 𝓟[ty]870{ConcreteVisitor2};
}
class 𝓟[ty]870{ConcreteVisitor2} extends 𝓟[ty]853{Visitor}{
 function 𝓟872{visitConcreteElement1} (𝓟873{concreteElement1}: (𝓟[ty]891{ConcreteElement2} ≠ 𝓟[ty]882{ConcreteElement1})): (𝓟874: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟875{visitConcreteElement2} (𝓟876{concreteElement2}: 𝓟[ty]891{ConcreteElement2}): (𝓟877: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟878{CONSTRUCTOR} (): (𝓟[ty]882{ConcreteElement1})
{
 const 𝓟[ty]882{ConcreteElement1};
 const 𝓟[ty]882{ConcreteElement1};
}
class 𝓟[ty]882{ConcreteElement1} extends 𝓟[ty]852{Element}{
 function 𝓟884{operate} (𝓟885{visitor}: [OOV]𝓟[ty]853{Visitor}): (𝓟886: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟885{visitor}.visitConcreteElement1(𝓟[ty]882{ConcreteElement1})
 }
}
function 𝓟887{CONSTRUCTOR} (): (𝓟[ty]891{ConcreteElement2})
{
 const 𝓟[ty]891{ConcreteElement2};
 const 𝓟[ty]891{ConcreteElement2};
}
class 𝓟[ty]891{ConcreteElement2} extends 𝓟[ty]852{Element}{
 function 𝓟893{operate} (𝓟894{visitor}: [OOV]𝓟[ty]853{Visitor}): (𝓟895: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟894{visitor}.visitConcreteElement2(𝓟[ty]891{ConcreteElement2})
 }
}
function 𝓟896{CONSTRUCTOR} (): (𝓟[ty]900{Objs})
{
 const 𝓟[ty]900{Objs};
 const 𝓟[ty]900{Objs};
 𝓟[ty]900{Objs}.elements ⟵ 𝓛8757{Array}();
}
class 𝓟[ty]900{Objs}{
 𝓟902{elements}: 𝓛[ty]8670{Array};
 function 𝓟903{attach} (𝓟904{e}: [OOV]𝓟[ty]852{Element}): (𝓟905: 𝓛[ty]10033{Void})
 {
 𝓟[ty]900{Objs}.elements.push(𝓟904{e})
 }
 function 𝓟906{detach} (𝓟907{e}: [OOV]𝓟[ty]852{Element}): (𝓟908: 𝓛[ty]10033{Void})
 {
 let 𝓟909{index}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]900{Objs}.elements.indexOf(𝓟907{e});
 𝓟[ty]900{Objs}.elements.splice(𝓟909{index},𝓛8745{Number})
 }
 function 𝓟910{operate} (𝓟911{visitor}: [OOV]𝓟[ty]853{Visitor}): (𝓟912: 𝓛[ty]10033{Void})
 {
 let 𝓟913{i}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
 let 𝓟914{max}: [miss]𝓛[ty]8655{Number} = 𝓟[ty]900{Objs}.elements.length;
 {
 while (𝓛1{<UNKNOWN>}(𝓟913{i},𝓟914{max}))
 {
 {
 𝓟[ty]900{Objs}.elements.access(𝓟913{i}).operate(𝓟911{visitor})
 }
 𝓛12564{FirstCompoundAssignment}(𝓟913{i},𝓛8745{Number})
 }
 }
 }
}

Module: facade/demo

function 𝓟915{show} (): (𝓟916: 𝓛[ty]10033{Void})
{
 let 𝓟917{facade}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟917{facade}.operation1()
 𝓟917{facade}.operation2()
}

Module: builder/demo

function 𝓟918{show} (): (𝓟919: 𝓛[ty]10033{Void})
{
 let 𝓟920{u}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String}).setAge(𝓛8745{Number}).setPhone(𝓛8743{String}).setAddress(𝓛8743{String}).build();
 𝓛1{<UNKNOWN>}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓟920{u}.Name,𝓛8743{String}),𝓟920{u}.Age),𝓛8743{String}),𝓟920{u}.Phone),𝓛8743{String}),𝓟920{u}.Address))
}

Module: observer/demo

function 𝓟921{show} (): (𝓟922: 𝓛[ty]10033{Void})
{
 let 𝓟923{sub}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR();
 𝓟923{sub}.register(𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟923{sub},𝓛8743{String}))
 𝓟923{sub}.register(𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟923{sub},𝓛8743{String}))
 𝓟923{sub}.register(𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓟923{sub},𝓛8743{String}))
 𝓟923{sub}.SubjectState ⟵ 𝓛8745{Number};
 𝓟923{sub}.notify()
}

Module: proxy/demo

function 𝓟924{show} (): (𝓟925: 𝓛[ty]10033{Void})
{
 let 𝓟926{proxy1}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 let 𝓟927{proxy2}: [OOV]𝓛[ty]2{<UNKNOWN>} = 𝓛1{<UNKNOWN>}.CONSTRUCTOR(𝓛8743{String});
 𝓟926{proxy1}.doAction()
 𝓟926{proxy1}.doAction()
 𝓟927{proxy2}.doAction()
 𝓟927{proxy2}.doAction()
 𝓟926{proxy1}.doAction()
}

Module: bridge/bridge

type 𝓟[ty]928{Implementor} = {callee: (any)->𝓛[ty]10033{Void}}
function 𝓟929{CONSTRUCTOR} (𝓟930{imp}: [OOV]𝓟[ty]928{Implementor}): (𝓟[ty]934{Abstraction})
{
 const 𝓟[ty]934{Abstraction};
 const 𝓟[ty]934{Abstraction};
 𝓟[ty]934{Abstraction}.implementor ⟵ 𝓟930{imp};
}
class 𝓟[ty]934{Abstraction}{
 𝓟936{implementor}: [OOV]𝓟[ty]928{Implementor};
 function 𝓟937{callIt} (𝓟938{s}: 𝓛[ty]10051{String}): (𝓟939: 𝓛[ty]10033{Void})
 {
 𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String})
 }
}
function 𝓟940{CONSTRUCTOR} (𝓟941{imp}: [OOV]𝓟[ty]928{Implementor}): (𝓟[ty]945{RefinedAbstractionA})
{
 const 𝓟[ty]945{RefinedAbstractionA};
 const 𝓟[ty]945{RefinedAbstractionA};
 𝓟[ty]945{RefinedAbstractionA}(𝓟941{imp})
}
class 𝓟[ty]945{RefinedAbstractionA} extends 𝓟[ty]934{Abstraction}{
 function 𝓟947{callIt} (𝓟948{s}: 𝓛[ty]10051{String}): (𝓟949: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]945{RefinedAbstractionA}.implementor.callee(𝓟948{s})
 }
}
function 𝓟950{CONSTRUCTOR} (𝓟951{imp}: [OOV]𝓟[ty]928{Implementor}): (𝓟[ty]955{RefinedAbstractionB})
{
 const 𝓟[ty]955{RefinedAbstractionB};
 const 𝓟[ty]955{RefinedAbstractionB};
 𝓟[ty]955{RefinedAbstractionB}(𝓟951{imp})
}
class 𝓟[ty]955{RefinedAbstractionB} extends 𝓟[ty]934{Abstraction}{
 function 𝓟957{callIt} (𝓟958{s}: 𝓛[ty]10051{String}): (𝓟959: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]955{RefinedAbstractionB}.implementor.callee(𝓟958{s})
 }
}
function 𝓟960{CONSTRUCTOR} (): (𝓟[ty]964{ConcreteImplementorA})
{
 const 𝓟[ty]964{ConcreteImplementorA};
 const 𝓟[ty]964{ConcreteImplementorA};
}
class 𝓟[ty]964{ConcreteImplementorA} extends 𝓟[ty]928{Implementor}{
 function 𝓟966{callee} (𝓟967{s}: [OOV]any): (𝓟968: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓟967{s})
 }
}
function 𝓟969{CONSTRUCTOR} (): (𝓟[ty]973{ConcreteImplementorB})
{
 const 𝓟[ty]973{ConcreteImplementorB};
 const 𝓟[ty]973{ConcreteImplementorB};
}
class 𝓟[ty]973{ConcreteImplementorB} extends 𝓟[ty]928{Implementor}{
 function 𝓟975{callee} (𝓟976{s}: [OOV]any): (𝓟977: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓟976{s})
 }
}

Module: main

let 𝓟978{require}: 𝓛[ty]8696{Function};
let 𝓟979{process}: [OOV]any;
let 𝓟980{readline} = 𝓟978{require}(𝓛8743{String});
function 𝓟981{printMenu} (): (𝓟982: 𝓛[ty]10033{Void})
{
 let 𝓟983{menu}: [miss]𝓛[ty]10051{String} = 𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛12641{PlusToken}(𝓛8743{String},𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String}),𝓛8743{String});
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓛1{<UNKNOWN>}(𝓟983{menu})
}
function 𝓟984{menu} (): (𝓟985: 𝓛[ty]10033{Void})
{
 let 𝓟986{rl} = 𝓛1293{createInterface}({input: 𝓛1{<UNKNOWN>},output: 𝓛1{<UNKNOWN>}});
 𝓟981{printMenu}()
 function 𝓟987{$Lambda0} (𝓟988{answer}): (𝓟989: [miss]𝓛[ty]10033{Void})
 {
 𝓛12577{$Switch}(𝓛12641{PlusToken}(𝓟988{answer}))
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓛12634{$Case}(𝓛8745{Number})
 𝓟990{show}(𝓛1{<UNKNOWN>})
 𝓟986{rl}.close()
 }
 𝓟986{rl}.question(𝓛8743{String},𝓟987{$Lambda0})
}
function 𝓟990{show} (𝓟991{Pattern}: [OOV]any): (𝓟992: 𝓛[ty]10033{Void})
{
 𝓟991{Pattern}.Demo.show()
}
𝓟984{menu}()

Module: facade/facade

function 𝓟993{CONSTRUCTOR} (): (𝓟[ty]997{Part1})
{
 const 𝓟[ty]997{Part1};
 const 𝓟[ty]997{Part1};
}
class 𝓟[ty]997{Part1}{
 function 𝓟999{method1} (): (𝓟1000: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟1001{CONSTRUCTOR} (): (𝓟[ty]1005{Part2})
{
 const 𝓟[ty]1005{Part2};
 const 𝓟[ty]1005{Part2};
}
class 𝓟[ty]1005{Part2}{
 function 𝓟1007{method2} (): (𝓟1008: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟1009{CONSTRUCTOR} (): (𝓟[ty]1013{Part3})
{
 const 𝓟[ty]1013{Part3};
 const 𝓟[ty]1013{Part3};
}
class 𝓟[ty]1013{Part3}{
 function 𝓟1015{method3} (): (𝓟1016: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}
function 𝓟1017{CONSTRUCTOR} (): (𝓟[ty]1021{Facade})
{
 const 𝓟[ty]1021{Facade};
 const 𝓟[ty]1021{Facade};
 𝓟[ty]1021{Facade}.part3 ⟵ 𝓟1009{CONSTRUCTOR}();
 𝓟[ty]1021{Facade}.part2 ⟵ 𝓟1001{CONSTRUCTOR}();
 𝓟[ty]1021{Facade}.part1 ⟵ 𝓟993{CONSTRUCTOR}();
}
class 𝓟[ty]1021{Facade}{
 𝓟1023{part1}: (𝓟[ty]1005{Part2} ≠ 𝓟[ty]997{Part1});
 𝓟1024{part2}: 𝓟[ty]1005{Part2};
 𝓟1025{part3}: (𝓟[ty]1005{Part2} ≠ 𝓟[ty]1013{Part3});
 function 𝓟1026{operation1} (): (𝓟1027: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]1021{Facade}.part1.method1()
 𝓟[ty]1021{Facade}.part2.method2()
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
 function 𝓟1028{operation2} (): (𝓟1029: 𝓛[ty]10033{Void})
 {
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 𝓟[ty]1021{Facade}.part1.method1()
 𝓟[ty]1021{Facade}.part3.method3()
 𝓛1{<UNKNOWN>}(𝓛8743{String})
 }
}