gen_docs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "import re\n",
    "import json\n",
    "def loadFile(file_name) :\n",
    "    with open(file_name, \"r\") as f :\n",
    "        return \"\".join(f.readlines())\n",
    "    return \"\"\n",
    "\n",
    "def saveFile(file_name, contents) :\n",
    "    with open(file_name, \"w\") as f :\n",
    "        f.write(contents)\n",
    "\n",
    "def loadJson(json_file_path) :\n",
    "    with open(json_file_path, encoding='utf-8') as json_file :\n",
    "        return json.load(json_file)\n",
    "\n",
    "def camel2Sname(name) :\n",
    "    return re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()\n",
    "\n",
    "def camel2SnameSpace(name) :\n",
    "    return re.sub(r'(?<!^)(?=[A-Z])', ' ', name).lower()\n",
    "\n",
    "\n",
    "simpleApi = loadJson(\"../ngx3js-module/docs_api.json\")[\"children\"]\n",
    "\n",
    "i3JSApi = None\n",
    "for info in simpleApi :\n",
    "    if (info[\"name\"] == \"I3JS\") :\n",
    "        i3JSApi = info[\"children\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getClassInfo(className : str) :\n",
    "    for info in i3JSApi :\n",
    "        if (info[\"name\"] == className) :\n",
    "            return info\n",
    "    for info in simpleApi :\n",
    "        if (info[\"name\"] == className) :\n",
    "            return info\n",
    "    return None\n",
    "\n",
    "def getSourceFile(info) :\n",
    "    if \"sources\" in info :\n",
    "        fileName : str = info[\"sources\"][0][\"fileName\"]\n",
    "        if fileName.startswith(\"lib/\") :\n",
    "            return fileName[0:-3]\n",
    "    return \"error\"\n",
    "\n",
    "def isDecorators(info, decoType) :\n",
    "    isInput = False\n",
    "    if 'decorators' in info :\n",
    "        decorators = info['decorators']\n",
    "        for deco in decorators :\n",
    "            if deco['name'] == decoType :\n",
    "                isInput = True\n",
    "    return isInput\n",
    "\n",
    "def getExtends(info) :\n",
    "    extendeds = []\n",
    "    if \"extendedTypes\" in info : \n",
    "        extendedTypeName = info[\"extendedTypes\"][0][\"name\"]\n",
    "        childInfo = getClassInfo(extendedTypeName)\n",
    "        if childInfo is not None :\n",
    "            parentExtends = getExtends(childInfo)\n",
    "            if len(parentExtends) > 0 :\n",
    "                for name in parentExtends :\n",
    "                    extendeds.append(name)\n",
    "        extendeds.append(extendedTypeName)\n",
    "    return extendeds\n",
    "\n",
    "\n",
    "\n",
    "def getGenApiDocs(className : str) :\n",
    "    info = getClassInfo(className)\n",
    "    if info is None :\n",
    "        return False\n",
    "    kindString = info[\"kindString\"]\n",
    "    parentkindString = kindString\n",
    "    html = []\n",
    "    html.append('<!DOCTYPE html>')\n",
    "    html.append('<html lang=\"en\">')\n",
    "    html.append('\t<head>')\n",
    "    html.append('\t\t<meta charset=\"utf-8\" />')\n",
    "    html.append('\t\t<base href=\"../../\" />')\n",
    "    html.append('\t\t<script src=\"page.js\"></script>')\n",
    "    html.append('\t\t<link type=\"text/css\" rel=\"stylesheet\" href=\"page.css\" />')\n",
    "    html.append('\t</head>')\n",
    "    html.append('\t<body>')\n",
    "    refTypes = []\n",
    "    fileName = getSourceFile(info)\n",
    "    nameSpace = None\n",
    "    if kindString == \"Namespace\" :\n",
    "        html.append('\t\t<h1>{0}</h1>'.format(className))\n",
    "        html.append('')\n",
    "        html.append('\t\t<h2>Namespace</h2>')\n",
    "        if 'children' in info :\n",
    "            for child in info['children'] :\n",
    "                typeName = child['name']\n",
    "                childkindString = child['kindString']\n",
    "                if childkindString == 'Variable':\n",
    "                    defaultValue = ''\n",
    "                    typeName = getParamTypes(child)\n",
    "                    if 'defaultValue' in child and child['defaultValue'] != 'null':\n",
    "                        defaultValue = ' &nbsp; = {0} '.format(child['defaultValue'])\n",
    "                    html.append('\t\t<h3>[property:{1} {0}]{2}{4}{3}</h3>'.format(\n",
    "                        child['name'], \n",
    "                        typeName,\n",
    "                        '',\n",
    "                        '',\n",
    "                        defaultValue\n",
    "                    ))\n",
    "                    refTypes.append(typeName)\n",
    "                    html.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(getComment(child)))\n",
    "                    html.append('')\n",
    "                else :\n",
    "                    extends = getExtends(child)\n",
    "                    interfaceHtml = getExtraInterFace(child, extends)\n",
    "                    if interfaceHtml is not None and len(interfaceHtml) > 0 :\n",
    "                        mChildName = child['name']\n",
    "                        extendHtml = []\n",
    "                        if len(extends) > 0 :\n",
    "                            for ext in extends :\n",
    "                                extendHtml.append(\"[page:{0}] &rarr;\".format(ext))\n",
    "                        interFacekindString = child['kindString']\n",
    "                        if interfaceHtml.find('<h4>Constructor</h4>') > 0 :\n",
    "                            html.append('\t\t<h3 id=\"{0}\" class=\"dummy-class\">{2} [page:{0} {0}] <i class=\"modifier modifier-interface\">{1}</i></h3>'.format(mChildName, interFacekindString, \" \".join(extendHtml)))\n",
    "                            html.append('\t\t<p class=\"desc\">\\n\\t\\t\\tSee the [page:{0} {0}] page for more details.\\n\\t\\t</p>'.format(mChildName))\n",
    "                        else :\n",
    "                            html.append('\t\t<h3 id=\"{0}\">{2} {0} <i class=\"modifier modifier-interface\">{1}</i></h3>'.format(mChildName, interFacekindString, \" \".join(extendHtml)))\n",
    "                            html.append(interfaceHtml)\n",
    "                        html.append('')\n",
    "                        html.append('\t\t<p class=\"desc\">\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(getComment(child)))\n",
    "                        html.append('')\n",
    "                    # refTypes.append(typeName)\n",
    "        nameSpace = className\n",
    "    elif kindString == \"Class\" or kindString == \"Interface\":\n",
    "        extends = getExtends(info)\n",
    "        if len(extends) > 0 :\n",
    "            extendHtml = []\n",
    "            for ext in extends :\n",
    "                extendHtml.append(\"[page:{0}] &rarr;\".format(ext))\n",
    "            html.append('\t\t' + \" \".join(extendHtml))\n",
    "            html.append('')\n",
    "        html.append('\t\t<h1>{0}</h1>'.format(className))\n",
    "        html.append('')\n",
    "        html.append('\t\t<p class=\"desc\">\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(getComment(info, True)))\n",
    "        html.append('')\n",
    "\n",
    "\n",
    "        methodCnt = 0\n",
    "        if 'children' in info :\n",
    "            if isDecorators(info, 'Component') :\n",
    "                decorators = info['decorators']\n",
    "                for deco in decorators :\n",
    "                    name = deco['name']\n",
    "                    if name == 'Component' :\n",
    "                        selector = re.compile(\"selector: '([a-z0-9\\-]+)'\")\n",
    "                        matches = selector.findall(deco['arguments']['obj'])\n",
    "                        if matches :\n",
    "                            tagName = matches[0]\n",
    "                            html.append('\t\t<h2>Angular Template</h2>'.format(deco['name']))\n",
    "                            html.append('\t\t<code data-type=\"html\">&lt;{0}'.format(tagName))\n",
    "                            for child in info['children'] :        \n",
    "                                kindString = child['kindString']\n",
    "                                paramType = getParamTypes(child)\n",
    "                                if kindString == 'Property' :\n",
    "                                    attrName = child['name']\n",
    "                                    shortText = ''\n",
    "                                    if 'comment' in child and 'shortText' in child['comment'] :\n",
    "                                        shortText = child['comment']['shortText'].replace('\\t',' ').replace('\\n',' ').replace('   ',' ').replace('  ',' ').replace('  ',' ').strip()\n",
    "                                        if shortText != '' and len(shortText) > 30:\n",
    "                                            shortText = shortText[0:30] + '...'\n",
    "                                        if shortText != '' :\n",
    "                                            shortText = ' -- {0} '.format(shortText) \n",
    "                                    if isDecorators(child, 'Input') :\n",
    "                                        html.append('\t\t\t[ {0} ]=\"... {1}{2}\"'.format(attrName, paramType, shortText))\n",
    "                                    elif isDecorators(child, 'Output') :\n",
    "                                        typeArguments = 'any'\n",
    "                                        if 'type' in child and 'typeArguments' in child['type'] and len(child['type']['typeArguments']) > 0 :\n",
    "                                            typeArguments = child['type']['typeArguments'][0]['name']\n",
    "                                        html.append('\t\t\t( {0} )=\"...($event : {1}{2})\"'.format(attrName, typeArguments, shortText))\n",
    "                            html.append('\t\t&gt;&lt;/{0}&gt;'.format(tagName))\n",
    "                            html.append('\t\t</code>')\n",
    "                            html.append('')\n",
    "            htmlConstructor = []\n",
    "            for child in info['children'] :        \n",
    "                sources = getSourceFile(child)\n",
    "                kindString = child['kindString']\n",
    "                flags = child['flags']\n",
    "                if (kindString == 'Constructor'):\n",
    "                    params = []\n",
    "                    returnType  = 'void' \n",
    "                    comment = None\n",
    "                    paramsComments = []\n",
    "                    funcModifier = []\n",
    "                    if 'isPublic' in flags and flags['isPublic'] :\n",
    "                        funcModifier.append('<i class=\"modifier modifier-public\">Public</i>')\n",
    "                    elif 'isPrivate' in flags and flags['isPrivate'] :\n",
    "                        funcModifier.append('<i class=\"modifier modifier-private\">Private</i>')\n",
    "                    if 'isProtected' in flags and flags['isProtected'] :\n",
    "                        funcModifier.append('<i class=\"modifier modifier-protected\">Protected</i>')\n",
    "                    if 'isStatic' in flags and flags['isStatic'] :\n",
    "                        funcModifier.append('<i class=\"modifier modifier-static\">Static</i>')\n",
    "                    if 'overwrites' in child :\n",
    "                        funcModifier.append('<i class=\"modifier modifier-overwrite\">Overwrite</i>')\n",
    "                    if 'inheritedFrom' in child :\n",
    "                        funcModifier.append('<i class=\"modifier modifier-inherited\">Inherited</i>')\n",
    "                    funcModifierStr = ' '.join(funcModifier)\n",
    "                    if 'signatures' in child :\n",
    "                        for signatures in child['signatures'] :\n",
    "                            returnType = getReturnType(signatures)\n",
    "                            comment = getComment(signatures)\n",
    "                            if 'parameters' in signatures :\n",
    "                                params = []\n",
    "                                paramsComments = []\n",
    "                                for parameters in signatures['parameters'] :\n",
    "                                    typeName = getParamTypes(parameters)\n",
    "                                    isOptional = ''\n",
    "                                    paramComment = ''\n",
    "                                    isOptionalComment = ''\n",
    "                                    if 'flags' in parameters and 'isOptional' in parameters['flags'] and  parameters['flags']['isOptional'] :\n",
    "                                        isOptional = '?'\n",
    "                                        isOptionalComment = '(optional) '\n",
    "                                    if 'comment' in parameters and 'shortText' in parameters['comment'] :\n",
    "                                        paramComment = getCommentParse(parameters['comment']['shortText'].strip())\n",
    "                                    params.append(\" [param:{0} {1}]{2}\".format(typeName, parameters['name'], isOptional)); \n",
    "                                    refTypes.append(typeName)\n",
    "                                    if paramComment == '' :\n",
    "                                        paramComment = \"The {0}.\".format(camel2SnameSpace(parameters['name']))\n",
    "                                    defaultValue = ''\n",
    "                                    if 'defaultValue' in parameters and parameters['defaultValue'] != 'null':\n",
    "                                        defaultValue = ' &nbsp; = {0} '.format(parameters['defaultValue'])\n",
    "                                        \n",
    "                                    paramsComments.append(\"[parameter:{0} {1}]{4} - {2}{3}\".format(typeName, parameters['name'], isOptionalComment, paramComment, defaultValue)); \n",
    "                    htmlConstructor.append('\t\t<h3>[constructor:{1} {0}]( {2} ){3}</h3>'.format(\n",
    "                        className, \n",
    "                        returnType,\n",
    "                        \", \".join(params),\n",
    "                        funcModifierStr\n",
    "                    ))\n",
    "                    if len(paramsComments) > 0 :\n",
    "                        htmlConstructor.append('\t\t<h4>Parameters</h4>\\n\\t\\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(\"<br />\\n\\t\\t\\t\".join(paramsComments)))\n",
    "                    if comment is not None :\n",
    "                        htmlConstructor.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(comment))\n",
    "                    htmlConstructor.append('')\n",
    "                    methodCnt += 1\n",
    "                    break\n",
    "            if len(htmlConstructor) > 0 :\n",
    "                html.append('\t\t<h2>Constructor</h2>')\n",
    "                html.append('\t\t{0}'.format(\"\\n\".join(htmlConstructor)))\n",
    "\n",
    "            if \"children\" in info:\n",
    "                htmlProperty = []\n",
    "                inputCnt = 0\n",
    "                if len(extends) > 0 :\n",
    "                    for ext in extends :\n",
    "                        htmlProperty.append('\t\t<p>')\n",
    "                        htmlProperty.append('\t\t\tSee the base [page:{0} {0}] class for common properties.'.format(ext))\n",
    "                        htmlProperty.append('\t\t</p>')\n",
    "                        inputCnt += 1\n",
    "                    htmlProperty.append('')\n",
    "                for child in info['children'] :        \n",
    "                    sources = getSourceFile(child)\n",
    "                    kindString = child['kindString']\n",
    "                    flags = child['flags']\n",
    "                    if child['name'].startswith('_') :\n",
    "                        pass\n",
    "                    if kindString == 'Property' and (parentkindString == \"Interface\" or isDecorators(child, 'Input') or isDecorators(child, 'Output') or ('isPublic' in flags and flags['isPublic']) or ('isProtected' in flags and flags['isProtected'])):\n",
    "                        typeName = getParamTypes(child)\n",
    "                        isOptional = ''\n",
    "                        funcModifier = []\n",
    "                        if isDecorators(child, 'Input') :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-input\">Input</i>')\n",
    "                        if isDecorators(child, 'Output') :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-output\">Output</i>')\n",
    "                        if 'isPublic' in flags and flags['isPublic'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-public\">Public</i>')\n",
    "                        elif 'isPrivate' in flags and flags['isPrivate'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-private\">Private</i>')\n",
    "                        if 'isProtected' in flags and flags['isProtected'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-protected\">Protected</i>')\n",
    "                        if 'isStatic' in flags and flags['isStatic'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-static\">Static</i>')\n",
    "                        if 'inheritedFrom' in child :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-inherited\">Inherited</i>')\n",
    "                        if 'flags' in child and 'isOptional' in child['flags'] and  child['flags']['isOptional'] :\n",
    "                            isOptional = '?'\n",
    "                            funcModifier.append('<i class=\"modifier modifier-optional\">Optional</i>')\n",
    "                        funcModifierStr = ' '.join(funcModifier)\n",
    "                        defaultValue = ''\n",
    "                        if 'defaultValue' in child and child['defaultValue'] != 'null':\n",
    "                            defaultValue = ' &nbsp; = {0} '.format(child['defaultValue'])\n",
    "                        htmlProperty.append('\t\t<h3>[property:{1} {0}]{2}{4}{3}</h3>'.format(\n",
    "                            child['name'], \n",
    "                            typeName,\n",
    "                            isOptional,\n",
    "                            funcModifierStr,\n",
    "                            defaultValue\n",
    "                        ))\n",
    "                        refTypes.append(typeName)\n",
    "                        htmlProperty.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(getComment(child)))\n",
    "                        htmlProperty.append('')\n",
    "                        inputCnt += 1\n",
    "                if len(htmlProperty) > 0 :\n",
    "                    html.append('\t\t<h2>Properties</h2>')\n",
    "                    html.append('\t\t{0}'.format('\\n'.join(htmlProperty)))\n",
    "                    html.append('')\n",
    "                htmlMethod = []\n",
    "                methodCnt = 0\n",
    "                if len(extends) > 0 :\n",
    "                    for ext in extends :\n",
    "                        htmlMethod.append('\t\t<p>')\n",
    "                        htmlMethod.append('\t\t\tSee the base [page:{0} {0}] class for common methods.'.format(ext))\n",
    "                        htmlMethod.append('\t\t</p>')\n",
    "                        methodCnt += 1\n",
    "                    htmlMethod.append('')\n",
    "                for child in info['children'] :        \n",
    "                    sources = getSourceFile(child)\n",
    "                    kindString = child['kindString']\n",
    "                    flags = child['flags']\n",
    "                    if (kindString == 'Method') and (\n",
    "                        parentkindString == \"Interface\" or ('isPublic' in flags and flags['isPublic']) or ('isProtected' in flags and flags['isProtected'])) :\n",
    "                        params = []\n",
    "                        returnType  = 'void' \n",
    "                        comment = None\n",
    "                        paramsComments = []\n",
    "                        funcModifier = []\n",
    "                        if 'isPublic' in flags and flags['isPublic'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-public\">Public</i>')\n",
    "                        elif 'isPrivate' in flags and flags['isPrivate'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-private\">Private</i>')\n",
    "                        if 'isProtected' in flags and flags['isProtected'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-protected\">Protected</i>')\n",
    "                        if 'isStatic' in flags and flags['isStatic'] :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-static\">Static</i>')\n",
    "                        if 'overwrites' in child :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-overwrite\">Overwrite</i>')\n",
    "                        if 'inheritedFrom' in child :\n",
    "                            funcModifier.append('<i class=\"modifier modifier-inherited\">Inherited</i>')\n",
    "                        funcModifierStr = ' '.join(funcModifier)\n",
    "                        if 'signatures' in child :\n",
    "                            for signatures in child['signatures'] :\n",
    "                                returnType = getReturnType(signatures)\n",
    "                                comment = getComment(signatures)\n",
    "                                if 'parameters' in signatures :\n",
    "                                    for parameters in signatures['parameters'] :\n",
    "                                        typeName = getParamTypes(parameters)\n",
    "                                        isOptional = ''\n",
    "                                        paramComment = ''\n",
    "                                        isOptionalComment = ''\n",
    "                                        if 'flags' in parameters and 'isOptional' in parameters['flags'] and  parameters['flags']['isOptional'] :\n",
    "                                            isOptional = '?'\n",
    "                                            isOptionalComment = '(optional) '\n",
    "                                        if 'comment' in parameters and 'shortText' in parameters['comment'] :\n",
    "                                            paramComment = getCommentParse(parameters['comment']['shortText'].strip())\n",
    "                                        params.append(\" [param:{0} {1}]{2}\".format(typeName, parameters['name'], isOptional)); \n",
    "                                        refTypes.append(typeName)\n",
    "                                        if paramComment == '' :\n",
    "                                            paramComment = \"The {0}.\".format(camel2SnameSpace(parameters['name']))\n",
    "                                        paramsComments.append(\"[parameter:{0} {1}] - {2}{3}\".format(typeName, parameters['name'], isOptionalComment, paramComment)); \n",
    "                        htmlMethod.append('\t\t<h3>[method:{1} {0}]( {2} ){3}</h3>'.format(\n",
    "                            child['name'], \n",
    "                            returnType,\n",
    "                            \", \".join(params),\n",
    "                            funcModifierStr\n",
    "                        ))\n",
    "                        if len(paramsComments) > 0 :\n",
    "                            htmlMethod.append('\t\t<h4>Parameters</h4>\\n\\t\\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(\"<br />\\n\\t\\t\\t\".join(paramsComments)))\n",
    "                        if comment is not None :\n",
    "                            htmlMethod.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(comment))\n",
    "                        htmlMethod.append('')\n",
    "                        methodCnt += 1\n",
    "                if len(htmlMethod) > 0 :\n",
    "                    html.append('\t\t<h2>Methods</h2>')\n",
    "                    html.append('\t\t{0}'.format('\\n'.join(htmlMethod)))\n",
    "                    html.append('')\n",
    "    else :\n",
    "        pass\n",
    "        # print(kindString)\n",
    "        # print(info)\n",
    "\n",
    "    if 'sources' in info :\n",
    "        sourcesPath = info['sources'][0]['fileName']\n",
    "        refClassList = getSameSourceFile(refTypes, nameSpace)\n",
    "        interfaceHtmlLine = []\n",
    "        for mchild in refClassList :\n",
    "            extends = getExtends(mchild)\n",
    "            interfaceHtml = getExtraInterFace(mchild, extends)\n",
    "            if interfaceHtml is not None and len(interfaceHtml) > 0 :\n",
    "                mChildName = mchild['name']\n",
    "                extendHtml = []\n",
    "                if len(extends) > 0 :\n",
    "                    for ext in extends :\n",
    "                        extendHtml.append(\"[page:{0}] &rarr;\".format(ext))\n",
    "                interFacekindString = mchild['kindString']\n",
    "                interfaceHtmlLine.append('\t\t<h3 id=\"{0}\" class=\"interface\">{2} {0} <i class=\"modifier modifier-interface\">{1}</i></h3>'.format(mChildName, interFacekindString, \" \".join(extendHtml)))\n",
    "                interfaceHtmlLine.append(interfaceHtml)\n",
    "                interfaceHtmlLine.append('')\n",
    "                interfaceHtmlLine.append('\t\t<p class=\"desc\">\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(getComment(mchild)))\n",
    "                interfaceHtmlLine.append('')\n",
    "\n",
    "        if len(interfaceHtmlLine) > 0 :\n",
    "            html.append(\"\t\t<h2>Interfaces</h2>\")\n",
    "            html.append(\"\\n\".join(interfaceHtmlLine))\n",
    "        html.append('\t\t<br /><br />')\n",
    "\n",
    "        html.append('\t\t<h2>Source</h2>')\n",
    "        html.append('\t\t<p>[link:https://github.com/outmindkjg/ngx3js-module/tree/master/projects/ngx3js/src/lib{0}.ts {0}.ts]</p>'.format(sourcesPath[3:-3]))\n",
    "    html.append('\t</body>')\n",
    "    html.append('</html>')\n",
    "    html = re.sub('<br />[ \\t\\n]*<br />', r'<br />', \"\\n\".join(html))\n",
    "    if className == 'TWEEN' :\n",
    "        saveFile('src/assets/ngxapi/en/{0}.html'.format('TweenMain'),html)\n",
    "    else :\n",
    "        saveFile('src/assets/ngxapi/en/{0}.html'.format(className),html)\n",
    "    return True\n",
    "\n",
    "def getCommentCode(comment : str, isTop : bool = False) :\n",
    "    restComment = comment\n",
    "    restComment = restComment.replace('>','&gt;').replace('<','&lt;').replace('] |',']')\n",
    "    if isTop :\n",
    "        restComment = re.sub('#### ([a-zA-Z0-9 ]+)', r'<h3>\\1</h3>', restComment)\n",
    "        restComment = re.sub('### ([a-zA-Z0-9 ]+)', r'<h2>\\1</h2>', restComment)\n",
    "    else :\n",
    "        restComment = re.sub('#### ([a-zA-Z0-9 ]+)', r'<h5>\\1</h5>', restComment)\n",
    "        restComment = re.sub('### ([a-zA-Z0-9 ]+)', r'<h4>\\1</h4>', restComment)\n",
    "    if restComment is not None and restComment.find(\"```\") > -1 :\n",
    "        whileCnt = 0\n",
    "        while restComment.find(\"```\") > -1 and whileCnt < 5:\n",
    "            whileCnt += 1\n",
    "            start = restComment.find(\"```\")\n",
    "            end = restComment.find(\"```\", start + 5)\n",
    "            blockType = 'text'\n",
    "            conStart = start + 3\n",
    "            if restComment[conStart: conStart+2] == 'ts' :\n",
    "                conStart += 2\n",
    "                blockType = 'typescript'\n",
    "            elif restComment[conStart: conStart+4] == 'html' :\n",
    "                conStart += 4\n",
    "                blockType = 'html'\n",
    "            elif restComment[conStart: conStart+4] == 'text' :\n",
    "                conStart += 4\n",
    "                blockType = 'text'\n",
    "            elif restComment[conStart: conStart+3] == 'css' :\n",
    "                conStart += 3\n",
    "                blockType = 'css'\n",
    "            elif restComment[conStart: conStart+4] == 'scss' :\n",
    "                conStart += 4\n",
    "                blockType = 'scss'\n",
    "            elif restComment[conStart: conStart+2] == 'js' :\n",
    "                conStart += 2\n",
    "                blockType = 'javascript'\n",
    "            elif restComment[conStart: conStart+10] == 'javascript' :\n",
    "                conStart += 10\n",
    "                blockType = 'javascript'\n",
    "            planeHtml = restComment[conStart: end]\n",
    "            planeHtml = planeHtml.replace('>','&gt;')\n",
    "            planeHtml = planeHtml.replace('<','&lt;')\n",
    "            restComment = restComment[0: start] + '<code data-type=\"'+blockType+'\">' +  planeHtml + '</code>' + restComment[end + 3:]\n",
    "        if whileCnt >= 4 : \n",
    "            print(restComment)\n",
    "    return restComment\n",
    "\n",
    "def getReturnType(signatures) :\n",
    "    returnType = 'void'\n",
    "    if 'type' in signatures :\n",
    "        if 'name' in signatures['type'] :\n",
    "            returnType = signatures['type']['name']\n",
    "        elif 'type' in signatures['type'] :\n",
    "            childType = signatures['type']['type']\n",
    "            if childType == 'union' and 'types' in signatures['type'] :\n",
    "                typeNames = []\n",
    "                for typeInfo in signatures['type']['types'] :\n",
    "                    if 'name' in typeInfo :\n",
    "                        typeNames.append('{0}'.format(typeInfo['name']))\n",
    "                    elif typeInfo['type'] == 'array' and 'elementType' in typeInfo and 'name' in typeInfo['elementType']:\n",
    "                        typeNames.append('{0}[]'.format(typeInfo['elementType']['name']))\n",
    "                if len(typeNames) > 0 :\n",
    "                    returnType = \"|\".join(typeNames).strip()\n",
    "            elif childType == 'array' and 'elementType' in signatures['type'] and 'name' in signatures['type']['elementType'] :\n",
    "                returnType = '{0}[]'.format(signatures['type']['elementType']['name'])\n",
    "\n",
    "    return returnType\n",
    "\n",
    "\n",
    "def getComment(info, demoCheck : bool = False) :\n",
    "    commentHtml = ''\n",
    "    comment = None\n",
    "    commentTxt = []\n",
    "    funcReturns = ''\n",
    "    shortText = ''\n",
    "    if \"comment\" in info :\n",
    "        comment = info['comment']\n",
    "    if comment is not None :\n",
    "        if 'shortText' in comment :\n",
    "            shortText = getCommentCode(comment['shortText'].strip(), demoCheck) + \"\\n\"\n",
    "        if 'text' in comment :\n",
    "            commentTxt.append(getCommentCode(comment['text'].strip(), demoCheck))\n",
    "        if 'tags' in comment :\n",
    "            tagHtml = []\n",
    "            for tags in comment['tags'] :\n",
    "                if (tags['tag'] == 'deprecated'):\n",
    "                    tagText = tags['text'].strip()\n",
    "                    tagHtml.append(\"deprecated - {0}\".format(\n",
    "                        tagText\n",
    "                    ))\n",
    "                if (tags['tag'] == 'see'):\n",
    "                    tagText = tags['text'].strip()\n",
    "                    if tagText.endswith(\",\") : \n",
    "                        tagText = tagText[0:-1]\n",
    "                    threeSelector = re.compile(\"THREE\\.([a-zA-Z0-9]+)\")\n",
    "                    matches = threeSelector.findall(tagText)\n",
    "                    if matches :\n",
    "                        tagHtml.append(\"[page:{0} {0}] - {1}\".format(\n",
    "                            matches[0],\n",
    "                            tagText\n",
    "                        ))\n",
    "                    else :\n",
    "                        linkSelector = re.compile(\"{@link (.+)\\|(.+)\\}\")\n",
    "                        matches = linkSelector.findall(tagText)\n",
    "                        if matches :\n",
    "                            linkUrl = matches[0][0].strip()\n",
    "                            linkName = matches[0][1].strip()\n",
    "                            if linkUrl.startswith('https://outmindkjg.github.io/ngx3js-doc/#/examples/') : \n",
    "                                tagHtml.append(\"[example:{0} {1}] \".format(\n",
    "                                    linkUrl[51:],\n",
    "                                    linkName\n",
    "                                ))\n",
    "                            else :\n",
    "                                tagHtml.append(\"[link:{0} {1}]\".format(\n",
    "                                    linkUrl,\n",
    "                                    linkName\n",
    "                                ))\n",
    "            if len(tagHtml) > 0 :\n",
    "                commentTxt.append(\"\")\n",
    "                commentTxt.append(\"\\n\".join(tagHtml).strip())\n",
    "    if 'type' in info and 'type' in info['type']['type']:\n",
    "        childType = info['type']['type']\n",
    "        if childType == 'union' :\n",
    "            typeNames = []\n",
    "            for typeInfo in info['type']['types'] :\n",
    "                if 'name' in typeInfo :\n",
    "                    typeNames.append('[parameter:{0} {0}]'.format(typeInfo['name']))\n",
    "                elif typeInfo['type'] == 'array' and 'elementType' in typeInfo and 'name' in typeInfo['elementType']:\n",
    "                    typeNames.append('[parameter:{0} {0}]'.format(typeInfo['elementType']['name']))\n",
    "            if len(typeNames) > 0 :\n",
    "                commentTxt.append(\"\")\n",
    "                commentTxt.append(\" | \".join(typeNames).strip())\n",
    "        elif childType == 'reflection' and 'declaration' in info['type']:\n",
    "            declaration = info['type']['declaration']\n",
    "            if 'indexSignature' in declaration :\n",
    "                parameters = declaration['indexSignature']['parameters']\n",
    "                key = parameters[0]['name']\n",
    "                keyType = parameters[0]['type']['name']\n",
    "                value = 'any'\n",
    "                if 'name' in declaration['indexSignature']['type'] :\n",
    "                    value = declaration['indexSignature']['type']['name']\n",
    "                commentTxt.append(\"\")\n",
    "                commentTxt.append(\" {{ [ {0} : [page:{1} {1}] ] : [page:{2} {2}] }} \".format(key, keyType, value ))\n",
    "    funcComment = ''\n",
    "    if comment is not None :\n",
    "        if 'returns' in comment :\n",
    "            funcComment = comment['returns'].strip()\n",
    "    if funcComment != '' or funcReturns != '':\n",
    "        commentTxt.append(\"\")\n",
    "        commentTxt.append(\"Returns : {0} {1}\".format(funcComment, funcReturns ))\n",
    "    if len(commentTxt) == 0 :\n",
    "        commentTxt.append(shortText)\n",
    "        shortText = ''\n",
    "    if len(commentTxt) > 0 :\n",
    "        commentHtml = \"\\n\".join(commentTxt)\n",
    "        commentHtml = commentHtml.replace(\"_@Component\",\"@Component\").replace(\"_@Directive\",\"@Directive\").replace(\"_@Pipe\",\"@Pipe\")\n",
    "        commentHtml = commentHtml.replace(\"<br>\",\"\").replace(\"<br/>\",\"\").replace(\"<br />\",\"\")\n",
    "        commentHtml = getCommentParse(commentHtml.replace(\"\\n\\n\\n\",\"\\n\\n\"))\n",
    "        if demoCheck :\n",
    "            previewSelector = re.compile(\"\\[example:([A-Za-z/_0-9]+) ([^\\]]+)\\]\")\n",
    "            matches = previewSelector.findall(commentHtml)\n",
    "            if matches :\n",
    "                linkUrl = matches[0][0].strip()\n",
    "                linkName = matches[0][1].strip()\n",
    "                commentHtml =  shortText + '\\n<h3>Preview - {0}</h3>\\n<iframe src=\"#/viewer/{1}\"></iframe>\\n\\n'.format(linkName, linkUrl) + commentHtml\n",
    "            else :\n",
    "                commentHtml =  shortText + commentHtml\n",
    "        else :\n",
    "            commentHtml =  shortText + commentHtml\n",
    "        commentHtml = getCommentParse(commentHtml)\n",
    "        commentHtml = commentHtml.strip().replace(\"\\n\",\"<br />\\n\\t\\t\\t\").strip()\n",
    "    return commentHtml\n",
    "\n",
    "\n",
    "def getSameSourceFile(refList, nameSpace = None) :\n",
    "    list = []\n",
    "    refListChecked = {}\n",
    "    for txt in refList :\n",
    "        txtList = txt.split('|')\n",
    "        for s in txtList :\n",
    "            if s.endswith('[]') :\n",
    "                s = s[0:-2]\n",
    "            if s not in refListChecked:\n",
    "                if len(s) > 3 and not s.endswith('Component') and not s.endswith('Service') and not s.endswith('Pipe') and not s.endswith('Directive') :\n",
    "                    if s != 'SimpleChanges' and s != 'EventEmitter' and s != 'True' and s != 'Subscription' and s != 'string' and s != 'boolean' and s != 'number' and s != 'any':\n",
    "                        refListChecked[s] = False\n",
    "    nameSpaceApi = []\n",
    "    if nameSpace is None or nameSpace == '' :\n",
    "        nameSpaceApi = simpleApi\n",
    "    else :\n",
    "        for info in simpleApi :\n",
    "            if 'children' in info and info['name'] == nameSpace :\n",
    "                nameSpaceApi = info['children']\n",
    "    for info in nameSpaceApi :\n",
    "        name = info[\"name\"]\n",
    "        if name in refListChecked and not refListChecked[name] :\n",
    "            list.append(info)\n",
    "            refListChecked[name] = True\n",
    "    for info in simpleApi :\n",
    "        name = info[\"name\"]\n",
    "        if name in refListChecked and not refListChecked[name]:\n",
    "            list.append(info)\n",
    "            refListChecked[name] = True\n",
    "    for info in i3JSApi :\n",
    "        name = info[\"name\"]\n",
    "        if name in refListChecked and not refListChecked[name]:\n",
    "            list.append(info)\n",
    "            refListChecked[name] = True\n",
    "    return list\n",
    "\n",
    "def getParamTypes(child) :\n",
    "    typeName = 'any'\n",
    "    if 'type' in child and 'type' in child['type']:\n",
    "        childType = child['type']['type']\n",
    "        if childType == 'union' :\n",
    "            typeNames = []\n",
    "            for typeInfo in child['type']['types'] :\n",
    "                if 'name' in typeInfo :\n",
    "                    typeNames.append(typeInfo['name'])\n",
    "                elif typeInfo['type'] == 'literal' and 'value' in typeInfo:\n",
    "                    typeNames.append(\"'{0}'\".format(typeInfo['value']))\n",
    "                elif typeInfo['type'] == 'array' and 'elementType' in typeInfo and 'name' in typeInfo['elementType']:\n",
    "                    typeNames.append(typeInfo['elementType']['name'] + \"[]\")\n",
    "            typeName = '|'.join(typeNames)\n",
    "            # typeName = 'mixed'\n",
    "        elif childType == 'array' : \n",
    "            if 'elementType' in child['type'] and 'name' in child['type']['elementType'] :\n",
    "                typeName = child['type']['elementType']['name'] + \"[]\"\n",
    "        elif 'name' in child['type']:\n",
    "            typeName = child['type']['name']\n",
    "    return typeName.replace('NGX3JS.','').replace('O3JS.','THREE.')\n",
    "\n",
    "def getExtraInterFace(mchild, extends):\n",
    "    html = []\n",
    "    fileName = getSourceFile(mchild)\n",
    "    kindString = mchild[\"kindString\"]\n",
    "    intfaceName = mchild[\"name\"]\n",
    "    if kindString == \"Interface\" or kindString == 'Enumeration' :\n",
    "        propertiesCnt = 0\n",
    "        if \"children\" in mchild:\n",
    "            properties = []\n",
    "            methods = []\n",
    "            constructorsFunc = [] \n",
    "            for child in mchild['children'] :        \n",
    "                sources = getSourceFile(child)\n",
    "                kindString = child['kindString']\n",
    "                if kindString == 'Property' or kindString == 'Enumeration member':\n",
    "                    if kindString == 'Enumeration member' :\n",
    "                        typeName = intfaceName\n",
    "                    else :\n",
    "                        typeName = getParamTypes(child)\n",
    "                    isOptional = ''\n",
    "                    if 'flags' in child and 'isOptional' in child['flags'] and  child['flags']['isOptional'] :\n",
    "                        isOptional = '?'\n",
    "                    paramComment = getComment(child, False)\n",
    "                    if paramComment is None or paramComment == '' :\n",
    "                        paramComment = ' The {0}.'.format(camel2SnameSpace(child['name']))\n",
    "                    defaultValue = ''\n",
    "                    if 'defaultValue' in child :\n",
    "                        defaultValue = ' = {0}'.format(child['defaultValue'])\n",
    "                    properties.append('[property:{1} {0}]{2}{4} - {3}'.format(\n",
    "                        child['name'], \n",
    "                        typeName,\n",
    "                        isOptional,\n",
    "                        paramComment,\n",
    "                        defaultValue\n",
    "                    ))\n",
    "                    propertiesCnt += 1\n",
    "                elif kindString == 'Method' or kindString == 'Constructor' :\n",
    "                    params = []\n",
    "                    returnType  = 'void' \n",
    "                    comment = None\n",
    "                    methodsProperties = []\n",
    "                    for signatures in child['signatures'] :\n",
    "                        returnType = getReturnType(signatures)\n",
    "                        comment = getComment(signatures)\n",
    "                        if 'parameters' in signatures :\n",
    "                            for parameters in signatures['parameters'] :\n",
    "                                typeName = getParamTypes(parameters)\n",
    "                                isOptional = ''\n",
    "                                if 'flags' in parameters and 'isOptional' in parameters['flags'] and  parameters['flags']['isOptional'] :\n",
    "                                    isOptional = '?'\n",
    "                                params.append(\" [param:{0} {1}]{2}\".format(typeName, parameters['name'], isOptional)); \n",
    "                                paramComment = getComment(parameters)\n",
    "                                if paramComment is None or paramComment == '' :\n",
    "                                    paramComment = ' The {0}.'.format(camel2SnameSpace(parameters['name']))\n",
    "                                methodsProperties.append('[property:{1} {0}]{2} - {3}'.format(\n",
    "                                    parameters['name'], \n",
    "                                    typeName,\n",
    "                                    isOptional,\n",
    "                                    paramComment\n",
    "                                ))\n",
    "                        childName = child['name']\n",
    "                        if childName == '__type':\n",
    "                            childName = 'function'\n",
    "                        if comment is not None and len(comment) > 1:\n",
    "                            comment = '- ' + comment\n",
    "                        if kindString == 'Constructor' :\n",
    "                            constructorsFunc.append('[constructor:{1} {0}]( {2} ) {3}'.format(\n",
    "                                returnType, \n",
    "                                returnType,\n",
    "                                \", \".join(params),\n",
    "                                comment\n",
    "                            ))\n",
    "                        else :\n",
    "                            methods.append('[method:{1} {0}]( {2} ) {3}'.format(\n",
    "                                childName, \n",
    "                                returnType,\n",
    "                                \", \".join(params),\n",
    "                                comment\n",
    "                            ))\n",
    "            if len(constructorsFunc) > 0 :\n",
    "                html.append('\t\t<h4>Constructor</h4>')\n",
    "                html.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format('<br />\\n\\t\\t\\t'.join(constructorsFunc)))                    \n",
    "            if len(properties) > 0 :\n",
    "                html.append('\t\t<h4>Properties</h4>')\n",
    "                html.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format('<br />\\n\\t\\t\\t'.join(properties)))                    \n",
    "            if len(methods) > 0 :\n",
    "                html.append('\t\t<h4>Methods</h4>')\n",
    "                html.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format('<br />\\n\\t\\t\\t'.join(methods)))                    \n",
    "    elif kindString == \"Type alias\" or kindString == 'Variable':\n",
    "        typeInfo = mchild['type']\n",
    "        typeName = typeInfo['type']\n",
    "        if typeName == 'reflection' :\n",
    "            params = []\n",
    "            returnType  = 'void' \n",
    "            comment = None\n",
    "            child = typeInfo['declaration']\n",
    "            if 'signatures' in child :\n",
    "                for signatures in child['signatures'] :\n",
    "                    returnType = getReturnType(signatures)\n",
    "                    comment = getComment(signatures)\n",
    "                    properties = []\n",
    "                    if 'parameters' in signatures :\n",
    "                        for parameters in signatures['parameters'] :\n",
    "                            typeName = getParamTypes(parameters)\n",
    "                            isOptional = ''\n",
    "                            if 'flags' in parameters and 'isOptional' in parameters['flags'] and  parameters['flags']['isOptional'] :\n",
    "                                isOptional = '?'\n",
    "                            params.append(\" [param:{0} {1}]{2}\".format(typeName, parameters['name'], isOptional)); \n",
    "                            paramComment = getComment(parameters)\n",
    "                            if paramComment is None or paramComment == '' :\n",
    "                                paramComment = ' The {0}.'.format(camel2SnameSpace(parameters['name']))\n",
    "                            properties.append('[property:{1} {0}]{2} - {3}'.format(\n",
    "                                parameters['name'], \n",
    "                                typeName,\n",
    "                                isOptional,\n",
    "                                paramComment\n",
    "                            ))\n",
    "                childName = child['name']\n",
    "                if childName == '__type':\n",
    "                    childName = 'function'\n",
    "                html.append('\t\t<h4>[method:{1} {0}]( {2} )</h4>'.format(\n",
    "                    childName, \n",
    "                    returnType,\n",
    "                    \", \".join(params)\n",
    "                ))\n",
    "                if len(properties) > 0 :\n",
    "                    html.append('\t\t<h4>Parameters</h4>')\n",
    "                    html.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format('<br />\\n\\t\\t\\t'.join(properties)))\n",
    "            if 'indexSignature' in child :\n",
    "                signatures = child['indexSignature']\n",
    "                returnType = getReturnType(signatures)\n",
    "                comment = getComment(signatures)\n",
    "                if 'parameters' in signatures :\n",
    "                    for parameters in signatures['parameters'] :\n",
    "                        typeName = getParamTypes(parameters)\n",
    "                        isOptional = ''\n",
    "                        if 'flags' in child and 'isOptional' in child['flags'] and  child['flags']['isOptional'] :\n",
    "                            isOptional = '?'\n",
    "                        params.append(\" [param:{0} {1}]{2}\".format(typeName, parameters['name'], isOptional)); \n",
    "                html.append('\t\t<h3> {{ [ {2} ] : [param:{1} emptyName] }}</h3>'.format(\n",
    "                    child['name'], \n",
    "                    returnType,\n",
    "                    \", \".join(params)\n",
    "                ))\n",
    "            \n",
    "            if comment is not None :\n",
    "                html.append('\t\t<p>\\n\\t\\t\\t{0}\\n\\t\\t</p>'.format(comment))\n",
    "            html.append('')\n",
    "        elif typeName == 'union' :\n",
    "            child = mchild\n",
    "            typeName = getParamTypes(child)\n",
    "            html.append('\t\t<h3>[property:{1} {0}]</h3>'.format(\n",
    "                child['name'], \n",
    "                typeName\n",
    "            ))\n",
    "        html.append('')\n",
    "    else :\n",
    "        print(kindString)\n",
    "    return \"\\n\".join(html)\n",
    "\n",
    "\n",
    "def getCommentParse(commentHtml) :\n",
    "    commentHtml = re.sub('\\[([^\\]]+)\\]\\(([^\\)]+)\\)', r'[link:\\2 \\1]', commentHtml)\n",
    "    commentHtml = re.sub('\\[link:https://outmindkjg.github.io/ngx3js-doc/#/docs/[a-z0-9\\/]+/([a-zA-Z0-9\\.]+) ', r'[page:\\1 ', commentHtml)\n",
    "    commentHtml = re.sub('\\[link:https://outmindkjg.github.io/ngx3js-doc/#/examples/([a-zA-Z_0-9/\\.]+) ', r'[example:\\1 ', commentHtml)\n",
    "    commentHtml = re.sub('\\[example:([^\\]]+)\\] \\|', r'[example:\\1]', commentHtml)\n",
    "    commentHtml = re.sub('&lt;em&gt;([^&]+)&lt;/em&gt;', r'<em>\\1</em>', commentHtml)\n",
    "    \n",
    "    commentHtml = re.sub('\\*([^ ]+)\\*', r'<i>\\1</i>', commentHtml)\n",
    "    tableSelector = re.compile(\"\\n(.+)\\n\\|(:|)--.+\\|\\n.*\")\n",
    "    matches = tableSelector.findall(commentHtml)\n",
    "    if matches :\n",
    "        lines = commentHtml.split('\\n')\n",
    "        newLines = []\n",
    "        headStated = False\n",
    "        bodyStated = False\n",
    "        tableLines = []\n",
    "        for line in lines :\n",
    "            if line.startswith('|') and line.endswith('|') :\n",
    "                if not headStated :\n",
    "                    tableLines = []\n",
    "                    tableLines.append('<table><thead><tr>{0}</tr></thead><tbody>'.format(re.sub('\\|', r'</th><th>', line)))\n",
    "                    bodyStated = True\n",
    "                    headStated = True\n",
    "                elif line.find('---') == -1 :\n",
    "                    tableLines.append('<tr>{0}</tr>'.format(re.sub('\\|', r'</td><td>', line)))\n",
    "            elif bodyStated :\n",
    "                bodyStated = False\n",
    "                headStated = False\n",
    "                tableLines.append('</table>')\n",
    "                newLines.append(' '.join(tableLines))\n",
    "            else :\n",
    "                newLines.append(line)\n",
    "        if bodyStated :\n",
    "            bodyStated = False\n",
    "            headStated = False\n",
    "            tableLines.append('</table>')\n",
    "            newLines.append(re.sub('(<td>|<th>)</tr>','</tr>',re.sub('<tr>(</td>|</th>)','<tr>',' '.join(tableLines))))\n",
    "        commentHtml = '\\n'.join(newLines)\n",
    "    return commentHtml\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Reference\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# getGenApiDocs(\"MeshComponent\")\n",
    "\n",
    "# getGenApiDocs(\"NgxThreeUtil\")\n",
    "getGenApiDocs(\"I3JS\")\n",
    "\n",
    "# getGenApiDocs(\"AbstractGeometryComponent\")\n",
    "# getGenApiDocs(\"GeometryComponent\")\n",
    "# getGenApiDocs(\"GeometryComponent\")\n",
    "# getGenApiDocs(\"AudioComponent\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Reference\n",
      "Function\n",
      "Function\n",
      "Reference\n",
      "Reference\n",
      "Class\n",
      "Function\n",
      "Function\n",
      "Function\n",
      "Function\n",
      "Class\n",
      "Class\n",
      "\"ammo-type\" : {\n",
      "\"AMMO\" : \"ngxapi/en/AMMO\"\n",
      "},\n",
      "\n",
      "\"chartjs.interface\" : {\n",
      "\"CHARTJS\" : \"ngxapi/en/CHARTJS\"\n",
      "},\n",
      "\n",
      "\"echarts.interface\" : {\n",
      "\"ECHARTS\" : \"ngxapi/en/ECHARTS\"\n",
      "},\n",
      "\n",
      "\"three-interface\" : {\n",
      "\"I3JS\" : \"ngxapi/en/I3JS\"\n",
      "},\n",
      "\n",
      "\"nodes-renderer\" : {\n",
      "\"NODES\" : \"ngxapi/en/NODES\"\n",
      "},\n",
      "\n",
      "\"three-core\" : {\n",
      "\"THREE\" : \"ngxapi/en/THREE\"\n",
      "},\n",
      "\n",
      "\"chart-utils\" : {\n",
      "\"ChartUtils\" : \"ngxapi/en/ChartUtils\"\n",
      "},\n",
      "\n",
      "\"circle\" : {\n",
      "\"CurvesCircle\" : \"ngxapi/en/CurvesCircle\"\n",
      "},\n",
      "\n",
      "\"line\" : {\n",
      "\"CurvesLine\" : \"ngxapi/en/CurvesLine\"\n",
      "},\n",
      "\n",
      "\"curveUtils\" : {\n",
      "\"CurvesNormal\" : \"ngxapi/en/CurvesNormal\",\n",
      "\"NgxCurveUtils\" : \"ngxapi/en/NgxCurveUtils\"\n",
      "},\n",
      "\n",
      "\"polygon\" : {\n",
      "\"CurvesPolygon\" : \"ngxapi/en/CurvesPolygon\",\n",
      "\"CurvesRegularPolygon\" : \"ngxapi/en/CurvesRegularPolygon\",\n",
      "\"CurvesRegularPolygonDecagon\" : \"ngxapi/en/CurvesRegularPolygonDecagon\",\n",
      "\"CurvesRegularPolygonDodecagon\" : \"ngxapi/en/CurvesRegularPolygonDodecagon\",\n",
      "\"CurvesRegularPolygonHeptagon\" : \"ngxapi/en/CurvesRegularPolygonHeptagon\",\n",
      "\"CurvesRegularPolygonHexagon\" : \"ngxapi/en/CurvesRegularPolygonHexagon\",\n",
      "\"CurvesRegularPolygonNonagon\" : \"ngxapi/en/CurvesRegularPolygonNonagon\",\n",
      "\"CurvesRegularPolygonOctagon\" : \"ngxapi/en/CurvesRegularPolygonOctagon\",\n",
      "\"CurvesRegularPolygonPentagon\" : \"ngxapi/en/CurvesRegularPolygonPentagon\",\n",
      "\"CurvesRegularPolygonSquare\" : \"ngxapi/en/CurvesRegularPolygonSquare\",\n",
      "\"CurvesRegularPolygonTriangle\" : \"ngxapi/en/CurvesRegularPolygonTriangle\",\n",
      "\"CurvesRegularPolygonUndecagon\" : \"ngxapi/en/CurvesRegularPolygonUndecagon\"\n",
      "},\n",
      "\n",
      "\"rollercoaster\" : {\n",
      "\"CurvesRollerCoaster\" : \"ngxapi/en/CurvesRollerCoaster\"\n",
      "},\n",
      "\n",
      "\"tween\" : {\n",
      "\"CurvesTween\" : \"ngxapi/en/CurvesTween\",\n",
      "\"CurvesTweenBackEaseIn\" : \"ngxapi/en/CurvesTweenBackEaseIn\",\n",
      "\"CurvesTweenBackEaseInOut\" : \"ngxapi/en/CurvesTweenBackEaseInOut\",\n",
      "\"CurvesTweenBackEaseOut\" : \"ngxapi/en/CurvesTweenBackEaseOut\",\n",
      "\"CurvesTweenBounceEaseIn\" : \"ngxapi/en/CurvesTweenBounceEaseIn\",\n",
      "\"CurvesTweenBounceEaseInOut\" : \"ngxapi/en/CurvesTweenBounceEaseInOut\",\n",
      "\"CurvesTweenBounceEaseOut\" : \"ngxapi/en/CurvesTweenBounceEaseOut\",\n",
      "\"CurvesTweenCircEaseIn\" : \"ngxapi/en/CurvesTweenCircEaseIn\",\n",
      "\"CurvesTweenCircEaseInOut\" : \"ngxapi/en/CurvesTweenCircEaseInOut\",\n",
      "\"CurvesTweenCircEaseOut\" : \"ngxapi/en/CurvesTweenCircEaseOut\",\n",
      "\"CurvesTweenCubicEaseIn\" : \"ngxapi/en/CurvesTweenCubicEaseIn\",\n",
      "\"CurvesTweenCubicEaseInOut\" : \"ngxapi/en/CurvesTweenCubicEaseInOut\",\n",
      "\"CurvesTweenCubicEaseOut\" : \"ngxapi/en/CurvesTweenCubicEaseOut\",\n",
      "\"CurvesTweenElasticEaseIn\" : \"ngxapi/en/CurvesTweenElasticEaseIn\",\n",
      "\"CurvesTweenElasticEaseInOut\" : \"ngxapi/en/CurvesTweenElasticEaseInOut\",\n",
      "\"CurvesTweenElasticEaseOut\" : \"ngxapi/en/CurvesTweenElasticEaseOut\",\n",
      "\"CurvesTweenExpoEaseIn\" : \"ngxapi/en/CurvesTweenExpoEaseIn\",\n",
      "\"CurvesTweenExpoEaseInOut\" : \"ngxapi/en/CurvesTweenExpoEaseInOut\",\n",
      "\"CurvesTweenExpoEaseOut\" : \"ngxapi/en/CurvesTweenExpoEaseOut\",\n",
      "\"CurvesTweenLinearEaseIn\" : \"ngxapi/en/CurvesTweenLinearEaseIn\",\n",
      "\"CurvesTweenLinearEaseInOut\" : \"ngxapi/en/CurvesTweenLinearEaseInOut\",\n",
      "\"CurvesTweenLinearEaseNone\" : \"ngxapi/en/CurvesTweenLinearEaseNone\",\n",
      "\"CurvesTweenLinearEaseOut\" : \"ngxapi/en/CurvesTweenLinearEaseOut\",\n",
      "\"CurvesTweenQuadEaseIn\" : \"ngxapi/en/CurvesTweenQuadEaseIn\",\n",
      "\"CurvesTweenQuadEaseInOut\" : \"ngxapi/en/CurvesTweenQuadEaseInOut\",\n",
      "\"CurvesTweenQuadEaseOut\" : \"ngxapi/en/CurvesTweenQuadEaseOut\",\n",
      "\"CurvesTweenQuartEaseIn\" : \"ngxapi/en/CurvesTweenQuartEaseIn\",\n",
      "\"CurvesTweenQuartEaseInOut\" : \"ngxapi/en/CurvesTweenQuartEaseInOut\",\n",
      "\"CurvesTweenQuartEaseOut\" : \"ngxapi/en/CurvesTweenQuartEaseOut\",\n",
      "\"CurvesTweenQuintEaseIn\" : \"ngxapi/en/CurvesTweenQuintEaseIn\",\n",
      "\"CurvesTweenQuintEaseInOut\" : \"ngxapi/en/CurvesTweenQuintEaseInOut\",\n",
      "\"CurvesTweenQuintEaseOut\" : \"ngxapi/en/CurvesTweenQuintEaseOut\",\n",
      "\"CurvesTweenSineEaseIn\" : \"ngxapi/en/CurvesTweenSineEaseIn\",\n",
      "\"CurvesTweenSineEaseInOut\" : \"ngxapi/en/CurvesTweenSineEaseInOut\",\n",
      "\"CurvesTweenSineEaseOut\" : \"ngxapi/en/CurvesTweenSineEaseOut\"\n",
      "},\n",
      "\n",
      "\"loaders\" : {\n",
      "\"FontZipLoader\" : \"ngxapi/en/FontZipLoader\",\n",
      "\"AMFLoader\" : \"ngxapi/en/AMFLoader\",\n",
      "\"AnimationLoader\" : \"ngxapi/en/AnimationLoader\",\n",
      "\"AudioLoader\" : \"ngxapi/en/AudioLoader\",\n",
      "\"BVHLoader\" : \"ngxapi/en/BVHLoader\",\n",
      "\"BasisTextureLoader\" : \"ngxapi/en/BasisTextureLoader\",\n",
      "\"BufferGeometryLoader\" : \"ngxapi/en/BufferGeometryLoader\",\n",
      "\"Cache\" : \"ngxapi/en/Cache\",\n",
      "\"ColladaLoader\" : \"ngxapi/en/ColladaLoader\",\n",
      "\"CompressedTextureLoader\" : \"ngxapi/en/CompressedTextureLoader\",\n",
      "\"CubeTextureLoader\" : \"ngxapi/en/CubeTextureLoader\",\n",
      "\"DDSLoader\" : \"ngxapi/en/DDSLoader\",\n",
      "\"DRACOLoader\" : \"ngxapi/en/DRACOLoader\",\n",
      "\"DataTextureLoader\" : \"ngxapi/en/DataTextureLoader\",\n",
      "\"EXRLoader\" : \"ngxapi/en/EXRLoader\",\n",
      "\"FBXLoader\" : \"ngxapi/en/FBXLoader\",\n",
      "\"FileLoader\" : \"ngxapi/en/FileLoader\",\n",
      "\"Font\" : \"ngxapi/en/Font\",\n",
      "\"FontLoader\" : \"ngxapi/en/FontLoader\",\n",
      "\"GCodeLoader\" : \"ngxapi/en/GCodeLoader\",\n",
      "\"GLTFLoader\" : \"ngxapi/en/GLTFLoader\",\n",
      "\"HDRCubeTextureLoader\" : \"ngxapi/en/HDRCubeTextureLoader\",\n",
      "\"IFCLoader\" : \"ngxapi/en/IFCLoader\",\n",
      "\"ImageBitmapLoader\" : \"ngxapi/en/ImageBitmapLoader\",\n",
      "\"ImageLoader\" : \"ngxapi/en/ImageLoader\",\n",
      "\"KMZLoader\" : \"ngxapi/en/KMZLoader\",\n",
      "\"KTX2Loader\" : \"ngxapi/en/KTX2Loader\",\n",
      "\"KTXLoader\" : \"ngxapi/en/KTXLoader\",\n",
      "\"LDrawLoader\" : \"ngxapi/en/LDrawLoader\",\n",
      "\"LUT3dlLoader\" : \"ngxapi/en/LUT3dlLoader\",\n",
      "\"LUTCubeLoader\" : \"ngxapi/en/LUTCubeLoader\",\n",
      "\"LWOLoader\" : \"ngxapi/en/LWOLoader\",\n",
      "\"Loader\" : \"ngxapi/en/Loader\",\n",
      "\"LoaderUtils\" : \"ngxapi/en/LoaderUtils\",\n",
      "\"LoadingManager\" : \"ngxapi/en/LoadingManager\",\n",
      "\"LogLuvLoader\" : \"ngxapi/en/LogLuvLoader\",\n",
      "\"LottieLoader\" : \"ngxapi/en/LottieLoader\",\n",
      "\"MD2Loader\" : \"ngxapi/en/MD2Loader\",\n",
      "\"MDDLoader\" : \"ngxapi/en/MDDLoader\",\n",
      "\"MMDLoader\" : \"ngxapi/en/MMDLoader\",\n",
      "\"MTLLoader\" : \"ngxapi/en/MTLLoader\",\n",
      "\"MaterialLoader\" : \"ngxapi/en/MaterialLoader\",\n",
      "\"NRRDLoader\" : \"ngxapi/en/NRRDLoader\",\n",
      "\"NodeMaterialLoader\" : \"ngxapi/en/NodeMaterialLoader\",\n",
      "\"OBJLoader\" : \"ngxapi/en/OBJLoader\",\n",
      "\"ObjectLoader\" : \"ngxapi/en/ObjectLoader\",\n",
      "\"PCDLoader\" : \"ngxapi/en/PCDLoader\",\n",
      "\"PDBLoader\" : \"ngxapi/en/PDBLoader\",\n",
      "\"PLYLoader\" : \"ngxapi/en/PLYLoader\",\n",
      "\"PRWMLoader\" : \"ngxapi/en/PRWMLoader\",\n",
      "\"PVRLoader\" : \"ngxapi/en/PVRLoader\",\n",
      "\"RGBELoader\" : \"ngxapi/en/RGBELoader\",\n",
      "\"RGBMLoader\" : \"ngxapi/en/RGBMLoader\",\n",
      "\"Rhino3dmLoader\" : \"ngxapi/en/Rhino3dmLoader\",\n",
      "\"STLLoader\" : \"ngxapi/en/STLLoader\",\n",
      "\"SVGLoader\" : \"ngxapi/en/SVGLoader\",\n",
      "\"TDSLoader\" : \"ngxapi/en/TDSLoader\",\n",
      "\"TGALoader\" : \"ngxapi/en/TGALoader\",\n",
      "\"TTFLoader\" : \"ngxapi/en/TTFLoader\",\n",
      "\"TextureLoader\" : \"ngxapi/en/TextureLoader\",\n",
      "\"ThreeMFLoader\" : \"ngxapi/en/ThreeMFLoader\",\n",
      "\"TiltLoader\" : \"ngxapi/en/TiltLoader\",\n",
      "\"VOXDataTexture3D\" : \"ngxapi/en/VOXDataTexture3D\",\n",
      "\"VOXLoader\" : \"ngxapi/en/VOXLoader\",\n",
      "\"VOXMesh\" : \"ngxapi/en/VOXMesh\",\n",
      "\"VRMLLoader\" : \"ngxapi/en/VRMLLoader\",\n",
      "\"VRMLoader\" : \"ngxapi/en/VRMLoader\",\n",
      "\"VTKLoader\" : \"ngxapi/en/VTKLoader\",\n",
      "\"XYZLoader\" : \"ngxapi/en/XYZLoader\"\n",
      "},\n",
      "\n",
      "\"ngx3js.module\" : {\n",
      "\"Ngx3JsModule\" : \"ngxapi/en/Ngx3JsModule\"\n",
      "},\n",
      "\n",
      "\"avr-controls\" : {\n",
      "\"NgxAVRControls\" : \"ngxapi/en/NgxAVRControls\",\n",
      "\"VirtualSession\" : \"ngxapi/en/VirtualSession\"\n",
      "},\n",
      "\n",
      "\"controller.component.abstract\" : {\n",
      "\"NgxAbstractControllerComponent\" : \"ngxapi/en/NgxAbstractControllerComponent\"\n",
      "},\n",
      "\n",
      "\"geometry.abstract\" : {\n",
      "\"NgxAbstractGeometryComponent\" : \"ngxapi/en/NgxAbstractGeometryComponent\"\n",
      "},\n",
      "\n",
      "\"material.abstract\" : {\n",
      "\"NgxAbstractMaterialComponent\" : \"ngxapi/en/NgxAbstractMaterialComponent\"\n",
      "},\n",
      "\n",
      "\"object3d.abstract\" : {\n",
      "\"NgxAbstractObject3dComponent\" : \"ngxapi/en/NgxAbstractObject3dComponent\"\n",
      "},\n",
      "\n",
      "\"directive.abstract\" : {\n",
      "\"NgxAbstractObject3dDirective\" : \"ngxapi/en/NgxAbstractObject3dDirective\",\n",
      "\"NgxAbstractThreeDirective\" : \"ngxapi/en/NgxAbstractThreeDirective\"\n",
      "},\n",
      "\n",
      "\"renderer-event.abstract\" : {\n",
      "\"NgxAbstractRendererEventComponent\" : \"ngxapi/en/NgxAbstractRendererEventComponent\"\n",
      "},\n",
      "\n",
      "\"renderer-update.abstract\" : {\n",
      "\"NgxAbstractRendererUpdateComponent\" : \"ngxapi/en/NgxAbstractRendererUpdateComponent\"\n",
      "},\n",
      "\n",
      "\"subscribe.abstract\" : {\n",
      "\"NgxAbstractSubscribeComponent\" : \"ngxapi/en/NgxAbstractSubscribeComponent\"\n",
      "},\n",
      "\n",
      "\"texture.abstract\" : {\n",
      "\"NgxAbstractTextureComponent\" : \"ngxapi/en/NgxAbstractTextureComponent\"\n",
      "},\n",
      "\n",
      "\"controller.abstract\" : {\n",
      "\"NgxAbstractThreeController\" : \"ngxapi/en/NgxAbstractThreeController\",\n",
      "\"NgxAutoMaterialController\" : \"ngxapi/en/NgxAutoMaterialController\",\n",
      "\"NgxAutoPositionController\" : \"ngxapi/en/NgxAutoPositionController\",\n",
      "\"NgxAutoRotationController\" : \"ngxapi/en/NgxAutoRotationController\",\n",
      "\"NgxAutoScaleController\" : \"ngxapi/en/NgxAutoScaleController\",\n",
      "\"NgxAutoUniformsController\" : \"ngxapi/en/NgxAutoUniformsController\"\n",
      "},\n",
      "\n",
      "\"angle.pipe\" : {\n",
      "\"NgxAnglePipe\" : \"ngxapi/en/NgxAnglePipe\"\n",
      "},\n",
      "\n",
      "\"animation-group.component\" : {\n",
      "\"NgxAnimationGroupComponent\" : \"ngxapi/en/NgxAnimationGroupComponent\"\n",
      "},\n",
      "\n",
      "\"three-cameras\" : {\n",
      "\"NgxArrayCamera\" : \"ngxapi/en/NgxArrayCamera\",\n",
      "\"NgxCinematicCamera\" : \"ngxapi/en/NgxCinematicCamera\",\n",
      "\"NgxCubeCamera\" : \"ngxapi/en/NgxCubeCamera\",\n",
      "\"NgxOrthographicCamera\" : \"ngxapi/en/NgxOrthographicCamera\",\n",
      "\"NgxPerspectiveCamera\" : \"ngxapi/en/NgxPerspectiveCamera\",\n",
      "\"NgxStereoCamera\" : \"ngxapi/en/NgxStereoCamera\"\n",
      "},\n",
      "\n",
      "\"asset.pipe\" : {\n",
      "\"NgxAssetsPipe\" : \"ngxapi/en/NgxAssetsPipe\"\n",
      "},\n",
      "\n",
      "\"audio.component\" : {\n",
      "\"NgxAudioComponent\" : \"ngxapi/en/NgxAudioComponent\"\n",
      "},\n",
      "\n",
      "\"background.component\" : {\n",
      "\"NgxBackgroundComponent\" : \"ngxapi/en/NgxBackgroundComponent\"\n",
      "},\n",
      "\n",
      "\"base.component\" : {\n",
      "\"NgxBaseComponent\" : \"ngxapi/en/NgxBaseComponent\"\n",
      "},\n",
      "\n",
      "\"camera.component\" : {\n",
      "\"NgxCameraComponent\" : \"ngxapi/en/NgxCameraComponent\"\n",
      "},\n",
      "\n",
      "\"canvas.component\" : {\n",
      "\"NgxCanvasComponent\" : \"ngxapi/en/NgxCanvasComponent\"\n",
      "},\n",
      "\n",
      "\"capsule\" : {\n",
      "\"NgxCapsuleGeometry\" : \"ngxapi/en/NgxCapsuleGeometry\"\n",
      "},\n",
      "\n",
      "\"circle-depth\" : {\n",
      "\"NgxCircleDepthGeometry\" : \"ngxapi/en/NgxCircleDepthGeometry\"\n",
      "},\n",
      "\n",
      "\"clip.component\" : {\n",
      "\"NgxClipComponent\" : \"ngxapi/en/NgxClipComponent\"\n",
      "},\n",
      "\n",
      "\"color.pipe\" : {\n",
      "\"NgxColorPipe\" : \"ngxapi/en/NgxColorPipe\"\n",
      "},\n",
      "\n",
      "\"control.component\" : {\n",
      "\"NgxControlComponent\" : \"ngxapi/en/NgxControlComponent\"\n",
      "},\n",
      "\n",
      "\"controller.component\" : {\n",
      "\"NgxControllerComponent\" : \"ngxapi/en/NgxControllerComponent\"\n",
      "},\n",
      "\n",
      "\"controller-item.component\" : {\n",
      "\"NgxControllerItemComponent\" : \"ngxapi/en/NgxControllerItemComponent\"\n",
      "},\n",
      "\n",
      "\"curve.component\" : {\n",
      "\"NgxCurveComponent\" : \"ngxapi/en/NgxCurveComponent\"\n",
      "},\n",
      "\n",
      "\"drawing-canvas.directive\" : {\n",
      "\"NgxDrawingCanvasDirective\" : \"ngxapi/en/NgxDrawingCanvasDirective\"\n",
      "},\n",
      "\n",
      "\"effect.component\" : {\n",
      "\"NgxEffectComponent\" : \"ngxapi/en/NgxEffectComponent\"\n",
      "},\n",
      "\n",
      "\"event-proxy.component\" : {\n",
      "\"NgxEventProxyComponent\" : \"ngxapi/en/NgxEventProxyComponent\"\n",
      "},\n",
      "\n",
      "\"fog.component\" : {\n",
      "\"NgxFogComponent\" : \"ngxapi/en/NgxFogComponent\"\n",
      "},\n",
      "\n",
      "\"bird.component\" : {\n",
      "\"NgxGeometryBirdComponent\" : \"ngxapi/en/NgxGeometryBirdComponent\"\n",
      "},\n",
      "\n",
      "\"geometry.component\" : {\n",
      "\"NgxGeometryComponent\" : \"ngxapi/en/NgxGeometryComponent\"\n",
      "},\n",
      "\n",
      "\"geometry-icon.component\" : {\n",
      "\"NgxGeometryIconComponent\" : \"ngxapi/en/NgxGeometryIconComponent\"\n",
      "},\n",
      "\n",
      "\"geometryUtils\" : {\n",
      "\"NgxGeometryUtils\" : \"ngxapi/en/NgxGeometryUtils\",\n",
      "\"GeometryFunctionType\" : \"ngxapi/en/GeometryFunctionType\"\n",
      "},\n",
      "\n",
      "\"grid\" : {\n",
      "\"NgxGridGeometry\" : \"ngxapi/en/NgxGridGeometry\"\n",
      "},\n",
      "\n",
      "\"three-objects\" : {\n",
      "\"NgxHTMLMesh\" : \"ngxapi/en/NgxHTMLMesh\",\n",
      "\"NgxMeshText\" : \"ngxapi/en/NgxMeshText\"\n",
      "},\n",
      "\n",
      "\"helper.component\" : {\n",
      "\"NgxHelperComponent\" : \"ngxapi/en/NgxHelperComponent\"\n",
      "},\n",
      "\n",
      "\"html.component\" : {\n",
      "\"NgxHtmlComponent\" : \"ngxapi/en/NgxHtmlComponent\"\n",
      "},\n",
      "\n",
      "\"keyframe.component\" : {\n",
      "\"NgxKeyframeComponent\" : \"ngxapi/en/NgxKeyframeComponent\"\n",
      "},\n",
      "\n",
      "\"lensflareelement.component\" : {\n",
      "\"NgxLensflareelementComponent\" : \"ngxapi/en/NgxLensflareelementComponent\"\n",
      "},\n",
      "\n",
      "\"light.component\" : {\n",
      "\"NgxLightComponent\" : \"ngxapi/en/NgxLightComponent\"\n",
      "},\n",
      "\n",
      "\"listener.component\" : {\n",
      "\"NgxListenerComponent\" : \"ngxapi/en/NgxListenerComponent\"\n",
      "},\n",
      "\n",
      "\"local-storage.service\" : {\n",
      "\"NgxLocalStorageService\" : \"ngxapi/en/NgxLocalStorageService\"\n",
      "},\n",
      "\n",
      "\"lookat.component\" : {\n",
      "\"NgxLookatComponent\" : \"ngxapi/en/NgxLookatComponent\"\n",
      "},\n",
      "\n",
      "\"material.component\" : {\n",
      "\"NgxMaterialComponent\" : \"ngxapi/en/NgxMaterialComponent\"\n",
      "},\n",
      "\n",
      "\"mesh.component\" : {\n",
      "\"NgxMeshComponent\" : \"ngxapi/en/NgxMeshComponent\"\n",
      "},\n",
      "\n",
      "\"mixer.component\" : {\n",
      "\"NgxMixerComponent\" : \"ngxapi/en/NgxMixerComponent\"\n",
      "},\n",
      "\n",
      "\"object3d-number.directive\" : {\n",
      "\"NgxNumberDirective\" : \"ngxapi/en/NgxNumberDirective\"\n",
      "},\n",
      "\n",
      "\"outline\" : {\n",
      "\"NgxOutlineGeometry\" : \"ngxapi/en/NgxOutlineGeometry\"\n",
      "},\n",
      "\n",
      "\"pass.component\" : {\n",
      "\"NgxPassComponent\" : \"ngxapi/en/NgxPassComponent\"\n",
      "},\n",
      "\n",
      "\"physics.component\" : {\n",
      "\"NgxPhysicsComponent\" : \"ngxapi/en/NgxPhysicsComponent\"\n",
      "},\n",
      "\n",
      "\"physics-constraint.component\" : {\n",
      "\"NgxPhysicsConstraintComponent\" : \"ngxapi/en/NgxPhysicsConstraintComponent\"\n",
      "},\n",
      "\n",
      "\"ngx-pingpong-camera\" : {\n",
      "\"NgxPingPongCamera\" : \"ngxapi/en/NgxPingPongCamera\"\n",
      "},\n",
      "\n",
      "\"plane.component\" : {\n",
      "\"NgxPlaneComponent\" : \"ngxapi/en/NgxPlaneComponent\"\n",
      "},\n",
      "\n",
      "\"plane-controls\" : {\n",
      "\"NgxPlaneControls\" : \"ngxapi/en/NgxPlaneControls\"\n",
      "},\n",
      "\n",
      "\"plane-depth\" : {\n",
      "\"NgxPlaneDepthGeometry\" : \"ngxapi/en/NgxPlaneDepthGeometry\"\n",
      "},\n",
      "\n",
      "\"plane-perlin\" : {\n",
      "\"NgxPlanePerlinGeometry\" : \"ngxapi/en/NgxPlanePerlinGeometry\"\n",
      "},\n",
      "\n",
      "\"position.component\" : {\n",
      "\"NgxPositionComponent\" : \"ngxapi/en/NgxPositionComponent\"\n",
      "},\n",
      "\n",
      "\"object3d-position.directive\" : {\n",
      "\"NgxPositionDirective\" : \"ngxapi/en/NgxPositionDirective\"\n",
      "},\n",
      "\n",
      "\"three-materials\" : {\n",
      "\"NgxRawShaderMaterial\" : \"ngxapi/en/NgxRawShaderMaterial\",\n",
      "\"NgxShaderAttributeSizeColor1Material\" : \"ngxapi/en/NgxShaderAttributeSizeColor1Material\",\n",
      "\"NgxShaderAttributeSizeColorMaterial\" : \"ngxapi/en/NgxShaderAttributeSizeColorMaterial\",\n",
      "\"NgxShaderAttributesParticlesMaterial\" : \"ngxapi/en/NgxShaderAttributesParticlesMaterial\",\n",
      "\"NgxShaderAudioVisualizerMaterial\" : \"ngxapi/en/NgxShaderAudioVisualizerMaterial\",\n",
      "\"NgxShaderCloudMaterial\" : \"ngxapi/en/NgxShaderCloudMaterial\",\n",
      "\"NgxShaderColorRainbowMaterial\" : \"ngxapi/en/NgxShaderColorRainbowMaterial\",\n",
      "\"NgxShaderCustomAttributesLinesMaterial\" : \"ngxapi/en/NgxShaderCustomAttributesLinesMaterial\",\n",
      "\"NgxShaderCustomAttributesMaterial\" : \"ngxapi/en/NgxShaderCustomAttributesMaterial\",\n",
      "\"NgxShaderCustomAttributesPointsMaterial\" : \"ngxapi/en/NgxShaderCustomAttributesPointsMaterial\",\n",
      "\"NgxShaderFresnelMaterial\" : \"ngxapi/en/NgxShaderFresnelMaterial\",\n",
      "\"NgxShaderInstancingMaterial\" : \"ngxapi/en/NgxShaderInstancingMaterial\",\n",
      "\"NgxShaderMaterial\" : \"ngxapi/en/NgxShaderMaterial\",\n",
      "\"NgxShaderNoiseRandom1DMaterial\" : \"ngxapi/en/NgxShaderNoiseRandom1DMaterial\",\n",
      "\"NgxShaderNoiseRandom2DMaterial\" : \"ngxapi/en/NgxShaderNoiseRandom2DMaterial\",\n",
      "\"NgxShaderNoiseRandom3DMaterial\" : \"ngxapi/en/NgxShaderNoiseRandom3DMaterial\",\n",
      "\"NgxShaderParallaxMaterial\" : \"ngxapi/en/NgxShaderParallaxMaterial\",\n",
      "\"NgxShaderPerlinMaterial\" : \"ngxapi/en/NgxShaderPerlinMaterial\",\n",
      "\"NgxShaderRaymarchingReflectMaterial\" : \"ngxapi/en/NgxShaderRaymarchingReflectMaterial\",\n",
      "\"NgxShaderScaleColorMaterial\" : \"ngxapi/en/NgxShaderScaleColorMaterial\",\n",
      "\"NgxShaderSelectiveDrawMaterial\" : \"ngxapi/en/NgxShaderSelectiveDrawMaterial\",\n",
      "\"NgxShaderSinColorMaterial\" : \"ngxapi/en/NgxShaderSinColorMaterial\",\n",
      "\"NgxShaderSkyDomeMaterial\" : \"ngxapi/en/NgxShaderSkyDomeMaterial\",\n",
      "\"NgxShaderSubsurfaceScatteringMaterial\" : \"ngxapi/en/NgxShaderSubsurfaceScatteringMaterial\",\n",
      "\"NgxShaderVideoKinectMaterial\" : \"ngxapi/en/NgxShaderVideoKinectMaterial\",\n",
      "\"NgxShaderVolumeRenderShader1Material\" : \"ngxapi/en/NgxShaderVolumeRenderShader1Material\",\n",
      "\"NgxShaderWireframeMaterial\" : \"ngxapi/en/NgxShaderWireframeMaterial\"\n",
      "},\n",
      "\n",
      "\"render-target.component\" : {\n",
      "\"NgxRenderTargetComponent\" : \"ngxapi/en/NgxRenderTargetComponent\"\n",
      "},\n",
      "\n",
      "\"renderer.component\" : {\n",
      "\"NgxRendererComponent\" : \"ngxapi/en/NgxRendererComponent\"\n",
      "},\n",
      "\n",
      "\"rigidbody.component\" : {\n",
      "\"NgxRigidbodyComponent\" : \"ngxapi/en/NgxRigidbodyComponent\"\n",
      "},\n",
      "\n",
      "\"rigidbody-node.component\" : {\n",
      "\"NgxRigidbodyNodeComponent\" : \"ngxapi/en/NgxRigidbodyNodeComponent\"\n",
      "},\n",
      "\n",
      "\"ring-depth\" : {\n",
      "\"NgxRingDepthGeometry\" : \"ngxapi/en/NgxRingDepthGeometry\"\n",
      "},\n",
      "\n",
      "\"rope\" : {\n",
      "\"NgxRopeGeometry\" : \"ngxapi/en/NgxRopeGeometry\"\n",
      "},\n",
      "\n",
      "\"object3d-rotate.directive\" : {\n",
      "\"NgxRotateDirective\" : \"ngxapi/en/NgxRotateDirective\"\n",
      "},\n",
      "\n",
      "\"rotation.component\" : {\n",
      "\"NgxRotationComponent\" : \"ngxapi/en/NgxRotationComponent\"\n",
      "},\n",
      "\n",
      "\"scale.component\" : {\n",
      "\"NgxScaleComponent\" : \"ngxapi/en/NgxScaleComponent\"\n",
      "},\n",
      "\n",
      "\"object3d-scale.directive\" : {\n",
      "\"NgxScaleDirective\" : \"ngxapi/en/NgxScaleDirective\"\n",
      "},\n",
      "\n",
      "\"scene.component\" : {\n",
      "\"NgxSceneComponent\" : \"ngxapi/en/NgxSceneComponent\"\n",
      "},\n",
      "\n",
      "\"selection-box-controls\" : {\n",
      "\"NgxSelectBoxControls\" : \"ngxapi/en/NgxSelectBoxControls\"\n",
      "},\n",
      "\n",
      "\"shader.component\" : {\n",
      "\"NgxShaderComponent\" : \"ngxapi/en/NgxShaderComponent\"\n",
      "},\n",
      "\n",
      "\"shape.component\" : {\n",
      "\"NgxShapeComponent\" : \"ngxapi/en/NgxShapeComponent\"\n",
      "},\n",
      "\n",
      "\"shared.component\" : {\n",
      "\"NgxSharedComponent\" : \"ngxapi/en/NgxSharedComponent\"\n",
      "},\n",
      "\n",
      "\"size.component\" : {\n",
      "\"NgxSizeComponent\" : \"ngxapi/en/NgxSizeComponent\"\n",
      "},\n",
      "\n",
      "\"star-depth\" : {\n",
      "\"NgxStarDepthGeometry\" : \"ngxapi/en/NgxStarDepthGeometry\"\n",
      "},\n",
      "\n",
      "\"star\" : {\n",
      "\"NgxStarGeometry\" : \"ngxapi/en/NgxStarGeometry\"\n",
      "},\n",
      "\n",
      "\"svg.component\" : {\n",
      "\"NgxSvgComponent\" : \"ngxapi/en/NgxSvgComponent\"\n",
      "},\n",
      "\n",
      "\"chartjs.component\" : {\n",
      "\"NgxTextureChartJsComponent\" : \"ngxapi/en/NgxTextureChartJsComponent\"\n",
      "},\n",
      "\n",
      "\"texture.component\" : {\n",
      "\"NgxTextureComponent\" : \"ngxapi/en/NgxTextureComponent\"\n",
      "},\n",
      "\n",
      "\"echarts.component\" : {\n",
      "\"NgxTextureEChartsComponent\" : \"ngxapi/en/NgxTextureEChartsComponent\"\n",
      "},\n",
      "\n",
      "\"three-clock\" : {\n",
      "\"NgxThreeClock\" : \"ngxapi/en/NgxThreeClock\"\n",
      "},\n",
      "\n",
      "\"three-geometry-custom\" : {\n",
      "\"NgxThreeGeometryCustom\" : \"ngxapi/en/NgxThreeGeometryCustom\"\n",
      "},\n",
      "\n",
      "\"three-gui\" : {\n",
      "\"NgxThreeGui\" : \"ngxapi/en/NgxThreeGui\"\n",
      "},\n",
      "\n",
      "\"three-stats\" : {\n",
      "\"NgxThreeStats\" : \"ngxapi/en/NgxThreeStats\"\n",
      "},\n",
      "\n",
      "\"three-util\" : {\n",
      "\"NgxThreeUtil\" : \"ngxapi/en/NgxThreeUtil\"\n",
      "},\n",
      "\n",
      "\"tools.component\" : {\n",
      "\"NgxToolsComponent\" : \"ngxapi/en/NgxToolsComponent\"\n",
      "},\n",
      "\n",
      "\"transform.component\" : {\n",
      "\"NgxTransformComponent\" : \"ngxapi/en/NgxTransformComponent\"\n",
      "},\n",
      "\n",
      "\"translation.component\" : {\n",
      "\"NgxTranslationComponent\" : \"ngxapi/en/NgxTranslationComponent\"\n",
      "},\n",
      "\n",
      "\"tween.component\" : {\n",
      "\"NgxTweenComponent\" : \"ngxapi/en/NgxTweenComponent\"\n",
      "},\n",
      "\n",
      "\"viewer.component\" : {\n",
      "\"NgxViewerComponent\" : \"ngxapi/en/NgxViewerComponent\"\n",
      "},\n",
      "\n",
      "\"viewport-in.component\" : {\n",
      "\"NgxViewportInComponent\" : \"ngxapi/en/NgxViewportInComponent\"\n",
      "},\n",
      "\n",
      "\"visual.component\" : {\n",
      "\"NgxVisualComponent\" : \"ngxapi/en/NgxVisualComponent\"\n",
      "},\n",
      "\n",
      "\"shaderUtils\" : {\n",
      "\"ShaderUtils\" : \"ngxapi/en/ShaderUtils\"\n",
      "},\n",
      "\n",
      "\"textureUtils\" : {\n",
      "\"TextureUtils\" : \"ngxapi/en/TextureUtils\"\n",
      "},\n",
      "\n",
      "\"viewer-canvas\" : {\n",
      "\"ViewerCanvas\" : \"ngxapi/en/ViewerCanvas\"\n",
      "},\n",
      "\n",
      "\"webxr\" : {\n",
      "\"ARButton\" : \"ngxapi/en/ARButton\",\n",
      "\"OculusHandModel\" : \"ngxapi/en/OculusHandModel\",\n",
      "\"OculusHandPointerModel\" : \"ngxapi/en/OculusHandPointerModel\",\n",
      "\"VRButton\" : \"ngxapi/en/VRButton\",\n",
      "\"XRControllerModelFactory\" : \"ngxapi/en/XRControllerModelFactory\",\n",
      "\"XREstimatedLight\" : \"ngxapi/en/XREstimatedLight\",\n",
      "\"XRHandMeshModel\" : \"ngxapi/en/XRHandMeshModel\",\n",
      "\"XRHandModelFactory\" : \"ngxapi/en/XRHandModelFactory\",\n",
      "\"XRHandPrimitiveModel\" : \"ngxapi/en/XRHandPrimitiveModel\"\n",
      "},\n",
      "\n",
      "\"postprocessing\" : {\n",
      "\"AdaptiveToneMappingPass\" : \"ngxapi/en/AdaptiveToneMappingPass\",\n",
      "\"AfterimagePass\" : \"ngxapi/en/AfterimagePass\",\n",
      "\"BloomPass\" : \"ngxapi/en/BloomPass\",\n",
      "\"BokehPass\" : \"ngxapi/en/BokehPass\",\n",
      "\"ClearMaskPass\" : \"ngxapi/en/ClearMaskPass\",\n",
      "\"ClearPass\" : \"ngxapi/en/ClearPass\",\n",
      "\"CubeTexturePass\" : \"ngxapi/en/CubeTexturePass\",\n",
      "\"DotScreenPass\" : \"ngxapi/en/DotScreenPass\",\n",
      "\"EffectComposer\" : \"ngxapi/en/EffectComposer\",\n",
      "\"FilmPass\" : \"ngxapi/en/FilmPass\",\n",
      "\"FullScreenQuad\" : \"ngxapi/en/FullScreenQuad\",\n",
      "\"GlitchPass\" : \"ngxapi/en/GlitchPass\",\n",
      "\"HalftonePass\" : \"ngxapi/en/HalftonePass\",\n",
      "\"LUTPass\" : \"ngxapi/en/LUTPass\",\n",
      "\"MaskPass\" : \"ngxapi/en/MaskPass\",\n",
      "\"OutlinePass\" : \"ngxapi/en/OutlinePass\",\n",
      "\"Pass\" : \"ngxapi/en/Pass\",\n",
      "\"RenderPass\" : \"ngxapi/en/RenderPass\",\n",
      "\"SAOPass\" : \"ngxapi/en/SAOPass\",\n",
      "\"SMAAPass\" : \"ngxapi/en/SMAAPass\",\n",
      "\"SSAARenderPass\" : \"ngxapi/en/SSAARenderPass\",\n",
      "\"SSAOPass\" : \"ngxapi/en/SSAOPass\",\n",
      "\"SSRPass\" : \"ngxapi/en/SSRPass\",\n",
      "\"SSRrPass\" : \"ngxapi/en/SSRrPass\",\n",
      "\"SavePass\" : \"ngxapi/en/SavePass\",\n",
      "\"ShaderPass\" : \"ngxapi/en/ShaderPass\",\n",
      "\"TAARenderPass\" : \"ngxapi/en/TAARenderPass\",\n",
      "\"TexturePass\" : \"ngxapi/en/TexturePass\",\n",
      "\"UnrealBloomPass\" : \"ngxapi/en/UnrealBloomPass\"\n",
      "},\n",
      "\n",
      "\"shaders\" : {\n",
      "\"AfterimageShader\" : \"ngxapi/en/AfterimageShader\",\n",
      "\"BasicShader\" : \"ngxapi/en/BasicShader\",\n",
      "\"BleachBypassShader\" : \"ngxapi/en/BleachBypassShader\",\n",
      "\"BlendShader\" : \"ngxapi/en/BlendShader\",\n",
      "\"BokehDepthShader\" : \"ngxapi/en/BokehDepthShader\",\n",
      "\"BokehShader\" : \"ngxapi/en/BokehShader\",\n",
      "\"BokehShader2\" : \"ngxapi/en/BokehShader2\",\n",
      "\"BrightnessContrastShader\" : \"ngxapi/en/BrightnessContrastShader\",\n",
      "\"ColorCorrectionShader\" : \"ngxapi/en/ColorCorrectionShader\",\n",
      "\"ColorifyShader\" : \"ngxapi/en/ColorifyShader\",\n",
      "\"ConvolutionShader\" : \"ngxapi/en/ConvolutionShader\",\n",
      "\"CopyShader\" : \"ngxapi/en/CopyShader\",\n",
      "\"DOFMipMapShader\" : \"ngxapi/en/DOFMipMapShader\",\n",
      "\"DepthLimitedBlurShader\" : \"ngxapi/en/DepthLimitedBlurShader\",\n",
      "\"DigitalGlitch\" : \"ngxapi/en/DigitalGlitch\",\n",
      "\"DotScreenShader\" : \"ngxapi/en/DotScreenShader\",\n",
      "\"FXAAShader\" : \"ngxapi/en/FXAAShader\",\n",
      "\"FilmShader\" : \"ngxapi/en/FilmShader\",\n",
      "\"FocusShader\" : \"ngxapi/en/FocusShader\",\n",
      "\"FreiChenShader\" : \"ngxapi/en/FreiChenShader\",\n",
      "\"GammaCorrectionShader\" : \"ngxapi/en/GammaCorrectionShader\",\n",
      "\"GodRaysCombineShader\" : \"ngxapi/en/GodRaysCombineShader\",\n",
      "\"GodRaysDepthMaskShader\" : \"ngxapi/en/GodRaysDepthMaskShader\",\n",
      "\"GodRaysFakeSunShader\" : \"ngxapi/en/GodRaysFakeSunShader\",\n",
      "\"GodRaysGenerateShader\" : \"ngxapi/en/GodRaysGenerateShader\",\n",
      "\"HalftoneShader\" : \"ngxapi/en/HalftoneShader\",\n",
      "\"HorizontalBlurShader\" : \"ngxapi/en/HorizontalBlurShader\",\n",
      "\"HorizontalTiltShiftShader\" : \"ngxapi/en/HorizontalTiltShiftShader\",\n",
      "\"HueSaturationShader\" : \"ngxapi/en/HueSaturationShader\",\n",
      "\"KaleidoShader\" : \"ngxapi/en/KaleidoShader\",\n",
      "\"LuminosityHighPassShader\" : \"ngxapi/en/LuminosityHighPassShader\",\n",
      "\"LuminosityShader\" : \"ngxapi/en/LuminosityShader\",\n",
      "\"MirrorShader\" : \"ngxapi/en/MirrorShader\",\n",
      "\"NormalMapShader\" : \"ngxapi/en/NormalMapShader\",\n",
      "\"PixelShader\" : \"ngxapi/en/PixelShader\",\n",
      "\"RGBShiftShader\" : \"ngxapi/en/RGBShiftShader\",\n",
      "\"SAOShader\" : \"ngxapi/en/SAOShader\",\n",
      "\"SMAABlendShader\" : \"ngxapi/en/SMAABlendShader\",\n",
      "\"SMAAEdgesShader\" : \"ngxapi/en/SMAAEdgesShader\",\n",
      "\"SMAAWeightsShader\" : \"ngxapi/en/SMAAWeightsShader\",\n",
      "\"SSAOBlurShader\" : \"ngxapi/en/SSAOBlurShader\",\n",
      "\"SSAODepthShader\" : \"ngxapi/en/SSAODepthShader\",\n",
      "\"SSAOShader\" : \"ngxapi/en/SSAOShader\",\n",
      "\"SSRBlurShader\" : \"ngxapi/en/SSRBlurShader\",\n",
      "\"SSRDepthShader\" : \"ngxapi/en/SSRDepthShader\",\n",
      "\"SSRShader\" : \"ngxapi/en/SSRShader\",\n",
      "\"SSRrDepthShader\" : \"ngxapi/en/SSRrDepthShader\",\n",
      "\"SSRrShader\" : \"ngxapi/en/SSRrShader\",\n",
      "\"SepiaShader\" : \"ngxapi/en/SepiaShader\",\n",
      "\"SobelOperatorShader\" : \"ngxapi/en/SobelOperatorShader\",\n",
      "\"SubsurfaceScatteringShader\" : \"ngxapi/en/SubsurfaceScatteringShader\",\n",
      "\"TechnicolorShader\" : \"ngxapi/en/TechnicolorShader\",\n",
      "\"ToneMapShader\" : \"ngxapi/en/ToneMapShader\",\n",
      "\"ToonShader1\" : \"ngxapi/en/ToonShader1\",\n",
      "\"ToonShader2\" : \"ngxapi/en/ToonShader2\",\n",
      "\"ToonShaderDotted\" : \"ngxapi/en/ToonShaderDotted\",\n",
      "\"ToonShaderHatching\" : \"ngxapi/en/ToonShaderHatching\",\n",
      "\"TriangleBlurShader\" : \"ngxapi/en/TriangleBlurShader\",\n",
      "\"UnpackDepthRGBAShader\" : \"ngxapi/en/UnpackDepthRGBAShader\",\n",
      "\"VerticalBlurShader\" : \"ngxapi/en/VerticalBlurShader\",\n",
      "\"VerticalTiltShiftShader\" : \"ngxapi/en/VerticalTiltShiftShader\",\n",
      "\"VignetteShader\" : \"ngxapi/en/VignetteShader\",\n",
      "\"VolumeRenderShader1\" : \"ngxapi/en/VolumeRenderShader1\",\n",
      "\"WaterRefractionShader\" : \"ngxapi/en/WaterRefractionShader\"\n",
      "},\n",
      "\n",
      "\"lights\" : {\n",
      "\"AmbientLight\" : \"ngxapi/en/AmbientLight\",\n",
      "\"AmbientLightProbe\" : \"ngxapi/en/AmbientLightProbe\",\n",
      "\"DirectionalLight\" : \"ngxapi/en/DirectionalLight\",\n",
      "\"HemisphereLight\" : \"ngxapi/en/HemisphereLight\",\n",
      "\"HemisphereLightProbe\" : \"ngxapi/en/HemisphereLightProbe\",\n",
      "\"Light\" : \"ngxapi/en/Light\",\n",
      "\"LightProbe\" : \"ngxapi/en/LightProbe\",\n",
      "\"LightProbeGenerator\" : \"ngxapi/en/LightProbeGenerator\",\n",
      "\"PointLight\" : \"ngxapi/en/PointLight\",\n",
      "\"RectAreaLight\" : \"ngxapi/en/RectAreaLight\",\n",
      "\"SpotLight\" : \"ngxapi/en/SpotLight\"\n",
      "},\n",
      "\n",
      "\"physics\" : {\n",
      "\"AmmoPhysics\" : \"ngxapi/en/AmmoPhysics\",\n",
      "\"OimoPhysics\" : \"ngxapi/en/OimoPhysics\"\n",
      "},\n",
      "\n",
      "\"effects\" : {\n",
      "\"AnaglyphEffect\" : \"ngxapi/en/AnaglyphEffect\",\n",
      "\"AsciiEffect\" : \"ngxapi/en/AsciiEffect\",\n",
      "\"OutlineEffect\" : \"ngxapi/en/OutlineEffect\",\n",
      "\"ParallaxBarrierEffect\" : \"ngxapi/en/ParallaxBarrierEffect\",\n",
      "\"PeppersGhostEffect\" : \"ngxapi/en/PeppersGhostEffect\",\n",
      "\"StereoEffect\" : \"ngxapi/en/StereoEffect\"\n",
      "},\n",
      "\n",
      "\"animation\" : {\n",
      "\"AnimationClip\" : \"ngxapi/en/AnimationClip\",\n",
      "\"AnimationClipCreator\" : \"ngxapi/en/AnimationClipCreator\",\n",
      "\"AnimationMixer\" : \"ngxapi/en/AnimationMixer\",\n",
      "\"AnimationObjectGroup\" : \"ngxapi/en/AnimationObjectGroup\",\n",
      "\"AnimationUtils\" : \"ngxapi/en/AnimationUtils\",\n",
      "\"BooleanKeyframeTrack\" : \"ngxapi/en/BooleanKeyframeTrack\",\n",
      "\"CCDIKSolver\" : \"ngxapi/en/CCDIKSolver\",\n",
      "\"ColorKeyframeTrack\" : \"ngxapi/en/ColorKeyframeTrack\",\n",
      "\"KeyframeTrack\" : \"ngxapi/en/KeyframeTrack\",\n",
      "\"MMDAnimationHelper\" : \"ngxapi/en/MMDAnimationHelper\",\n",
      "\"MMDPhysics\" : \"ngxapi/en/MMDPhysics\",\n",
      "\"NumberKeyframeTrack\" : \"ngxapi/en/NumberKeyframeTrack\",\n",
      "\"PropertyBinding\" : \"ngxapi/en/PropertyBinding\",\n",
      "\"PropertyMixer\" : \"ngxapi/en/PropertyMixer\",\n",
      "\"QuaternionKeyframeTrack\" : \"ngxapi/en/QuaternionKeyframeTrack\",\n",
      "\"StringKeyframeTrack\" : \"ngxapi/en/StringKeyframeTrack\",\n",
      "\"VectorKeyframeTrack\" : \"ngxapi/en/VectorKeyframeTrack\"\n",
      "},\n",
      "\n",
      "\"extras\" : {\n",
      "\"ArcCurve\" : \"ngxapi/en/ArcCurve\",\n",
      "\"CatmullRomCurve3\" : \"ngxapi/en/CatmullRomCurve3\",\n",
      "\"CubicBezierCurve\" : \"ngxapi/en/CubicBezierCurve\",\n",
      "\"CubicBezierCurve3\" : \"ngxapi/en/CubicBezierCurve3\",\n",
      "\"Curve\" : \"ngxapi/en/Curve\",\n",
      "\"CurvePath\" : \"ngxapi/en/CurvePath\",\n",
      "\"CurvePathVector2\" : \"ngxapi/en/CurvePathVector2\",\n",
      "\"CurvePathVector3\" : \"ngxapi/en/CurvePathVector3\",\n",
      "\"CurveVector2\" : \"ngxapi/en/CurveVector2\",\n",
      "\"CurveVector3\" : \"ngxapi/en/CurveVector3\",\n",
      "\"DataUtils\" : \"ngxapi/en/DataUtils\",\n",
      "\"EllipseCurve\" : \"ngxapi/en/EllipseCurve\",\n",
      "\"ImageUtils\" : \"ngxapi/en/ImageUtils\",\n",
      "\"LineCurve\" : \"ngxapi/en/LineCurve\",\n",
      "\"LineCurve3\" : \"ngxapi/en/LineCurve3\",\n",
      "\"PMREMGenerator\" : \"ngxapi/en/PMREMGenerator\",\n",
      "\"Path\" : \"ngxapi/en/Path\",\n",
      "\"QuadraticBezierCurve\" : \"ngxapi/en/QuadraticBezierCurve\",\n",
      "\"QuadraticBezierCurve3\" : \"ngxapi/en/QuadraticBezierCurve3\",\n",
      "\"Shape\" : \"ngxapi/en/Shape\",\n",
      "\"ShapePath\" : \"ngxapi/en/ShapePath\",\n",
      "\"ShapeUtils\" : \"ngxapi/en/ShapeUtils\",\n",
      "\"SplineCurve\" : \"ngxapi/en/SplineCurve\"\n",
      "},\n",
      "\n",
      "\"controls\" : {\n",
      "\"ArcballControls\" : \"ngxapi/en/ArcballControls\",\n",
      "\"DragControls\" : \"ngxapi/en/DragControls\",\n",
      "\"FirstPersonControls\" : \"ngxapi/en/FirstPersonControls\",\n",
      "\"FlyControls\" : \"ngxapi/en/FlyControls\",\n",
      "\"MapControls\" : \"ngxapi/en/MapControls\",\n",
      "\"OrbitControls\" : \"ngxapi/en/OrbitControls\",\n",
      "\"PointerLockControls\" : \"ngxapi/en/PointerLockControls\",\n",
      "\"TrackballControls\" : \"ngxapi/en/TrackballControls\",\n",
      "\"TransformControls\" : \"ngxapi/en/TransformControls\"\n",
      "},\n",
      "\n",
      "\"cameras\" : {\n",
      "\"ArrayCamera\" : \"ngxapi/en/ArrayCamera\",\n",
      "\"Camera\" : \"ngxapi/en/Camera\",\n",
      "\"CinematicCamera\" : \"ngxapi/en/CinematicCamera\",\n",
      "\"CubeCamera\" : \"ngxapi/en/CubeCamera\",\n",
      "\"OrthographicCamera\" : \"ngxapi/en/OrthographicCamera\",\n",
      "\"PerspectiveCamera\" : \"ngxapi/en/PerspectiveCamera\",\n",
      "\"StereoCamera\" : \"ngxapi/en/StereoCamera\"\n",
      "},\n",
      "\n",
      "\"helpers\" : {\n",
      "\"ArrowHelper\" : \"ngxapi/en/ArrowHelper\",\n",
      "\"AxesHelper\" : \"ngxapi/en/AxesHelper\",\n",
      "\"Box3Helper\" : \"ngxapi/en/Box3Helper\",\n",
      "\"BoxHelper\" : \"ngxapi/en/BoxHelper\",\n",
      "\"CameraHelper\" : \"ngxapi/en/CameraHelper\",\n",
      "\"DirectionalLightHelper\" : \"ngxapi/en/DirectionalLightHelper\",\n",
      "\"GridHelper\" : \"ngxapi/en/GridHelper\",\n",
      "\"HemisphereLightHelper\" : \"ngxapi/en/HemisphereLightHelper\",\n",
      "\"LightProbeHelper\" : \"ngxapi/en/LightProbeHelper\",\n",
      "\"PlaneHelper\" : \"ngxapi/en/PlaneHelper\",\n",
      "\"PointLightHelper\" : \"ngxapi/en/PointLightHelper\",\n",
      "\"PolarGridHelper\" : \"ngxapi/en/PolarGridHelper\",\n",
      "\"PositionalAudioHelper\" : \"ngxapi/en/PositionalAudioHelper\",\n",
      "\"RectAreaLightHelper\" : \"ngxapi/en/RectAreaLightHelper\",\n",
      "\"SkeletonHelper\" : \"ngxapi/en/SkeletonHelper\",\n",
      "\"SpotLightHelper\" : \"ngxapi/en/SpotLightHelper\",\n",
      "\"VertexNormalsHelper\" : \"ngxapi/en/VertexNormalsHelper\",\n",
      "\"VertexTangentsHelper\" : \"ngxapi/en/VertexTangentsHelper\"\n",
      "},\n",
      "\n",
      "\"libs\" : {\n",
      "\"AsyncDecompress\" : \"ngxapi/en/AsyncDecompress\",\n",
      "\"AsyncDeflate\" : \"ngxapi/en/AsyncDeflate\",\n",
      "\"AsyncGunzip\" : \"ngxapi/en/AsyncGunzip\",\n",
      "\"AsyncGzip\" : \"ngxapi/en/AsyncGzip\",\n",
      "\"AsyncInflate\" : \"ngxapi/en/AsyncInflate\",\n",
      "\"AsyncUnzipInflate\" : \"ngxapi/en/AsyncUnzipInflate\",\n",
      "\"AsyncUnzlib\" : \"ngxapi/en/AsyncUnzlib\",\n",
      "\"AsyncZipDeflate\" : \"ngxapi/en/AsyncZipDeflate\",\n",
      "\"AsyncZlib\" : \"ngxapi/en/AsyncZlib\",\n",
      "\"DecodeUTF8\" : \"ngxapi/en/DecodeUTF8\",\n",
      "\"Decompress\" : \"ngxapi/en/Decompress\",\n",
      "\"Deflate\" : \"ngxapi/en/Deflate\",\n",
      "\"Easing\" : \"ngxapi/en/Easing\",\n",
      "\"EncodeUTF8\" : \"ngxapi/en/EncodeUTF8\",\n",
      "\"GUI\" : \"ngxapi/en/GUI\",\n",
      "\"Gunzip\" : \"ngxapi/en/Gunzip\",\n",
      "\"Gzip\" : \"ngxapi/en/Gzip\",\n",
      "\"Inflate\" : \"ngxapi/en/Inflate\",\n",
      "\"Interpolation\" : \"ngxapi/en/Interpolation\",\n",
      "\"Stats\" : \"ngxapi/en/Stats\",\n",
      "\"TWEEN\" : \"ngxapi/en/TWEEN\",\n",
      "\"Tween\" : \"ngxapi/en/Tween\",\n",
      "\"TweenGroup\" : \"ngxapi/en/TweenGroup\",\n",
      "\"Unzip\" : \"ngxapi/en/Unzip\",\n",
      "\"UnzipInflate\" : \"ngxapi/en/UnzipInflate\",\n",
      "\"UnzipPassThrough\" : \"ngxapi/en/UnzipPassThrough\",\n",
      "\"Unzlib\" : \"ngxapi/en/Unzlib\",\n",
      "\"Zip\" : \"ngxapi/en/Zip\",\n",
      "\"ZipDeflate\" : \"ngxapi/en/ZipDeflate\",\n",
      "\"ZipPassThrough\" : \"ngxapi/en/ZipPassThrough\",\n",
      "\"Zlib\" : \"ngxapi/en/Zlib\",\n",
      "\"strFromU8\" : \"ngxapi/en/strFromU8\",\n",
      "\"unzip\" : \"ngxapi/en/unzip\",\n",
      "\"unzipSync\" : \"ngxapi/en/unzipSync\"\n",
      "},\n",
      "\n",
      "\"nodes\" : {\n",
      "\"AttributeNode\" : \"ngxapi/en/AttributeNode\",\n",
      "\"BasicNode\" : \"ngxapi/en/BasicNode\",\n",
      "\"BasicNodeMaterial\" : \"ngxapi/en/BasicNodeMaterial\",\n",
      "\"BlurNode\" : \"ngxapi/en/BlurNode\",\n",
      "\"BoolNode\" : \"ngxapi/en/BoolNode\",\n",
      "\"BumpMapNode\" : \"ngxapi/en/BumpMapNode\",\n",
      "\"BypassNode\" : \"ngxapi/en/BypassNode\",\n",
      "\"CameraNode\" : \"ngxapi/en/CameraNode\",\n",
      "\"CheckerNode\" : \"ngxapi/en/CheckerNode\",\n",
      "\"ColorAdjustmentNode\" : \"ngxapi/en/ColorAdjustmentNode\",\n",
      "\"ColorNode\" : \"ngxapi/en/ColorNode\",\n",
      "\"ColorSpaceNode\" : \"ngxapi/en/ColorSpaceNode\",\n",
      "\"ColorsNode\" : \"ngxapi/en/ColorsNode\",\n",
      "\"CondNode\" : \"ngxapi/en/CondNode\",\n",
      "\"ConstNode\" : \"ngxapi/en/ConstNode\",\n",
      "\"CubeTextureNode\" : \"ngxapi/en/CubeTextureNode\",\n",
      "\"ExpressionNode\" : \"ngxapi/en/ExpressionNode\",\n",
      "\"FloatNode\" : \"ngxapi/en/FloatNode\",\n",
      "\"FunctionCallNode\" : \"ngxapi/en/FunctionCallNode\",\n",
      "\"FunctionNode\" : \"ngxapi/en/FunctionNode\",\n",
      "\"InputNode\" : \"ngxapi/en/InputNode\",\n",
      "\"IntNode\" : \"ngxapi/en/IntNode\",\n",
      "\"JoinNode\" : \"ngxapi/en/JoinNode\",\n",
      "\"LightNode\" : \"ngxapi/en/LightNode\",\n",
      "\"LuminanceNode\" : \"ngxapi/en/LuminanceNode\",\n",
      "\"MathNode\" : \"ngxapi/en/MathNode\",\n",
      "\"Matrix3Node\" : \"ngxapi/en/Matrix3Node\",\n",
      "\"Matrix4Node\" : \"ngxapi/en/Matrix4Node\",\n",
      "\"MaxMIPLevelNode\" : \"ngxapi/en/MaxMIPLevelNode\",\n",
      "\"MeshStandardNode\" : \"ngxapi/en/MeshStandardNode\",\n",
      "\"MeshStandardNodeMaterial\" : \"ngxapi/en/MeshStandardNodeMaterial\",\n",
      "\"NodeBuilder\" : \"ngxapi/en/NodeBuilder\",\n",
      "\"NodeFrame\" : \"ngxapi/en/NodeFrame\",\n",
      "\"NodeLib\" : \"ngxapi/en/NodeLib\",\n",
      "\"NodeMaterial\" : \"ngxapi/en/NodeMaterial\",\n",
      "\"NodeNode\" : \"ngxapi/en/NodeNode\",\n",
      "\"NodePass\" : \"ngxapi/en/NodePass\",\n",
      "\"NodePostProcessing\" : \"ngxapi/en/NodePostProcessing\",\n",
      "\"NodeUniform\" : \"ngxapi/en/NodeUniform\",\n",
      "\"NodeUpdateType\" : \"ngxapi/en/NodeUpdateType\",\n",
      "\"NodeUtils\" : \"ngxapi/en/NodeUtils\",\n",
      "\"NormalMapNode\" : \"ngxapi/en/NormalMapNode\",\n",
      "\"NormalNode\" : \"ngxapi/en/NormalNode\",\n",
      "\"OperatorNode\" : \"ngxapi/en/OperatorNode\",\n",
      "\"PhongNode\" : \"ngxapi/en/PhongNode\",\n",
      "\"PhongNodeMaterial\" : \"ngxapi/en/PhongNodeMaterial\",\n",
      "\"PositionNode\" : \"ngxapi/en/PositionNode\",\n",
      "\"PropertyNode\" : \"ngxapi/en/PropertyNode\",\n",
      "\"RTTNode\" : \"ngxapi/en/RTTNode\",\n",
      "\"RawNode\" : \"ngxapi/en/RawNode\",\n",
      "\"ReflectNode\" : \"ngxapi/en/ReflectNode\",\n",
      "\"ReflectorNode\" : \"ngxapi/en/ReflectorNode\",\n",
      "\"ResolutionNode\" : \"ngxapi/en/ResolutionNode\",\n",
      "\"ScreenNode\" : \"ngxapi/en/ScreenNode\",\n",
      "\"ScreenUVNode\" : \"ngxapi/en/ScreenUVNode\",\n",
      "\"SpecularMIPLevelNode\" : \"ngxapi/en/SpecularMIPLevelNode\",\n",
      "\"SpriteNode\" : \"ngxapi/en/SpriteNode\",\n",
      "\"SpriteNodeMaterial\" : \"ngxapi/en/SpriteNodeMaterial\",\n",
      "\"StandardNode\" : \"ngxapi/en/StandardNode\",\n",
      "\"StandardNodeMaterial\" : \"ngxapi/en/StandardNodeMaterial\",\n",
      "\"StructNode\" : \"ngxapi/en/StructNode\",\n",
      "\"SubSlotNode\" : \"ngxapi/en/SubSlotNode\",\n",
      "\"SwitchNode\" : \"ngxapi/en/SwitchNode\",\n",
      "\"TempNode\" : \"ngxapi/en/TempNode\",\n",
      "\"TextureCubeNode\" : \"ngxapi/en/TextureCubeNode\",\n",
      "\"TextureCubeUVNode\" : \"ngxapi/en/TextureCubeUVNode\",\n",
      "\"TextureNode\" : \"ngxapi/en/TextureNode\",\n",
      "\"TimerNode\" : \"ngxapi/en/TimerNode\",\n",
      "\"UVNode\" : \"ngxapi/en/UVNode\",\n",
      "\"UVTransformNode\" : \"ngxapi/en/UVTransformNode\",\n",
      "\"VarNode\" : \"ngxapi/en/VarNode\",\n",
      "\"Vector2Node\" : \"ngxapi/en/Vector2Node\",\n",
      "\"Vector3Node\" : \"ngxapi/en/Vector3Node\",\n",
      "\"Vector4Node\" : \"ngxapi/en/Vector4Node\",\n",
      "\"VelocityNode\" : \"ngxapi/en/VelocityNode\"\n",
      "},\n",
      "\n",
      "\"audio\" : {\n",
      "\"Audio\" : \"ngxapi/en/Audio\",\n",
      "\"AudioAnalyser\" : \"ngxapi/en/AudioAnalyser\",\n",
      "\"AudioContext\" : \"ngxapi/en/AudioContext\",\n",
      "\"AudioListener\" : \"ngxapi/en/AudioListener\",\n",
      "\"PositionalAudio\" : \"ngxapi/en/PositionalAudio\"\n",
      "},\n",
      "\n",
      "\"objects\" : {\n",
      "\"Bone\" : \"ngxapi/en/Bone\",\n",
      "\"Group\" : \"ngxapi/en/Group\",\n",
      "\"InstancedMesh\" : \"ngxapi/en/InstancedMesh\",\n",
      "\"LOD\" : \"ngxapi/en/LOD\",\n",
      "\"Lensflare\" : \"ngxapi/en/Lensflare\",\n",
      "\"LensflareElement\" : \"ngxapi/en/LensflareElement\",\n",
      "\"LightningStorm\" : \"ngxapi/en/LightningStorm\",\n",
      "\"Line\" : \"ngxapi/en/Line\",\n",
      "\"LineLoop\" : \"ngxapi/en/LineLoop\",\n",
      "\"LineSegments\" : \"ngxapi/en/LineSegments\",\n",
      "\"MarchingCubes\" : \"ngxapi/en/MarchingCubes\",\n",
      "\"Mesh\" : \"ngxapi/en/Mesh\",\n",
      "\"Points\" : \"ngxapi/en/Points\",\n",
      "\"Reflector\" : \"ngxapi/en/Reflector\",\n",
      "\"ReflectorForSSRPass\" : \"ngxapi/en/ReflectorForSSRPass\",\n",
      "\"ReflectorRTT\" : \"ngxapi/en/ReflectorRTT\",\n",
      "\"Refractor\" : \"ngxapi/en/Refractor\",\n",
      "\"ShadowMesh\" : \"ngxapi/en/ShadowMesh\",\n",
      "\"Skeleton\" : \"ngxapi/en/Skeleton\",\n",
      "\"SkinnedMesh\" : \"ngxapi/en/SkinnedMesh\",\n",
      "\"Sky\" : \"ngxapi/en/Sky\",\n",
      "\"Sprite\" : \"ngxapi/en/Sprite\",\n",
      "\"Water\" : \"ngxapi/en/Water\",\n",
      "\"Water2\" : \"ngxapi/en/Water2\"\n",
      "},\n",
      "\n",
      "\"math\" : {\n",
      "\"Box2\" : \"ngxapi/en/Box2\",\n",
      "\"Box3\" : \"ngxapi/en/Box3\",\n",
      "\"Capsule\" : \"ngxapi/en/Capsule\",\n",
      "\"Color\" : \"ngxapi/en/Color\",\n",
      "\"ColorConverter\" : \"ngxapi/en/ColorConverter\",\n",
      "\"ColorRepresentation\" : \"ngxapi/en/ColorRepresentation\",\n",
      "\"ConvexHull\" : \"ngxapi/en/ConvexHull\",\n",
      "\"CubicInterpolant\" : \"ngxapi/en/CubicInterpolant\",\n",
      "\"Cylindrical\" : \"ngxapi/en/Cylindrical\",\n",
      "\"DiscreteInterpolant\" : \"ngxapi/en/DiscreteInterpolant\",\n",
      "\"Euler\" : \"ngxapi/en/Euler\",\n",
      "\"Frustum\" : \"ngxapi/en/Frustum\",\n",
      "\"ImprovedNoise\" : \"ngxapi/en/ImprovedNoise\",\n",
      "\"Interpolant\" : \"ngxapi/en/Interpolant\",\n",
      "\"Line3\" : \"ngxapi/en/Line3\",\n",
      "\"LinearInterpolant\" : \"ngxapi/en/LinearInterpolant\",\n",
      "\"Lut\" : \"ngxapi/en/Lut\",\n",
      "\"MathUtils\" : \"ngxapi/en/MathUtils\",\n",
      "\"Matrix3\" : \"ngxapi/en/Matrix3\",\n",
      "\"Matrix4\" : \"ngxapi/en/Matrix4\",\n",
      "\"MeshSurfaceSampler\" : \"ngxapi/en/MeshSurfaceSampler\",\n",
      "\"OBB\" : \"ngxapi/en/OBB\",\n",
      "\"Octree\" : \"ngxapi/en/Octree\",\n",
      "\"Plane\" : \"ngxapi/en/Plane\",\n",
      "\"Quaternion\" : \"ngxapi/en/Quaternion\",\n",
      "\"QuaternionLinearInterpolant\" : \"ngxapi/en/QuaternionLinearInterpolant\",\n",
      "\"Ray\" : \"ngxapi/en/Ray\",\n",
      "\"SimplexNoise\" : \"ngxapi/en/SimplexNoise\",\n",
      "\"Sphere\" : \"ngxapi/en/Sphere\",\n",
      "\"Spherical\" : \"ngxapi/en/Spherical\",\n",
      "\"SphericalHarmonics3\" : \"ngxapi/en/SphericalHarmonics3\",\n",
      "\"Triangle\" : \"ngxapi/en/Triangle\",\n",
      "\"Vector2\" : \"ngxapi/en/Vector2\",\n",
      "\"Vector2Tuple\" : \"ngxapi/en/Vector2Tuple\",\n",
      "\"Vector3\" : \"ngxapi/en/Vector3\",\n",
      "\"Vector3Tuple\" : \"ngxapi/en/Vector3Tuple\",\n",
      "\"Vector4\" : \"ngxapi/en/Vector4\",\n",
      "\"Vector4Tuple\" : \"ngxapi/en/Vector4Tuple\"\n",
      "},\n",
      "\n",
      "\"geometries\" : {\n",
      "\"BoxGeometry\" : \"ngxapi/en/BoxGeometry\",\n",
      "\"BoxLineGeometry\" : \"ngxapi/en/BoxLineGeometry\",\n",
      "\"CircleGeometry\" : \"ngxapi/en/CircleGeometry\",\n",
      "\"ConeGeometry\" : \"ngxapi/en/ConeGeometry\",\n",
      "\"ConvexGeometry\" : \"ngxapi/en/ConvexGeometry\",\n",
      "\"CylinderGeometry\" : \"ngxapi/en/CylinderGeometry\",\n",
      "\"DecalGeometry\" : \"ngxapi/en/DecalGeometry\",\n",
      "\"DecalVertex\" : \"ngxapi/en/DecalVertex\",\n",
      "\"DodecahedronGeometry\" : \"ngxapi/en/DodecahedronGeometry\",\n",
      "\"EdgesGeometry\" : \"ngxapi/en/EdgesGeometry\",\n",
      "\"ExtrudeGeometry\" : \"ngxapi/en/ExtrudeGeometry\",\n",
      "\"IcosahedronGeometry\" : \"ngxapi/en/IcosahedronGeometry\",\n",
      "\"LatheGeometry\" : \"ngxapi/en/LatheGeometry\",\n",
      "\"LightningStrike\" : \"ngxapi/en/LightningStrike\",\n",
      "\"OctahedronGeometry\" : \"ngxapi/en/OctahedronGeometry\",\n",
      "\"ParametricGeometries\" : \"ngxapi/en/ParametricGeometries\",\n",
      "\"ParametricGeometry\" : \"ngxapi/en/ParametricGeometry\",\n",
      "\"PlaneGeometry\" : \"ngxapi/en/PlaneGeometry\",\n",
      "\"PolyhedronGeometry\" : \"ngxapi/en/PolyhedronGeometry\",\n",
      "\"RingGeometry\" : \"ngxapi/en/RingGeometry\",\n",
      "\"RoundedBoxGeometry\" : \"ngxapi/en/RoundedBoxGeometry\",\n",
      "\"ShapeGeometry\" : \"ngxapi/en/ShapeGeometry\",\n",
      "\"SphereGeometry\" : \"ngxapi/en/SphereGeometry\",\n",
      "\"TeapotGeometry\" : \"ngxapi/en/TeapotGeometry\",\n",
      "\"TetrahedronGeometry\" : \"ngxapi/en/TetrahedronGeometry\",\n",
      "\"TextGeometry\" : \"ngxapi/en/TextGeometry\",\n",
      "\"TorusGeometry\" : \"ngxapi/en/TorusGeometry\",\n",
      "\"TorusKnotGeometry\" : \"ngxapi/en/TorusKnotGeometry\",\n",
      "\"TubeGeometry\" : \"ngxapi/en/TubeGeometry\",\n",
      "\"WireframeGeometry\" : \"ngxapi/en/WireframeGeometry\"\n",
      "},\n",
      "\n",
      "\"core\" : {\n",
      "\"BufferAttribute\" : \"ngxapi/en/BufferAttribute\",\n",
      "\"BufferGeometry\" : \"ngxapi/en/BufferGeometry\",\n",
      "\"Clock\" : \"ngxapi/en/Clock\",\n",
      "\"Float16BufferAttribute\" : \"ngxapi/en/Float16BufferAttribute\",\n",
      "\"Float32BufferAttribute\" : \"ngxapi/en/Float32BufferAttribute\",\n",
      "\"Float64BufferAttribute\" : \"ngxapi/en/Float64BufferAttribute\",\n",
      "\"GLBufferAttribute\" : \"ngxapi/en/GLBufferAttribute\",\n",
      "\"InstancedBufferAttribute\" : \"ngxapi/en/InstancedBufferAttribute\",\n",
      "\"InstancedBufferGeometry\" : \"ngxapi/en/InstancedBufferGeometry\",\n",
      "\"InstancedInterleavedBuffer\" : \"ngxapi/en/InstancedInterleavedBuffer\",\n",
      "\"Int16BufferAttribute\" : \"ngxapi/en/Int16BufferAttribute\",\n",
      "\"Int32BufferAttribute\" : \"ngxapi/en/Int32BufferAttribute\",\n",
      "\"Int8BufferAttribute\" : \"ngxapi/en/Int8BufferAttribute\",\n",
      "\"InterleavedBuffer\" : \"ngxapi/en/InterleavedBuffer\",\n",
      "\"InterleavedBufferAttribute\" : \"ngxapi/en/InterleavedBufferAttribute\",\n",
      "\"Layers\" : \"ngxapi/en/Layers\",\n",
      "\"Object3D\" : \"ngxapi/en/Object3D\",\n",
      "\"Raycaster\" : \"ngxapi/en/Raycaster\",\n",
      "\"Uint16BufferAttribute\" : \"ngxapi/en/Uint16BufferAttribute\",\n",
      "\"Uint32BufferAttribute\" : \"ngxapi/en/Uint32BufferAttribute\",\n",
      "\"Uint8BufferAttribute\" : \"ngxapi/en/Uint8BufferAttribute\",\n",
      "\"Uint8ClampedBufferAttribute\" : \"ngxapi/en/Uint8ClampedBufferAttribute\",\n",
      "\"Uniform\" : \"ngxapi/en/Uniform\"\n",
      "},\n",
      "\n",
      "\"csm\" : {\n",
      "\"CSMHelper\" : \"ngxapi/en/CSMHelper\",\n",
      "\"CsmControls\" : \"ngxapi/en/CsmControls\"\n",
      "},\n",
      "\n",
      "\"renderers\" : {\n",
      "\"CSS2DObject\" : \"ngxapi/en/CSS2DObject\",\n",
      "\"CSS2DRenderer\" : \"ngxapi/en/CSS2DRenderer\",\n",
      "\"CSS3DObject\" : \"ngxapi/en/CSS3DObject\",\n",
      "\"CSS3DRenderer\" : \"ngxapi/en/CSS3DRenderer\",\n",
      "\"CSS3DSprite\" : \"ngxapi/en/CSS3DSprite\",\n",
      "\"Projector\" : \"ngxapi/en/Projector\",\n",
      "\"SVGObject\" : \"ngxapi/en/SVGObject\",\n",
      "\"SVGRenderer\" : \"ngxapi/en/SVGRenderer\",\n",
      "\"ShaderChunk\" : \"ngxapi/en/ShaderChunk\",\n",
      "\"ShaderLib\" : \"ngxapi/en/ShaderLib\",\n",
      "\"UniformsLib\" : \"ngxapi/en/UniformsLib\",\n",
      "\"UniformsUtils\" : \"ngxapi/en/UniformsUtils\",\n",
      "\"WebGL1Renderer\" : \"ngxapi/en/WebGL1Renderer\",\n",
      "\"WebGLCubeRenderTarget\" : \"ngxapi/en/WebGLCubeRenderTarget\",\n",
      "\"WebGLMultipleRenderTargets\" : \"ngxapi/en/WebGLMultipleRenderTargets\",\n",
      "\"WebGLMultisampleRenderTarget\" : \"ngxapi/en/WebGLMultisampleRenderTarget\",\n",
      "\"WebGLRenderTarget\" : \"ngxapi/en/WebGLRenderTarget\",\n",
      "\"WebGLRenderer\" : \"ngxapi/en/WebGLRenderer\"\n",
      "},\n",
      "\n",
      "\"utils\" : {\n",
      "\"CameraUtils\" : \"ngxapi/en/CameraUtils\",\n",
      "\"GeometryCompressionUtils\" : \"ngxapi/en/GeometryCompressionUtils\",\n",
      "\"GeometryUtils\" : \"ngxapi/en/GeometryUtils\",\n",
      "\"SceneUtils\" : \"ngxapi/en/SceneUtils\",\n",
      "\"ShadowMapViewer\" : \"ngxapi/en/ShadowMapViewer\",\n",
      "\"SkeletonUtils\" : \"ngxapi/en/SkeletonUtils\",\n",
      "\"UVsDebug\" : \"ngxapi/en/UVsDebug\"\n",
      "},\n",
      "\n",
      "\"textures\" : {\n",
      "\"CanvasTexture\" : \"ngxapi/en/CanvasTexture\",\n",
      "\"CompressedTexture\" : \"ngxapi/en/CompressedTexture\",\n",
      "\"CubeTexture\" : \"ngxapi/en/CubeTexture\",\n",
      "\"DataTexture\" : \"ngxapi/en/DataTexture\",\n",
      "\"DataTexture2DArray\" : \"ngxapi/en/DataTexture2DArray\",\n",
      "\"DataTexture3D\" : \"ngxapi/en/DataTexture3D\",\n",
      "\"DepthTexture\" : \"ngxapi/en/DepthTexture\",\n",
      "\"FramebufferTexture\" : \"ngxapi/en/FramebufferTexture\",\n",
      "\"Texture\" : \"ngxapi/en/Texture\",\n",
      "\"VideoTexture\" : \"ngxapi/en/VideoTexture\"\n",
      "},\n",
      "\n",
      "\"exporters\" : {\n",
      "\"ColladaExporter\" : \"ngxapi/en/ColladaExporter\",\n",
      "\"DRACOExporter\" : \"ngxapi/en/DRACOExporter\",\n",
      "\"GLTFExporter\" : \"ngxapi/en/GLTFExporter\",\n",
      "\"MMDExporter\" : \"ngxapi/en/MMDExporter\",\n",
      "\"OBJExporter\" : \"ngxapi/en/OBJExporter\",\n",
      "\"PLYExporter\" : \"ngxapi/en/PLYExporter\",\n",
      "\"STLExporter\" : \"ngxapi/en/STLExporter\",\n",
      "\"USDZExporter\" : \"ngxapi/en/USDZExporter\"\n",
      "},\n",
      "\n",
      "\"misc\" : {\n",
      "\"ConvexObjectBreaker\" : \"ngxapi/en/ConvexObjectBreaker\",\n",
      "\"GPUComputationRenderer\" : \"ngxapi/en/GPUComputationRenderer\",\n",
      "\"Gyroscope\" : \"ngxapi/en/Gyroscope\",\n",
      "\"MD2Character\" : \"ngxapi/en/MD2Character\",\n",
      "\"MD2CharacterComplex\" : \"ngxapi/en/MD2CharacterComplex\",\n",
      "\"MorphAnimMesh\" : \"ngxapi/en/MorphAnimMesh\",\n",
      "\"MorphBlendMesh\" : \"ngxapi/en/MorphBlendMesh\",\n",
      "\"ProgressiveLightMap\" : \"ngxapi/en/ProgressiveLightMap\",\n",
      "\"RollerCoasterGeometry\" : \"ngxapi/en/RollerCoasterGeometry\",\n",
      "\"RollerCoasterLiftersGeometry\" : \"ngxapi/en/RollerCoasterLiftersGeometry\",\n",
      "\"RollerCoasterShadowGeometry\" : \"ngxapi/en/RollerCoasterShadowGeometry\",\n",
      "\"RollerCoasterSkyGeometry\" : \"ngxapi/en/RollerCoasterSkyGeometry\",\n",
      "\"RollerCoasterTreesGeometry\" : \"ngxapi/en/RollerCoasterTreesGeometry\",\n",
      "\"TubePainter\" : \"ngxapi/en/TubePainter\",\n",
      "\"Volume\" : \"ngxapi/en/Volume\",\n",
      "\"VolumeSlice\" : \"ngxapi/en/VolumeSlice\"\n",
      "},\n",
      "\n",
      "\"curves\" : {\n",
      "\"Curves\" : \"ngxapi/en/Curves\",\n",
      "\"NURBSCurve\" : \"ngxapi/en/NURBSCurve\",\n",
      "\"NURBSSurface\" : \"ngxapi/en/NURBSSurface\",\n",
      "\"NURBSUtils\" : \"ngxapi/en/NURBSUtils\"\n",
      "},\n",
      "\n",
      "\"environments\" : {\n",
      "\"DebugEnvironment\" : \"ngxapi/en/DebugEnvironment\",\n",
      "\"RoomEnvironment\" : \"ngxapi/en/RoomEnvironment\"\n",
      "},\n",
      "\n",
      "\"modifiers\" : {\n",
      "\"EdgeSplitModifier\" : \"ngxapi/en/EdgeSplitModifier\",\n",
      "\"Flow\" : \"ngxapi/en/Flow\",\n",
      "\"InstancedFlow\" : \"ngxapi/en/InstancedFlow\",\n",
      "\"SimplifyModifier\" : \"ngxapi/en/SimplifyModifier\",\n",
      "\"TessellateModifier\" : \"ngxapi/en/TessellateModifier\"\n",
      "},\n",
      "\n",
      "\"scenes\" : {\n",
      "\"Fog\" : \"ngxapi/en/Fog\",\n",
      "\"FogExp2\" : \"ngxapi/en/FogExp2\",\n",
      "\"Scene\" : \"ngxapi/en/Scene\"\n",
      "},\n",
      "\n",
      "\"interactive\" : {\n",
      "\"HTMLMesh\" : \"ngxapi/en/HTMLMesh\",\n",
      "\"InteractiveGroup\" : \"ngxapi/en/InteractiveGroup\",\n",
      "\"SelectionBox\" : \"ngxapi/en/SelectionBox\",\n",
      "\"SelectionHelper\" : \"ngxapi/en/SelectionHelper\"\n",
      "},\n",
      "\n",
      "\"ngx-interface\" : {\n",
      "\"INgxColor\" : \"ngxapi/en/INgxColor\",\n",
      "\"INgxTexture\" : \"ngxapi/en/INgxTexture\",\n",
      "\"INgxUniform\" : \"ngxapi/en/INgxUniform\",\n",
      "\"INgxUniforms\" : \"ngxapi/en/INgxUniforms\",\n",
      "\"TAttrBufferAttribute\" : \"ngxapi/en/TAttrBufferAttribute\",\n",
      "\"TCanvasFunctionType\" : \"ngxapi/en/TCanvasFunctionType\",\n",
      "\"TDataFunctionType\" : \"ngxapi/en/TDataFunctionType\",\n",
      "\"TMeshMaterial\" : \"ngxapi/en/TMeshMaterial\",\n",
      "\"TObject3dFunction\" : \"ngxapi/en/TObject3dFunction\",\n",
      "\"TObjectFunction\" : \"ngxapi/en/TObjectFunction\"\n",
      "},\n",
      "\n",
      "\"lines\" : {\n",
      "\"Line2\" : \"ngxapi/en/Line2\",\n",
      "\"LineGeometry\" : \"ngxapi/en/LineGeometry\",\n",
      "\"LineMaterial\" : \"ngxapi/en/LineMaterial\",\n",
      "\"LineSegments2\" : \"ngxapi/en/LineSegments2\",\n",
      "\"LineSegmentsGeometry\" : \"ngxapi/en/LineSegmentsGeometry\",\n",
      "\"Wireframe\" : \"ngxapi/en/Wireframe\",\n",
      "\"WireframeGeometry2\" : \"ngxapi/en/WireframeGeometry2\"\n",
      "},\n",
      "\n",
      "\"materials\" : {\n",
      "\"LineBasicMaterial\" : \"ngxapi/en/LineBasicMaterial\",\n",
      "\"LineDashedMaterial\" : \"ngxapi/en/LineDashedMaterial\",\n",
      "\"Material\" : \"ngxapi/en/Material\",\n",
      "\"MeshBasicMaterial\" : \"ngxapi/en/MeshBasicMaterial\",\n",
      "\"MeshDepthMaterial\" : \"ngxapi/en/MeshDepthMaterial\",\n",
      "\"MeshDistanceMaterial\" : \"ngxapi/en/MeshDistanceMaterial\",\n",
      "\"MeshLambertMaterial\" : \"ngxapi/en/MeshLambertMaterial\",\n",
      "\"MeshMatcapMaterial\" : \"ngxapi/en/MeshMatcapMaterial\",\n",
      "\"MeshNormalMaterial\" : \"ngxapi/en/MeshNormalMaterial\",\n",
      "\"MeshPhongMaterial\" : \"ngxapi/en/MeshPhongMaterial\",\n",
      "\"MeshPhysicalMaterial\" : \"ngxapi/en/MeshPhysicalMaterial\",\n",
      "\"MeshStandardMaterial\" : \"ngxapi/en/MeshStandardMaterial\",\n",
      "\"MeshToonMaterial\" : \"ngxapi/en/MeshToonMaterial\",\n",
      "\"PointsMaterial\" : \"ngxapi/en/PointsMaterial\",\n",
      "\"RawShaderMaterial\" : \"ngxapi/en/RawShaderMaterial\",\n",
      "\"ShaderMaterial\" : \"ngxapi/en/ShaderMaterial\",\n",
      "\"ShadowMaterial\" : \"ngxapi/en/ShadowMaterial\",\n",
      "\"SpriteMaterial\" : \"ngxapi/en/SpriteMaterial\"\n",
      "},\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "loadedClass = {}\n",
    "jsonList = []\n",
    "loadedClassByName = {}\n",
    "\n",
    "for child in simpleApi :\n",
    "    name = child[\"name\"]\n",
    "    kindString = child[\"kindString\"]\n",
    "    if name not in loadedClass and ( kindString == 'Class' or  kindString == 'Namespace' or kindString == 'Type alias'):\n",
    "        loadedClass[name] = child['sources'][0]['fileName']\n",
    "for name in loadedClass :\n",
    "    url = loadedClass[name]\n",
    "    if url.startswith('lib/') :\n",
    "        if getGenApiDocs(name) :\n",
    "            jsonList.append('\"{0}\" : \"ngxapi/en/{0}\"'.format(name))\n",
    "            urlInfos = url.split('/')\n",
    "            fileName = urlInfos[-1][0:-3]\n",
    "            if fileName not in loadedClassByName :\n",
    "                loadedClassByName[fileName] = []\n",
    "            loadedClassByName[fileName].append('\"{0}\" : \"ngxapi/en/{0}\"'.format(name))\n",
    "    # else :\n",
    "    #    print(url)\n",
    "for name in loadedClassByName :\n",
    "    print('\"{0}\" : {{'.format(name))\n",
    "    print(\",\\n\".join(loadedClassByName[name]))\n",
    "    print('},\\n')\n",
    "\n",
    "# print(\",\\n\".join(jsonList))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "display_name": "Python 3.9.7 64-bit",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "metadata": {
   "interpreter": {
    "hash": "50292dbb1f747f7151d445135d392af3138fb3c65386d17d9510cb605222b10b"
   }
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}