@difizen/libro-cofine-textmate 0.1.2

package/src/data/monaco-themes/vscode/light_vs.json

@@ -0,0 +1,380 @@
+{
+  "$schema": "vscode://schemas/color-theme",
+  "name": "Light (Visual Studio)",
+  "include": "light_defaults.json",
+  "colors": {},
+  "tokenColors": [
+    {
+      "scope": ["meta.embedded", "source.groovy.embedded"],
+      "settings": {
+        "foreground": "#000000ff"
+      }
+    },
+    {
+      "scope": "emphasis",
+      "settings": {
+        "fontStyle": "italic"
+      }
+    },
+    {
+      "scope": "strong",
+      "settings": {
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "meta.diff.header",
+      "settings": {
+        "foreground": "#000080"
+      }
+    },
+    {
+      "scope": "comment",
+      "settings": {
+        "foreground": "#008000"
+      }
+    },
+    {
+      "scope": "constant.language",
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": [
+        "constant.numeric",
+        "entity.name.operator.custom-literal.number",
+        "variable.other.enummember",
+        "keyword.operator.plus.exponent",
+        "keyword.operator.minus.exponent"
+      ],
+      "settings": {
+        "foreground": "#09885a"
+      }
+    },
+    {
+      "scope": "constant.regexp",
+      "settings": {
+        "foreground": "#811f3f"
+      }
+    },
+    {
+      "name": "css tags in selectors, xml tags",
+      "scope": "entity.name.tag",
+      "settings": {
+        "foreground": "#800000"
+      }
+    },
+    {
+      "scope": "entity.name.selector",
+      "settings": {
+        "foreground": "#800000"
+      }
+    },
+    {
+      "scope": "entity.other.attribute-name",
+      "settings": {
+        "foreground": "#ff0000"
+      }
+    },
+    {
+      "scope": [
+        "entity.other.attribute-name.class.css",
+        "entity.other.attribute-name.class.mixin.css",
+        "entity.other.attribute-name.id.css",
+        "entity.other.attribute-name.parent-selector.css",
+        "entity.other.attribute-name.pseudo-class.css",
+        "entity.other.attribute-name.pseudo-element.css",
+        "source.css.less entity.other.attribute-name.id",
+        "entity.other.attribute-name.attribute.scss",
+        "entity.other.attribute-name.scss"
+      ],
+      "settings": {
+        "foreground": "#800000"
+      }
+    },
+    {
+      "scope": "invalid",
+      "settings": {
+        "foreground": "#cd3131"
+      }
+    },
+    {
+      "scope": "markup.underline",
+      "settings": {
+        "fontStyle": "underline"
+      }
+    },
+    {
+      "scope": "markup.bold",
+      "settings": {
+        "fontStyle": "bold",
+        "foreground": "#000080"
+      }
+    },
+    {
+      "scope": "markup.heading",
+      "settings": {
+        "fontStyle": "bold",
+        "foreground": "#800000"
+      }
+    },
+    {
+      "scope": "markup.italic",
+      "settings": {
+        "fontStyle": "italic"
+      }
+    },
+    {
+      "scope": "markup.inserted",
+      "settings": {
+        "foreground": "#09885a"
+      }
+    },
+    {
+      "scope": "markup.deleted",
+      "settings": {
+        "foreground": "#a31515"
+      }
+    },
+    {
+      "scope": "markup.changed",
+      "settings": {
+        "foreground": "#0451a5"
+      }
+    },
+    {
+      "scope": [
+        "punctuation.definition.quote.begin.markdown",
+        "punctuation.definition.list.begin.markdown"
+      ],
+      "settings": {
+        "foreground": "#0451a5"
+      }
+    },
+    {
+      "scope": "markup.inline.raw",
+      "settings": {
+        "foreground": "#800000"
+      }
+    },
+    {
+      "name": "brackets of XML/HTML tags",
+      "scope": "punctuation.definition.tag",
+      "settings": {
+        "foreground": "#800000"
+      }
+    },
+    {
+      "scope": ["meta.preprocessor", "entity.name.function.preprocessor"],
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": "meta.preprocessor.string",
+      "settings": {
+        "foreground": "#a31515"
+      }
+    },
+    {
+      "scope": "meta.preprocessor.numeric",
+      "settings": {
+        "foreground": "#09885a"
+      }
+    },
+    {
+      "scope": "meta.structure.dictionary.key.python",
+      "settings": {
+        "foreground": "#0451a5"
+      }
+    },
+    {
+      "scope": "storage",
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": "storage.type",
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": ["storage.modifier", "keyword.operator.noexcept"],
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": [
+        "string",
+        "entity.name.operator.custom-literal.string",
+        "meta.embedded.assembly"
+      ],
+      "settings": {
+        "foreground": "#a31515"
+      }
+    },
+    {
+      "scope": [
+        "string.comment.buffered.block.pug",
+        "string.quoted.pug",
+        "string.interpolated.pug",
+        "string.unquoted.plain.in.yaml",
+        "string.unquoted.plain.out.yaml",
+        "string.unquoted.block.yaml",
+        "string.quoted.single.yaml",
+        "string.quoted.double.xml",
+        "string.quoted.single.xml",
+        "string.unquoted.cdata.xml",
+        "string.quoted.double.html",
+        "string.quoted.single.html",
+        "string.unquoted.html",
+        "string.quoted.single.handlebars",
+        "string.quoted.double.handlebars"
+      ],
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": "string.regexp",
+      "settings": {
+        "foreground": "#811f3f"
+      }
+    },
+    {
+      "name": "String interpolation",
+      "scope": [
+        "punctuation.definition.template-expression.begin",
+        "punctuation.definition.template-expression.end",
+        "punctuation.section.embedded"
+      ],
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "name": "Reset JavaScript string interpolation expression",
+      "scope": ["meta.template.expression"],
+      "settings": {
+        "foreground": "#000000"
+      }
+    },
+    {
+      "scope": [
+        "support.constant.property-value",
+        "support.constant.font-name",
+        "support.constant.media-type",
+        "support.constant.media",
+        "constant.other.color.rgb-value",
+        "constant.other.rgb-value",
+        "support.constant.color"
+      ],
+      "settings": {
+        "foreground": "#0451a5"
+      }
+    },
+    {
+      "scope": [
+        "support.type.vendored.property-name",
+        "support.type.property-name",
+        "variable.css",
+        "variable.scss",
+        "variable.other.less",
+        "source.coffee.embedded"
+      ],
+      "settings": {
+        "foreground": "#ff0000"
+      }
+    },
+    {
+      "scope": ["support.type.property-name.json"],
+      "settings": {
+        "foreground": "#0451a5"
+      }
+    },
+    {
+      "scope": "keyword",
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": "keyword.control",
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": "keyword.operator",
+      "settings": {
+        "foreground": "#000000"
+      }
+    },
+    {
+      "scope": [
+        "keyword.operator.new",
+        "keyword.operator.expression",
+        "keyword.operator.cast",
+        "keyword.operator.sizeof",
+        "keyword.operator.alignof",
+        "keyword.operator.typeid",
+        "keyword.operator.alignas",
+        "keyword.operator.instanceof",
+        "keyword.operator.logical.python",
+        "keyword.operator.wordlike"
+      ],
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    },
+    {
+      "scope": "keyword.other.unit",
+      "settings": {
+        "foreground": "#09885a"
+      }
+    },
+    {
+      "scope": [
+        "punctuation.section.embedded.begin.php",
+        "punctuation.section.embedded.end.php"
+      ],
+      "settings": {
+        "foreground": "#800000"
+      }
+    },
+    {
+      "scope": "support.function.git-rebase",
+      "settings": {
+        "foreground": "#0451a5"
+      }
+    },
+    {
+      "scope": "constant.sha.git-rebase",
+      "settings": {
+        "foreground": "#09885a"
+      }
+    },
+    {
+      "name": "coloring of the Java import and package identifiers",
+      "scope": [
+        "storage.modifier.import.java",
+        "variable.language.wildcard.java",
+        "storage.modifier.package.java"
+      ],
+      "settings": {
+        "foreground": "#000000"
+      }
+    },
+    {
+      "name": "this.self",
+      "scope": "variable.language",
+      "settings": {
+        "foreground": "#0000ff"
+      }
+    }
+  ]
+}

package/src/global.d.ts

@@ -0,0 +1,7 @@
+declare module '@difizen/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+declare module '@difizen/monaco-editor-core/esm/vs/editor/standalone/common/standaloneTheme';
+declare module '@difizen/monaco-editor-core/esm/vs/editor/common/languages/language';
+declare module '@difizen/monaco-editor-core/esm/vs/editor/common/languages';
+declare module '@difizen/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneLanguages';
+declare module '*.json';
+declare module 'vscode-oniguruma/release/onig.wasm';

package/src/index.spec.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import assert from 'assert';
+
+describe('libro-cofine-textmate', () => {
+  it('#import', () => {
+    assert(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+import { TextmateModule } from './monaco-module.js';
+
+export * from './monaco-module.js';
+export * from './monaco-textmate-service.js';
+export * from './textmate-contribution.js';
+export * from './textmate-registry.js';
+
+export default TextmateModule;

package/src/monaco-grammar-registry.ts

@@ -0,0 +1,88 @@
+import { inject, singleton } from '@difizen/mana-app';
+import type { IOnigLib, IRawGrammar, IRawTheme } from 'vscode-textmate';
+import { Registry, parseRawGrammar } from 'vscode-textmate';
+
+import { TextmateRegistry } from './textmate-registry.js';
+
+export const isBasicWasmSupported = typeof (window as any).WebAssembly !== 'undefined';
+export const OnigurumaPromise = Symbol('OnigasmPromise');
+export type OnigurumaPromise = Promise<IOnigLib>;
+
+@singleton()
+export class MonacoGrammarRegistry {
+  public registry?: Registry;
+  protected readonly textmateRegistry: TextmateRegistry;
+  protected readonly onigasmPromise: OnigurumaPromise;
+  constructor(
+    @inject(TextmateRegistry) textmateRegistry: TextmateRegistry,
+    @inject(OnigurumaPromise) onigasmPromise: OnigurumaPromise,
+  ) {
+    this.textmateRegistry = textmateRegistry;
+    this.onigasmPromise = onigasmPromise;
+  }
+
+  getRegistry(theme: IRawTheme): Registry {
+    return new Registry({
+      onigLib: this.onigasmPromise,
+      theme,
+      loadGrammar: async (scopeName: string) => {
+        const provider = this.textmateRegistry.getProvider(scopeName);
+        if (provider) {
+          const definition = await provider.getGrammarDefinition();
+          let rawGrammar: IRawGrammar;
+          if (typeof definition.content === 'string') {
+            rawGrammar = parseRawGrammar(
+              definition.content,
+              definition.format === 'json' ? 'grammar.json' : 'grammar.plist',
+            );
+          } else {
+            rawGrammar = definition.content as unknown as IRawGrammar;
+          }
+          return rawGrammar;
+        }
+        return undefined;
+      },
+      getInjections: (scopeName: string) => {
+        const provider = this.textmateRegistry.getProvider(scopeName);
+        if (provider && provider.getInjections) {
+          return provider.getInjections(scopeName);
+        }
+        return [];
+      },
+    });
+  }
+  setupRegistry(theme: IRawTheme): void {
+    if (this.registry) {
+      this.registry.setTheme(theme);
+      return;
+    }
+    this.registry = new Registry({
+      onigLib: this.onigasmPromise,
+      theme,
+      loadGrammar: async (scopeName: string) => {
+        const provider = this.textmateRegistry.getProvider(scopeName);
+        if (provider) {
+          const definition = await provider.getGrammarDefinition();
+          let rawGrammar: IRawGrammar;
+          if (typeof definition.content === 'string') {
+            rawGrammar = parseRawGrammar(
+              definition.content,
+              definition.format === 'json' ? 'grammar.json' : 'grammar.plist',
+            );
+          } else {
+            rawGrammar = definition.content as unknown as IRawGrammar;
+          }
+          return rawGrammar;
+        }
+        return undefined;
+      },
+      getInjections: (scopeName: string) => {
+        const provider = this.textmateRegistry.getProvider(scopeName);
+        if (provider && provider.getInjections) {
+          return provider.getInjections(scopeName);
+        }
+        return [];
+      },
+    });
+  }
+}

package/src/monaco-module.ts

@@ -0,0 +1,59 @@
+/* eslint-disable func-names */
+/* eslint-disable global-require */
+
+import { Module } from '@difizen/mana-app';
+import * as oniguruma from 'vscode-oniguruma';
+import * as onig from 'vscode-oniguruma/release/onig.wasm';
+
+import {
+  isBasicWasmSupported,
+  MonacoGrammarRegistry,
+  OnigurumaPromise,
+} from './monaco-grammar-registry.js';
+import { MonacoTextmateService } from './monaco-textmate-service.js';
+import { MonacoThemeRegistry } from './monaco-theme-registry.js';
+import { LanguageGrammarDefinitionContribution } from './textmate-contribution.js';
+import { TextmateRegistry } from './textmate-registry.js';
+import { TextmateThemeContribution } from './textmate-theme-contribution.js';
+
+export async function fetchOniguruma(): Promise<ArrayBuffer | Response> {
+  // const onigurumaPath = 'https://unpkg.com/vscode-oniguruma@2.0.1/release/onig.wasm'; // webpack doing its magic here
+  const onigurumaPath = onig;
+  let onigurumaUrl = onigurumaPath;
+  if (typeof onigurumaPath !== 'string' && onigurumaPath.default) {
+    onigurumaUrl = onigurumaPath.default;
+  }
+
+  const response = await fetch(onigurumaUrl);
+  const contentType = response.headers.get('content-type');
+  if (contentType === 'application/wasm') {
+    return response;
+  }
+
+  // Using the response directly only works if the server sets the MIME type 'application/wasm'.
+  // Otherwise, a TypeError is thrown when using the streaming compiler.
+  // We therefore use the non-streaming compiler :(.
+  return await response.arrayBuffer();
+}
+
+const vscodeOnigurumaLib = fetchOniguruma().then(async (buffer) => {
+  await oniguruma.loadWASM(buffer);
+  return oniguruma;
+});
+
+export const TextmateModule = Module()
+  .register(
+    {
+      token: OnigurumaPromise,
+      useValue: isBasicWasmSupported
+        ? vscodeOnigurumaLib
+        : Promise.reject(new Error('wasm not supported')),
+    },
+    MonacoTextmateService,
+    TextmateRegistry,
+    MonacoThemeRegistry,
+    TextmateThemeContribution,
+    MonacoGrammarRegistry,
+  )
+  .contribution(LanguageGrammarDefinitionContribution);
+export default TextmateModule;