@airalogy/aimd-editor 1.7.1

package/dist/vue.js

@@ -0,0 +1,30 @@
+import { _ as e, a as d, b as s, c as r, u as o } from "./AimdEditorTopBar.vue_vue_type_script_setup_true_lang-gbfMDZSh.js";
+import { _ as m } from "./AimdSourceEditor.vue_vue_type_script_setup_true_lang-t_sUoXky.js";
+import { A as E, a as l, _ as I, D as _, M as T, b as D, c as F, d as M, e as u, f as c, g as n, h as g, i as L, j as O, k as p, l as S, m as y, n as b, r as f } from "./AimdWysiwygEditor.vue_vue_type_script_setup_true_lang-B8o1VbUH.js";
+export {
+  E as AIMD_FIELD_TYPES,
+  l as AIMD_FIELD_TYPE_DEFINITIONS,
+  e as AimdEditor,
+  d as AimdEditorToolbar,
+  s as AimdEditorTopBar,
+  r as AimdFieldDialog,
+  m as AimdSourceEditor,
+  I as AimdWysiwygEditor,
+  _ as DEFAULT_AIMD_EDITOR_LOCALE,
+  T as MD_TOOLBAR_ITEMS,
+  D as MD_TOOLBAR_ITEM_DEFINITIONS,
+  F as aimdFieldInputRule,
+  M as aimdFieldNode,
+  u as aimdFieldView,
+  c as aimdMilkdownPlugins,
+  n as aimdRemarkPlugin,
+  g as buildAimdSyntax,
+  L as createAimdEditorMessages,
+  O as createAimdFieldTypes,
+  p as createAimdVarTypePresets,
+  S as createMdToolbarItems,
+  y as getDefaultAimdFields,
+  b as getQuickAimdSyntax,
+  f as resolveAimdEditorLocale,
+  o as useEditorContent
+};

package/dist/wysiwyg.js

@@ -0,0 +1,9 @@
+import { _ as a, D as r, i, j as d, k as t, r as A } from "./AimdWysiwygEditor.vue_vue_type_script_setup_true_lang-B8o1VbUH.js";
+export {
+  a as AimdWysiwygEditor,
+  r as DEFAULT_AIMD_EDITOR_LOCALE,
+  i as createAimdEditorMessages,
+  d as createAimdFieldTypes,
+  t as createAimdVarTypePresets,
+  A as resolveAimdEditorLocale
+};

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@airalogy/aimd-editor",
+  "type": "module",
+  "version": "1.7.1",
+  "description": "AIMD editor with Monaco source mode and Milkdown WYSIWYG mode",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/airalogy/aimd.git",
+    "directory": "packages/aimd-editor"
+  },
+  "bugs": {
+    "url": "https://github.com/airalogy/aimd/issues"
+  },
+  "homepage": "https://github.com/airalogy/aimd/tree/main/packages/aimd-editor#readme",
+  "keywords": [
+    "aimd",
+    "monaco",
+    "milkdown",
+    "editor",
+    "wysiwyg",
+    "markdown",
+    "vue"
+  ],
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./src/index.ts"
+    },
+    "./monaco": {
+      "types": "./src/monaco.ts",
+      "import": "./src/monaco.ts"
+    },
+    "./vue": {
+      "types": "./src/vue/index.ts",
+      "import": "./src/vue/index.ts"
+    },
+    "./embedded": {
+      "types": "./src/embedded.ts",
+      "import": "./src/embedded.ts"
+    },
+    "./wysiwyg": {
+      "types": "./src/wysiwyg.ts",
+      "import": "./src/wysiwyg.ts"
+    }
+  },
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "type-check": "tsc --noEmit",
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "test": "node --test ./tests/*.test.mjs"
+  },
+  "dependencies": {
+    "@airalogy/aimd-core": "workspace:^",
+    "@airalogy/aimd-renderer": "workspace:^",
+    "@codingame/monaco-vscode-editor-api": "^20.2.1",
+    "@codingame/monaco-vscode-standalone-languages": "^20.2.1",
+    "@milkdown/kit": "^7.18.0",
+    "@milkdown/theme-nord": "^7.18.0",
+    "@milkdown/vue": "^7.18.0"
+  },
+  "peerDependencies": {
+    "monaco-editor": ">=0.50.0",
+    "vue": ">=3.3.0"
+  },
+  "peerDependenciesMeta": {
+    "monaco-editor": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "monaco-editor": "^0.52.2",
+    "shiki": "^2.3.2",
+    "typescript": "5.8.3",
+    "vite": "^7.1.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vue": "^3.5.17",
+    "@vitejs/plugin-vue": "^6.0.1"
+  }
+}

package/src/__tests__/editor.test.ts

@@ -0,0 +1,296 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  AimdToken,
+  AimdTokenDefinition,
+  AimdSuffix,
+  MarkupDefinition,
+  KeywordDefinition,
+  DelimiterDefinition,
+  scopeName,
+} from '../tokens'
+import { aimdTheme, aimdTokenColors } from '../theme'
+import {
+  getDefaultAimdFields,
+  buildAimdSyntax,
+  createAimdFieldTypes,
+  createMdToolbarItems,
+  createAimdVarTypePresets,
+  AIMD_FIELD_TYPE_DEFINITIONS,
+  MD_TOOLBAR_ITEM_DEFINITIONS,
+} from '../vue/types'
+import { resolveAimdEditorLocale, createAimdEditorMessages } from '../vue/locales'
+
+// ---------------------------------------------------------------------------
+// Token definitions
+// ---------------------------------------------------------------------------
+
+describe('AimdToken definitions', () => {
+  it('has markup tokens', () => {
+    expect(AimdToken).toHaveProperty('MARKUP_AIMD_VARIABLE')
+    expect(AimdToken).toHaveProperty('MARKUP_AIMD_STEP')
+    expect(AimdToken).toHaveProperty('MARKUP_AIMD_CHECKPOINT')
+  })
+
+  it('has keyword tokens', () => {
+    expect(AimdToken).toHaveProperty('KEYWORD_VARIABLE_AIMD')
+    expect(AimdToken).toHaveProperty('KEYWORD_STEP_AIMD')
+  })
+
+  it('has delimiter tokens', () => {
+    expect(AimdToken).toHaveProperty('DELIMITER_PIPE_AIMD')
+    expect(AimdToken).toHaveProperty('DELIMITER_COLON_AIMD')
+  })
+
+  it('token suffix is "aimd"', () => {
+    expect(AimdSuffix).toBe('aimd')
+  })
+
+  it('scope name follows TextMate convention', () => {
+    expect(scopeName).toBe('text.html.markdown.aimd')
+  })
+
+  it('MarkupDefinition has variable and step entries', () => {
+    expect(MarkupDefinition).toHaveProperty('MARKUP_AIMD_VARIABLE')
+    expect(MarkupDefinition).toHaveProperty('MARKUP_AIMD_STEP')
+  })
+
+  it('KeywordDefinition has entries', () => {
+    expect(Object.keys(KeywordDefinition).length).toBeGreaterThan(0)
+  })
+
+  it('DelimiterDefinition has entries', () => {
+    expect(Object.keys(DelimiterDefinition).length).toBeGreaterThan(0)
+  })
+
+  it('AimdTokenDefinition has type tokens', () => {
+    expect(AimdTokenDefinition).toHaveProperty('KEYWORD_CONTROL_AIMD')
+    expect(AimdTokenDefinition).toHaveProperty('VARIABLE_PARAMETER_AIMD')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Theme (no Monaco dependency)
+// ---------------------------------------------------------------------------
+
+describe('AIMD theme', () => {
+  it('aimdTheme has proper structure', () => {
+    expect(aimdTheme).toHaveProperty('name')
+    expect(aimdTheme).toHaveProperty('settings')
+  })
+
+  it('aimdTokenColors is an array', () => {
+    expect(Array.isArray(aimdTokenColors)).toBe(true)
+    expect(aimdTokenColors.length).toBeGreaterThan(0)
+  })
+
+  it('token colors have scope and settings', () => {
+    for (const color of aimdTokenColors) {
+      expect(color).toHaveProperty('scope')
+      expect(color).toHaveProperty('settings')
+    }
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getDefaultAimdFields
+// ---------------------------------------------------------------------------
+
+describe('getDefaultAimdFields', () => {
+  it('returns var defaults', () => {
+    const fields = getDefaultAimdFields('var')
+    expect(fields).toHaveProperty('name')
+    expect(fields).toHaveProperty('type')
+    expect(fields.type).toBe('str')
+  })
+
+  it('returns step defaults with level 1', () => {
+    const fields = getDefaultAimdFields('step')
+    expect(fields).toHaveProperty('name')
+    expect(fields).toHaveProperty('level')
+    expect(fields.level).toBe('1')
+  })
+
+  it('returns check defaults', () => {
+    const fields = getDefaultAimdFields('check')
+    expect(fields).toHaveProperty('name')
+  })
+
+  it('returns quiz defaults', () => {
+    const fields = getDefaultAimdFields('quiz')
+    expect(fields).toHaveProperty('id')
+    expect(fields).toHaveProperty('quizType')
+    expect(fields.quizType).toBe('choice')
+  })
+
+  it('returns var_table defaults', () => {
+    const fields = getDefaultAimdFields('var_table')
+    expect(fields).toHaveProperty('name')
+    expect(fields).toHaveProperty('subvars')
+  })
+
+  it('returns generic defaults for unknown type', () => {
+    const fields = getDefaultAimdFields('unknown')
+    expect(fields).toHaveProperty('name')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildAimdSyntax
+// ---------------------------------------------------------------------------
+
+describe('buildAimdSyntax', () => {
+  it('builds simple var syntax', () => {
+    const syntax = buildAimdSyntax('var', { name: 'temperature', type: 'float', default: '36.5', title: '' })
+    expect(syntax).toBe('{{var|temperature: float = 36.5}}')
+  })
+
+  it('builds var with title', () => {
+    const syntax = buildAimdSyntax('var', { name: 'temp', type: 'float', default: '', title: 'Temperature' })
+    expect(syntax).toContain('title = "Temperature"')
+  })
+
+  it('builds var without type or default', () => {
+    const syntax = buildAimdSyntax('var', { name: 'note', type: '', default: '', title: '' })
+    expect(syntax).toBe('{{var|note}}')
+  })
+
+  it('uses fallback name when empty', () => {
+    const syntax = buildAimdSyntax('var', { name: '', type: '', default: '', title: '' })
+    expect(syntax).toContain('my_var')
+  })
+
+  it('builds step syntax', () => {
+    const syntax = buildAimdSyntax('step', { name: 'wash_hands', level: '1' })
+    expect(syntax).toBe('{{step|wash_hands}}')
+  })
+
+  it('builds step with level > 1', () => {
+    const syntax = buildAimdSyntax('step', { name: 'substep', level: '2' })
+    expect(syntax).toBe('{{step|substep, 2}}')
+  })
+
+  it('builds var_table syntax', () => {
+    const syntax = buildAimdSyntax('var_table', { name: 'measurements', subvars: 'temp, pressure' })
+    expect(syntax).toContain('var_table|measurements')
+    expect(syntax).toContain('subvars=[temp, pressure]')
+  })
+
+  it('builds check syntax', () => {
+    const syntax = buildAimdSyntax('check', { name: 'verify_result' })
+    expect(syntax).toBe('{{check|verify_result}}')
+  })
+
+  it('builds ref_step syntax', () => {
+    const syntax = buildAimdSyntax('ref_step', { name: 'step1' })
+    expect(syntax).toContain('ref_step')
+    expect(syntax).toContain('step1')
+  })
+
+  it('builds quiz syntax', () => {
+    const syntax = buildAimdSyntax('quiz', {
+      id: 'q1',
+      quizType: 'choice',
+      mode: 'single',
+      stem: 'What is 1+1?',
+      options: 'A:One, B:Two',
+      answer: 'B',
+      blanks: '',
+      rubric: '',
+      score: '',
+    })
+    expect(syntax).toContain('```quiz')
+    expect(syntax).toContain('id: q1')
+    expect(syntax).toContain('type: choice')
+    expect(syntax).toContain('mode: single')
+    expect(syntax).toContain('What is 1+1?')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Locale helpers
+// ---------------------------------------------------------------------------
+
+describe('resolveAimdEditorLocale', () => {
+  it('defaults to en-US', () => {
+    expect(resolveAimdEditorLocale()).toBe('en-US')
+  })
+
+  it('resolves zh to zh-CN', () => {
+    expect(resolveAimdEditorLocale('zh')).toBe('zh-CN')
+    expect(resolveAimdEditorLocale('zh-CN')).toBe('zh-CN')
+  })
+
+  it('resolves en to en-US', () => {
+    expect(resolveAimdEditorLocale('en')).toBe('en-US')
+  })
+})
+
+describe('createAimdEditorMessages', () => {
+  it('creates messages with expected sections', () => {
+    const messages = createAimdEditorMessages('en-US')
+    expect(messages).toHaveProperty('defaults')
+    expect(messages).toHaveProperty('fieldTypes')
+    expect(messages).toHaveProperty('mdToolbar')
+  })
+
+  it('merges custom overrides', () => {
+    const messages = createAimdEditorMessages('en-US', {
+      defaults: { questionStem: 'Custom stem' },
+    })
+    expect(messages.defaults.questionStem).toBe('Custom stem')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Field type and toolbar definitions
+// ---------------------------------------------------------------------------
+
+describe('AIMD field type definitions', () => {
+  it('has expected field types', () => {
+    const types = AIMD_FIELD_TYPE_DEFINITIONS.map(d => d.type)
+    expect(types).toContain('var')
+    expect(types).toContain('step')
+    expect(types).toContain('check')
+    expect(types).toContain('quiz')
+  })
+
+  it('createAimdFieldTypes localizes definitions', () => {
+    const messages = createAimdEditorMessages('en-US')
+    const types = createAimdFieldTypes(messages)
+    expect(types.length).toBe(AIMD_FIELD_TYPE_DEFINITIONS.length)
+    expect(types[0]).toHaveProperty('label')
+  })
+})
+
+describe('MD toolbar item definitions', () => {
+  it('has expected toolbar actions', () => {
+    const actions = MD_TOOLBAR_ITEM_DEFINITIONS.map(d => d.action)
+    expect(actions).toContain('h1')
+    expect(actions).toContain('bold')
+  })
+
+  it('createMdToolbarItems localizes items', () => {
+    const messages = createAimdEditorMessages('en-US')
+    const items = createMdToolbarItems(messages)
+    expect(items.length).toBe(MD_TOOLBAR_ITEM_DEFINITIONS.length)
+    const nonSeparator = items.find(i => !i.action.startsWith('sep'))
+    expect(nonSeparator).toHaveProperty('title')
+  })
+})
+
+describe('AIMD var type presets', () => {
+  it('includes built-in recorder-aware code string presets', () => {
+    const messages = createAimdEditorMessages('en-US')
+    const presets = createAimdVarTypePresets(messages)
+    const presetValues = presets.map(preset => preset.value)
+
+    expect(presetValues).toContain('CodeStr')
+    expect(presetValues).toContain('PyStr')
+    expect(presetValues).toContain('JsStr')
+    expect(presetValues).toContain('TsStr')
+    expect(presetValues).toContain('JsonStr')
+    expect(presetValues).toContain('TomlStr')
+    expect(presetValues).toContain('YamlStr')
+  })
+})

package/src/embedded.ts

@@ -0,0 +1,18 @@
+export { default as AimdSourceEditor } from './vue/AimdSourceEditor.vue'
+export { default as AimdWysiwygEditor } from './vue/AimdWysiwygEditor.vue'
+export {
+  createAimdEditorMessages,
+  DEFAULT_AIMD_EDITOR_LOCALE,
+  resolveAimdEditorLocale,
+} from './vue/locales'
+export {
+  createAimdFieldTypes,
+  createAimdVarTypePresets,
+} from './vue/types'
+export type {
+  AimdFieldType,
+  AimdVarTypePresetOption,
+  AimdEditorMessages,
+  AimdEditorMessagesInput,
+  AimdEditorLocale,
+} from './vue/index'

package/src/index.ts

@@ -0,0 +1,10 @@
+/// <reference path="./vue/env.d.ts" />
+
+/**
+ * @airalogy/aimd-editor
+ *
+ * Root entry that re-exports Monaco integration and Vue editor APIs.
+ */
+
+export * from './monaco'
+export * from './vue/index'

package/src/language-config.ts

@@ -0,0 +1,152 @@
+import { languages } from "@codingame/monaco-vscode-editor-api"
+
+// @ts-ignore - No type definitions available
+import { type languages as languagesNS, conf as markdownConf, language as markdownLanguage } from "@codingame/monaco-vscode-standalone-languages/markdown/markdown"
+import { AimdToken } from "./tokens"
+
+const autoClosingPairs: languages.IAutoClosingPairConditional[] = [
+  ...(markdownConf.autoClosingPairs as any[] || []),
+]
+const surroundingPairs = autoClosingPairs
+
+function getTokens(tokens: string, divider = "|"): string[] {
+  return tokens.split(divider)
+}
+const keywords: string[] = getTokens("var|var_table|check|step|ref_step|ref_var|ref_table|table_link")
+
+export const language: languagesNS.IMonarchLanguage = {
+  ...markdownLanguage,
+  tokenPostfix: ".aimd",
+  keywords,
+  tokenizer: {
+    ...markdownLanguage.tokenizer!,
+    root: [
+      [/^\s*(```|~~~)\s*quiz(?:\s+.*)?\s*$/, {
+        token: "string",
+        next: "@quizCodeblock",
+        nextEmbedded: "yaml",
+      }],
+      [/^\s*(```|~~~)\s*assigner(?:\s+.*\bruntime\s*=\s*(?:"client"|'client'|client)\b.*)\s*$/, {
+        token: "string",
+        next: "@assignerCodeblock",
+        nextEmbedded: "javascript",
+      }],
+      [/^\s*(```|~~~)\s*assigner(?:\s+.*)?\s*$/, {
+        token: "string",
+        next: "@assignerCodeblock",
+        nextEmbedded: "python",
+      }],
+      ...markdownLanguage.tokenizer.root,
+      { include: "@aimd" },
+    ],
+    table_body: [...markdownLanguage.tokenizer.table_body, { include: "@aimd" }],
+    assignerCodeblock: [
+      [/^\s*(```|~~~)\s*$/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+      [/.*$/, ""],
+    ],
+    quizCodeblock: [
+      [/^\s*(```|~~~)\s*$/, { token: "string", next: "@pop", nextEmbedded: "@pop" }],
+      [/.*$/, ""],
+    ],
+    aimd: [
+      // 1. AIMD Protocol Fields: {{keyword|content}}
+      // This rule finds the opening '{{' and switches to the 'protocol' state
+      // to handle the special syntax. This has the highest priority.
+      [/\{\{/, {
+        token: AimdToken.PUNCTUATION_DEFINITION_BEGIN_AIMD,
+        bracket: "@open",
+        next: "@protocol",
+      }],
+
+      // Links: [text](url)
+      [/\[([^\]]+)\]\s*\(([^)]+)\)/, [
+        { token: AimdToken.METATAG_LINK_AIMD }, // [
+        { token: AimdToken.STRING_LINK_DESCRIPTION_AIMD }, // text
+        { token: AimdToken.METATAG_LINK_AIMD }, // ](
+        { token: AimdToken.STRING_LINK_URL_AIMD }, // url
+        { token: AimdToken.METATAG_LINK_AIMD }, // )
+      ]],
+
+      // Images: ![alt](src)
+      [/!\[([^\]]+)\]\s*\(([^)]+)\)/, [
+        { token: AimdToken.METATAG_IMAGE_AIMD }, // ![
+        { token: AimdToken.STRING_LINK_DESCRIPTION_AIMD }, // alt
+        { token: AimdToken.METATAG_IMAGE_AIMD }, // ](
+        { token: AimdToken.STRING_LINK_URL_AIMD }, // src
+        { token: AimdToken.METATAG_IMAGE_AIMD }, // )
+      ]],
+    ],
+    // This state is active inside {{ ... }}
+    protocol: [
+      // Match the keywords from your regexes
+      // [/(var_table|var|quiz|step|check|ref_step|ref_var|ref_fig|cite|fig)/, AimdToken.KEYWORD_CONTROL_AIMD],
+      [/var(\s*\|)/, AimdToken.KEYWORD_VARIABLE_AIMD],
+      [/var_table(\s*\|)/, AimdToken.KEYWORD_VARIABLE_TABLE_AIMD],
+      [/step(\s*\|)/, AimdToken.KEYWORD_STEP_AIMD],
+      [/check(\s*\|)/, AimdToken.KEYWORD_CHECKPOINT_AIMD],
+      [/ref_var(\s*\|)/, AimdToken.KEYWORD_REFERENCE_VARIABLE_AIMD],
+      [/ref_step(\s*\|)/, AimdToken.KEYWORD_REFERENCE_STEP_AIMD],
+      // Match the pipe delimiter
+      [/\|/, { token: AimdToken.DELIMITER_PIPE_AIMD, next: "@protocolContent" }],
+      // Match the closing '}}' and pop back to the root state
+      [/\}\}/, { token: AimdToken.PUNCTUATION_DEFINITION_END_AIMD, bracket: "@close", next: "@pop" }],
+    ],
+    // Content inside protocol after the pipe delimiter - supports type syntax
+    protocolContent: [
+      // Match the closing '}}' and pop back to the root state
+      [/\}\}/, { token: AimdToken.PUNCTUATION_DEFINITION_END_AIMD, bracket: "@close", next: "@popall" }],
+      // Match subvars keyword
+      [/\bsubvars\b/, AimdToken.KEYWORD_OTHER_SUBVARS_AIMD],
+      // Match var keyword (for nested var() calls in subvars)
+      [/\bvar\b/, AimdToken.KEYWORD_VARIABLE_AIMD],
+      // Match type annotations after colon (e.g., : str, : int, : list[Student])
+      [/:/, { token: AimdToken.DELIMITER_COLON_AIMD, next: "@typeAnnotation" }],
+      // Match string literals (double or single quoted)
+      [/"([^"\\]|\\.)*"/, AimdToken.STRING_QUOTED_AIMD],
+      [/'([^'\\]|\\.)*'/, AimdToken.STRING_QUOTED_AIMD],
+      // Match numbers (integer and float)
+      [/-?\d+\.?\d*/, AimdToken.CONSTANT_NUMERIC_AIMD],
+      // Match boolean/null literals
+      [/\b(true|false|True|False|null|None)\b/, AimdToken.CONSTANT_LANGUAGE_AIMD],
+      // Match equals signs and commas used for parameters
+      [/=/, AimdToken.DELIMITER_PARAMETER_AIMD],
+      [/,/, AimdToken.DELIMITER_PARAMETER_AIMD],
+      // Match brackets for subvars and type params
+      [/[[\]()]/, AimdToken.DELIMITER_BRACKET_AIMD],
+      // Match variable name (identifier at start)
+      [/\b\w+\b/, AimdToken.VARIABLE_OTHER_AIMD],
+      // Skip whitespace
+      [/\s+/, ""],
+    ],
+    // Type annotation state (after colon)
+    typeAnnotation: [
+      // Match type with generic params like list[Student]
+      [/\w+(?:\[[\w,\s]+\])?/, { token: AimdToken.SUPPORT_TYPE_AIMD, next: "@pop" }],
+      // Skip whitespace
+      [/\s+/, ""],
+      // Pop on other characters
+      [/./, { token: "@rematch", next: "@pop" }],
+    ],
+  },
+}
+
+export const conf: languagesNS.LanguageConfiguration = {
+  ...markdownConf,
+  autoClosingPairs,
+  surroundingPairs,
+}
+
+export const completionItemProvider: languagesNS.CompletionItemProvider = {
+  provideCompletionItems: (doc: any, position: any) => {
+    const suggestions = keywords.map((value) => {
+      return {
+        label: value,
+        kind: languages.CompletionItemKind.Keyword,
+        insertText: value,
+        insertTextRules: languages.CompletionItemInsertTextRule.InsertAsSnippet,
+      } as languagesNS.CompletionItem
+    })
+
+    return { suggestions } as languagesNS.ProviderResult<languagesNS.CompletionList>
+  },
+}

package/src/monaco.ts

@@ -0,0 +1,19 @@
+/**
+ * @airalogy/aimd-editor/monaco
+ *
+ * AIMD Monaco editor integration
+ *
+ * This entry provides language config and themes for AIMD.
+ */
+
+export { language, conf, completionItemProvider } from './language-config'
+export { aimdTokenColors, aimdTheme, createAimdExtendedTheme } from './theme'
+export {
+  AimdToken,
+  AimdTokenDefinition,
+  AimdSuffix,
+  DelimiterDefinition,
+  KeywordDefinition,
+  MarkupDefinition,
+  scopeName,
+} from './tokens'