create-yss-spec 2.1.5 → 2.1.7

package/template/.qoder/skills/drawio/scripts/adapters/python/config-parser-worker.py

@@ -1,237 +0,0 @@
-import json
-import re
-import sys
-
-
-MAX_INPUT_BYTES = 1024 * 1024
-TERRAFORM_REFERENCE = re.compile(
-    r'(?<![A-Za-z0-9_.])(?:module\.[A-Za-z0-9_-]+\.)*[A-Za-z][A-Za-z0-9_]*\.[A-Za-z0-9_-]+'
-    r'(?:\[(?:\d+|"[^"\r\n]+")\])?'
-)
-TERRAFORM_NON_RESOURCE_ROOTS = {'count', 'data', 'each', 'local', 'path', 'self', 'terraform', 'var'}
-
-
-def respond(payload, status=0):
-    sys.stdout.write(json.dumps(payload, ensure_ascii=True, separators=(',', ':')))
-    raise SystemExit(status)
-
-
-def dependency_missing(message):
-    respond({'ok': False, 'code': 'OPTIONAL_DEPENDENCY_MISSING', 'message': message}, 3)
-
-
-def parser_failure(message):
-    respond({'ok': False, 'code': 'ADAPTER_PARSE', 'message': message}, 2)
-
-
-def collect_references(value, output):
-    if isinstance(value, str):
-        output.update(
-            match.group(0)
-            for match in TERRAFORM_REFERENCE.finditer(value)
-            if match.group(0).split('.', 1)[0] not in TERRAFORM_NON_RESOURCE_ROOTS
-        )
-    elif isinstance(value, list):
-        for entry in value:
-            collect_references(entry, output)
-    elif isinstance(value, dict):
-        for entry in value.values():
-            collect_references(entry, output)
-
-
-def hcl_label(value):
-    if isinstance(value, str) and len(value) >= 2 and value[0] == value[-1] == '"':
-        return value[1:-1]
-    return value
-
-
-def qualify_terraform_reference(reference, module_address):
-    if not module_address or reference.startswith('module.'):
-        return reference
-    return f'{module_address}.{reference}'
-
-
-def terraform_records(request):
-    try:
-        import hcl2
-    except ModuleNotFoundError:
-        dependency_missing('python-hcl2==8.1.2 is unavailable')
-
-    try:
-        parsed = hcl2.loads(request['source'])
-    except Exception:
-        parser_failure('Terraform HCL could not be parsed')
-
-    module_address = request.get('moduleAddress', '')
-    if module_address and not re.fullmatch(r'(?:module\.[A-Za-z0-9_-]+)(?:\.module\.[A-Za-z0-9_-]+)*', module_address):
-        parser_failure('Terraform moduleAddress is invalid')
-
-    resources = []
-    for resource_group in parsed.get('resource', []):
-        if not isinstance(resource_group, dict):
-            continue
-        for raw_resource_type, named_resources in resource_group.items():
-            if not isinstance(named_resources, dict):
-                continue
-            resource_type = hcl_label(raw_resource_type)
-            for raw_name, body in named_resources.items():
-                if not isinstance(body, dict):
-                    continue
-                name = hcl_label(raw_name)
-                base_address = f'{resource_type}.{name}'
-                address = f'{module_address}.{base_address}' if module_address else base_address
-                references = set()
-                for key, value in body.items():
-                    if key != 'depends_on':
-                        collect_references(value, references)
-                depends_on = set()
-                collect_references(body.get('depends_on', []), depends_on)
-                references = {qualify_terraform_reference(value, module_address) for value in references}
-                depends_on = {qualify_terraform_reference(value, module_address) for value in depends_on}
-                references.discard(address)
-                depends_on.discard(address)
-                resources.append({
-                    'address': address,
-                    'resourceType': resource_type,
-                    'provider': resource_type.split('_', 1)[0],
-                    'references': sorted(references),
-                    'dependsOn': sorted(depends_on),
-                })
-
-    diagnostics = []
-    for key, code in [('data', 'TERRAFORM_DATA_EXCLUDED'), ('provider', 'TERRAFORM_PROVIDER_EXCLUDED'), ('locals', 'TERRAFORM_LOCALS_EXCLUDED')]:
-        if parsed.get(key):
-            diagnostics.append({'code': code, 'message': f'{key} blocks are outside the managed-resource projection.'})
-    return {'resources': resources, 'diagnostics': diagnostics}
-
-
-def sql_name(expression):
-    return getattr(expression, 'name', None) or str(expression)
-
-
-def sql_table_parts(table, default_schema):
-    return (getattr(table, 'db', None) or default_schema, getattr(table, 'name', None) or str(table))
-
-
-def sql_foreign_key_record(foreign_key, name, schema, exp):
-    reference = foreign_key.args.get('reference')
-    if reference is None:
-        parser_failure('SQL FOREIGN KEY is missing a REFERENCES target')
-    target = reference.this
-    target_table = target.this if isinstance(target, exp.Schema) else target
-    target_schema, target_name = sql_table_parts(target_table, schema)
-    target_columns = [sql_name(value) for value in (target.expressions if isinstance(target, exp.Schema) else [])]
-    return {
-        'name': name,
-        'columns': [sql_name(value) for value in foreign_key.expressions],
-        'targetSchema': target_schema,
-        'targetTable': target_name,
-        'targetColumns': target_columns,
-    }
-
-
-def sql_records(request):
-    try:
-        import sqlglot
-        from sqlglot import expressions as exp
-    except ModuleNotFoundError:
-        dependency_missing('sqlglot==30.12.0 is unavailable')
-
-    dialect = request.get('dialect') or 'postgres'
-    default_schema = request.get('defaultSchema') or '_default'
-    try:
-        statements = sqlglot.parse(request['source'], read=dialect)
-    except Exception:
-        parser_failure(f'SQL DDL could not be parsed for dialect {dialect}')
-
-    tables = []
-    diagnostics = []
-    for statement in statements:
-        if not isinstance(statement, exp.Create) or str(statement.args.get('kind', '')).upper() != 'TABLE':
-            diagnostics.append({'code': 'SQL_UNSUPPORTED_STATEMENT', 'message': 'Only CREATE TABLE statements are projected.'})
-            continue
-        schema_expression = statement.this
-        if isinstance(schema_expression, exp.Schema):
-            table_expression = schema_expression.this
-            elements = list(schema_expression.expressions)
-        else:
-            table_expression = schema_expression
-            elements = []
-        schema, table_name = sql_table_parts(table_expression, default_schema)
-        columns = []
-        foreign_keys = []
-
-        for element in elements:
-            if isinstance(element, exp.ColumnDef):
-                constraints = list(element.args.get('constraints') or [])
-                primary = any(isinstance(item.args.get('kind'), exp.PrimaryKeyColumnConstraint) for item in constraints)
-                nullable = not primary and not any(isinstance(item.args.get('kind'), exp.NotNullColumnConstraint) for item in constraints)
-                columns.append({
-                    'name': sql_name(element.this),
-                    'type': element.args.get('kind').sql(dialect=dialect) if element.args.get('kind') else 'UNKNOWN',
-                    'primaryKey': primary,
-                    'nullable': nullable,
-                })
-                for constraint in constraints:
-                    kind = constraint.args.get('kind')
-                    if isinstance(kind, exp.Reference):
-                        target_schema, target_table = sql_table_parts(kind.this.this if isinstance(kind.this, exp.Schema) else kind.this, schema)
-                        target_columns = [sql_name(value) for value in (kind.this.expressions if isinstance(kind.this, exp.Schema) else [])]
-                        foreign_keys.append({
-                            'name': constraint.args.get('name') and sql_name(constraint.args['name']),
-                            'columns': [sql_name(element.this)],
-                            'targetSchema': target_schema,
-                            'targetTable': target_table,
-                            'targetColumns': target_columns,
-                        })
-            elif isinstance(element, exp.PrimaryKey):
-                primary_names = {sql_name(value) for value in element.expressions}
-                for column in columns:
-                    if column['name'] in primary_names:
-                        column['primaryKey'] = True
-            elif isinstance(element, exp.ForeignKey):
-                foreign_keys.append(sql_foreign_key_record(element, None, schema, exp))
-            elif isinstance(element, exp.Constraint):
-                constraint_name = sql_name(element.this)
-                handled = False
-                for constraint in element.expressions:
-                    if isinstance(constraint, exp.ForeignKey):
-                        foreign_keys.append(sql_foreign_key_record(constraint, constraint_name, schema, exp))
-                        handled = True
-                    elif isinstance(constraint, exp.PrimaryKey):
-                        primary_names = {sql_name(value) for value in constraint.expressions}
-                        for column in columns:
-                            if column['name'] in primary_names:
-                                column['primaryKey'] = True
-                                column['nullable'] = False
-                        handled = True
-                if not handled:
-                    diagnostics.append({'code': 'SQL_UNSUPPORTED_CLAUSE', 'message': f'Unsupported named constraint {constraint_name} was skipped.'})
-            else:
-                diagnostics.append({'code': 'SQL_UNSUPPORTED_CLAUSE', 'message': f'Unsupported CREATE TABLE clause {type(element).__name__} was skipped.'})
-
-        tables.append({'schema': schema, 'name': table_name, 'columns': columns, 'foreignKeys': foreign_keys})
-    return {'tables': tables, 'diagnostics': diagnostics}
-
-
-def main():
-    raw = sys.stdin.buffer.read(MAX_INPUT_BYTES + 1)
-    if len(raw) > MAX_INPUT_BYTES:
-        parser_failure('optional parser input exceeds the size limit')
-    try:
-        request = json.loads(raw.decode('utf-8'))
-    except Exception:
-        parser_failure('optional parser request is not valid JSON')
-    if not isinstance(request, dict) or not isinstance(request.get('source'), str):
-        parser_failure('optional parser request is invalid')
-    if request.get('adapter') == 'terraform':
-        result = terraform_records(request)
-    elif request.get('adapter') == 'sql':
-        result = sql_records(request)
-    else:
-        parser_failure('optional parser adapter is unsupported')
-    respond({'ok': True, 'result': result})
-
-
-if __name__ == '__main__':
-    main()

package/template/.qoder/skills/drawio/scripts/adapters/python/requirements.txt

@@ -1,2 +0,0 @@
-python-hcl2==8.1.2
-sqlglot==30.12.0

package/template/.qoder/skills/drawio/scripts/adapters/python-code-adapter.test.js

@@ -1,127 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { basename, join, resolve } from 'node:path'
-
-import { parsePythonClassesProject, parsePythonImportsProject } from './python-code.js'
-import { runOptionalPythonCodeParser } from './optional-python-code.js'
-
-function pythonProject() {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-python-'))
-  writeFileSync(join(root, 'a.py'), 'import b\n')
-  writeFileSync(join(root, 'b.py'), 'class A: pass\nclass B(A): pass\n')
-  return root
-}
-
-test('Python imports use stdlib AST records and stable file identities', async () => {
-  const root = pythonProject()
-  try {
-    const projection = await parsePythonImportsProject(root, {
-      runParser: () => ({
-        files: [
-          { path: 'a.py', imports: [{ module: 'b', level: 0, names: [], line: 1, column: 0 }] },
-          { path: 'b.py', imports: [] }
-        ]
-      })
-    })
-    assert.deepEqual(projection.nodes.map((node) => node.identity.key), ['python/a.py', 'python/b.py'])
-    assert.equal(projection.edges[0].relation, 'imports')
-    assert.equal(projection.edges[0].from.key, 'python/a.py')
-    assert.equal(projection.edges[0].to.key, 'python/b.py')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Python classes produce code-class identities and inheritance edges', async () => {
-  const root = pythonProject()
-  try {
-    const projection = await parsePythonClassesProject(root, {
-      runParser: () => ({
-        files: [
-          { path: 'a.py', classes: [] },
-          {
-            path: 'b.py',
-            classes: [
-              { qualifiedName: 'A', bases: [], line: 1, column: 0 },
-              { qualifiedName: 'B', bases: ['A'], line: 2, column: 0 }
-            ]
-          }
-        ]
-      })
-    })
-    assert.deepEqual(projection.nodes.map((node) => node.identity.key), [
-      '["code-module\\u0000python/b.py","A"]',
-      '["code-module\\u0000python/b.py","B"]'
-    ])
-    assert.equal(projection.edges[0].relation, 'inherits')
-    assert.equal(projection.edges[0].from.key, '["code-module\\u0000python/b.py","B"]')
-    assert.equal(projection.edges[0].to.key, '["code-module\\u0000python/b.py","A"]')
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Python parser failures preserve safe source location context', async () => {
-  const root = pythonProject()
-  try {
-    await assert.rejects(
-      () =>
-        parsePythonImportsProject(root, {
-          runParser: () => {
-            const error = new Error('invalid syntax')
-            error.code = 'ADAPTER_PARSE'
-            error.context = { path: 'a.py', line: 1, column: 7 }
-            throw error
-          }
-        }),
-      (error) => error.code === 'ADAPTER_PARSE' && error.context.path === 'a.py' && error.context.line === 1
-    )
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test('Python code worker uses a fixed bounded subprocess envelope', () => {
-  let invocation
-  const result = runOptionalPythonCodeParser(
-    { adapter: 'python-imports', files: [{ path: 'a.py', source: 'import b\n' }] },
-    {
-      pythonCommand: 'python-test',
-      workerPath: 'untrusted-worker.py',
-      allowedAdapters: ['anything'],
-      spawn: (...args) => {
-        invocation = args
-        return { status: 0, stdout: '{"ok":true,"result":{"files":[]}}', stderr: '' }
-      }
-    }
-  )
-  assert.deepEqual(result, { files: [] })
-  assert.equal(invocation[0], 'python-test')
-  assert.equal(invocation[1][0], '-I')
-  assert.match(invocation[1][1], /python[\\/]code-parser-worker\.py$/)
-  assert.equal(invocation[2].shell, false)
-  assert.equal(invocation[2].windowsHide, true)
-  assert.equal(invocation[2].timeout, 10_000)
-  assert.equal(invocation[2].maxBuffer, 1024 * 1024)
-  assert.equal(basename(resolve(invocation[2].cwd)), 'adapters')
-  assert.deepEqual(
-    Object.keys(invocation[2].env).filter((key) => !['PATH', 'SYSTEMROOT', 'WINDIR', 'TEMP', 'TMP'].includes(key)).sort(),
-    ['PYTHONIOENCODING', 'PYTHONUTF8']
-  )
-})
-
-test('Python classes report a distinct empty graph diagnostic', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'drawio-python-'))
-  try {
-    writeFileSync(join(root, 'empty.py'), 'VALUE = 1\n')
-    const projection = await parsePythonClassesProject(root, {
-      runParser: () => ({ files: [{ path: 'empty.py', classes: [] }] })
-    })
-    assert.equal(projection.nodes.length, 0)
-    assert.ok(projection.diagnostics.some((entry) => entry.code === 'CODE_EMPTY_GRAPH'))
-  } finally {
-    rmSync(root, { recursive: true, force: true })
-  }
-})

package/template/.qoder/skills/drawio/scripts/adapters/python-code.js

@@ -1,246 +0,0 @@
-import { basename } from 'node:path'
-
-import {
-  aggregateDiagnostic,
-  codeAdapterError,
-  emptyGraphDiagnostic,
-  finalizeCodeProjection,
-  moduleNode,
-  scanDiagnostics,
-  scanCodeProject
-} from './code-common.js'
-import { ERROR_CODES, createCodeClassIdentity, createCodeIdentity, serializeIdentity } from './identity.js'
-import { runOptionalPythonCodeParser } from './optional-python-code.js'
-
-const PYTHON_EXTENSIONS = ['.py']
-
-function moduleNameForPath(path, rootPackage) {
-  const parts = path.slice(0, -3).split('/')
-  if (parts.at(-1) === '__init__') parts.pop()
-  if (rootPackage) parts.unshift(rootPackage)
-  return parts.join('.')
-}
-
-function validateWorkerFiles(result, scan, field) {
-  if (!result || typeof result !== 'object' || !Array.isArray(result.files)) {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Python code worker returned an invalid result')
-  }
-  const expected = new Set(scan.files.map((file) => file.path))
-  const records = new Map()
-  for (const record of result.files) {
-    if (!record || typeof record !== 'object' || typeof record.path !== 'string' || !Array.isArray(record[field])) {
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Python code worker returned an invalid file record')
-    }
-    if (!expected.has(record.path) || records.has(record.path)) {
-      codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Python code worker returned an unexpected file path', {
-        path: record.path
-      })
-    }
-    records.set(record.path, record)
-  }
-  if (records.size !== expected.size) {
-    codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Python code worker omitted a source file')
-  }
-  return records
-}
-
-function pythonScan(projectRoot) {
-  const scan = scanCodeProject(projectRoot, { extensions: PYTHON_EXTENSIONS })
-  if (scan.files.length === 0) {
-    codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Python project contains no supported source files')
-  }
-  return scan
-}
-
-function pythonModules(scan) {
-  const rootPackage = scan.files.some((file) => file.path === '__init__.py') ? basename(scan.root) : ''
-  const modules = new Map()
-  for (const file of scan.files) {
-    const name = moduleNameForPath(file.path, rootPackage)
-    if (name) modules.set(name, file.path)
-  }
-  return { modules, rootPackage }
-}
-
-function resolveKnownModule(name, currentPath, modules) {
-  const parts = name ? name.split('.') : []
-  while (parts.length > 0) {
-    const candidate = parts.join('.')
-    const path = modules.get(candidate)
-    if (path && path !== currentPath) return path
-    parts.pop()
-  }
-  return null
-}
-
-function relativeModuleName(record, currentName, currentPath) {
-  const isPackage = currentPath.endsWith('/__init__.py') || currentPath === '__init__.py'
-  const packageParts = currentName ? currentName.split('.') : []
-  if (!isPackage) packageParts.pop()
-  const keep = packageParts.length - Math.max(0, record.level - 1)
-  if (keep < 0) return null
-  const prefix = packageParts.slice(0, keep).join('.')
-  return [prefix, record.module].filter(Boolean).join('.')
-}
-
-function pushEdge(edges, seen, from, to, relation) {
-  const key = `${serializeIdentity(from)}\0${relation}\0${serializeIdentity(to)}`
-  if (seen.has(key)) return
-  seen.add(key)
-  edges.push({ from, to, relation, attributes: {} })
-}
-
-export async function parsePythonImportsProject(
-  projectRoot,
-  { locator = 'project', runParser = runOptionalPythonCodeParser } = {}
-) {
-  const scan = pythonScan(projectRoot)
-  const records = validateWorkerFiles(
-    await runParser({ adapter: 'python-imports', files: scan.files }),
-    scan,
-    'imports'
-  )
-  const { modules } = pythonModules(scan)
-  const moduleNameByPath = new Map([...modules].map(([name, path]) => [path, name]))
-  const identities = new Map(scan.files.map((file) => [file.path, createCodeIdentity({ language: 'python', modulePath: file.path })]))
-  const nodes = scan.files.map((file) => moduleNode('python', file.path))
-  const edges = []
-  const seenEdges = new Set()
-  let ignored = 0
-
-  for (const file of scan.files) {
-    const currentName = moduleNameByPath.get(file.path) || ''
-    for (const record of records.get(file.path).imports) {
-      if (
-        !record ||
-        typeof record.module !== 'string' ||
-        !Number.isInteger(record.level) ||
-        record.level < 0 ||
-        !Array.isArray(record.names)
-      ) {
-        codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Python code worker returned an invalid import record', {
-          path: file.path
-        })
-      }
-      const moduleName = record.level > 0
-        ? relativeModuleName(record, currentName, file.path)
-        : record.module
-      if (moduleName == null) {
-        codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Python relative import escapes the selected project', {
-          path: file.path,
-          line: record.line,
-          column: record.column
-        })
-      }
-      const candidates = [moduleName]
-      for (const name of record.names) {
-        if (typeof name === 'string' && name !== '*') candidates.push([moduleName, name].filter(Boolean).join('.'))
-      }
-      const targets = new Set(candidates.map((name) => resolveKnownModule(name, file.path, modules)).filter(Boolean))
-      if (targets.size === 0) {
-        if (record.level > 0) {
-          codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, 'Python relative import does not resolve inside the selected project', {
-            path: file.path,
-            line: record.line,
-            column: record.column
-          })
-        }
-        ignored++
-        continue
-      }
-      for (const targetPath of targets) {
-        pushEdge(edges, seenEdges, identities.get(file.path), identities.get(targetPath), 'imports')
-      }
-    }
-  }
-
-  return finalizeCodeProjection({
-    adapter: 'python-imports',
-    locator,
-    nodes,
-    edges,
-    diagnostics: [
-      ...aggregateDiagnostic('CODE_EXTERNAL_IMPORTS_IGNORED', ignored, 'External or standard-library imports were ignored.'),
-      ...scanDiagnostics(scan)
-    ]
-  })
-}
-
-export async function parsePythonClassesProject(
-  projectRoot,
-  { locator = 'project', runParser = runOptionalPythonCodeParser } = {}
-) {
-  const scan = pythonScan(projectRoot)
-  const records = validateWorkerFiles(
-    await runParser({ adapter: 'python-classes', files: scan.files }),
-    scan,
-    'classes'
-  )
-  const classes = []
-  const byName = new Map()
-  for (const file of scan.files) {
-    const moduleIdentity = createCodeIdentity({ language: 'python', modulePath: file.path })
-    for (const record of records.get(file.path).classes) {
-      if (
-        !record ||
-        typeof record.qualifiedName !== 'string' ||
-        !Array.isArray(record.bases) ||
-        !record.bases.every((base) => typeof base === 'string')
-      ) {
-        codeAdapterError(ERROR_CODES.ADAPTER_PARSE, 'Python code worker returned an invalid class record', {
-          path: file.path
-        })
-      }
-      const identity = createCodeClassIdentity({ moduleIdentity, qualifiedClassName: record.qualifiedName })
-      const entry = { ...record, path: file.path, identity, moduleIdentity }
-      classes.push(entry)
-      const simpleName = record.qualifiedName.split('.').at(-1)
-      byName.set(simpleName, [...(byName.get(simpleName) || []), entry])
-    }
-  }
-
-  const nodes = classes.map((entry) => ({
-    identity: entry.identity,
-    label: entry.qualifiedName,
-    semanticType: 'component',
-    attributes: {}
-  }))
-  const edges = []
-  const seenEdges = new Set()
-  let ignored = 0
-  for (const entry of classes) {
-    for (const base of entry.bases) {
-      const candidates = byName.get(base) || []
-      const sameModule = candidates.filter(
-        (candidate) => serializeIdentity(candidate.moduleIdentity) === serializeIdentity(entry.moduleIdentity)
-      )
-      const target = sameModule.length === 1 ? sameModule[0] : candidates.length === 1 ? candidates[0] : null
-      if (!target) {
-        if (candidates.length > 1) {
-          codeAdapterError(ERROR_CODES.ADAPTER_UNSUPPORTED, `Python base class "${base}" is ambiguous`, {
-            path: entry.path,
-            line: entry.line,
-            column: entry.column
-          })
-        }
-        ignored++
-        continue
-      }
-      if (serializeIdentity(target.identity) !== serializeIdentity(entry.identity)) {
-        pushEdge(edges, seenEdges, entry.identity, target.identity, 'inherits')
-      }
-    }
-  }
-
-  return finalizeCodeProjection({
-    adapter: 'python-classes',
-    locator,
-    nodes,
-    edges,
-    diagnostics: [
-      ...aggregateDiagnostic('CODE_EXTERNAL_BASES_IGNORED', ignored, 'External base classes were ignored.'),
-      ...emptyGraphDiagnostic(nodes, 'No top-level Python classes were found in the selected project.'),
-      ...scanDiagnostics(scan)
-    ]
-  })
-}