@difizen/libro-cofine-textmate 0.1.2

package/es/monaco-theme-registry.js

@@ -0,0 +1,227 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _dec2, _class, _class2, _descriptor;
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+import { MixedThemeRegistry, InitializeContribution } from '@difizen/libro-cofine-editor-core';
+import { Emitter, inject, singleton } from '@difizen/mana-app';
+import * as monaco from '@difizen/monaco-editor-core';
+import { StandaloneServices } from '@difizen/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IStandaloneThemeService } from '@difizen/monaco-editor-core/esm/vs/editor/standalone/common/standaloneTheme';
+import { MonacoGrammarRegistry } from "./monaco-grammar-registry.js";
+export var MonacoThemeRegistry = (_dec = singleton({
+  contrib: [MixedThemeRegistry, InitializeContribution]
+}), _dec2 = inject(MonacoGrammarRegistry), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  function MonacoThemeRegistry() {
+    _classCallCheck(this, MonacoThemeRegistry);
+    _initializerDefineProperty(this, "grammarRegistry", _descriptor, this);
+    this.registedTheme = [];
+    this.themeChangedEmitter = new Emitter();
+    this.onThemeChanged = this.themeChangedEmitter.event;
+  }
+  _createClass(MonacoThemeRegistry, [{
+    key: "onInitialize",
+    value: function onInitialize() {
+      var _this = this;
+      var standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
+      standaloneThemeService.onDidColorThemeChange(function () {
+        _this.themeChangedEmitter.fire();
+      });
+    }
+  }, {
+    key: "getThemeData",
+    value: function getThemeData(name) {
+      var theme = this.doGetTheme(name);
+      return theme && theme.themeData;
+    }
+  }, {
+    key: "getTheme",
+    value: function getTheme(name) {
+      return this.doGetTheme(name);
+    }
+  }, {
+    key: "getMonacoThemeName",
+    value: function getMonacoThemeName() {
+      var standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
+      return standaloneThemeService.getColorTheme().themeName;
+    }
+  }, {
+    key: "doGetTheme",
+    value: function doGetTheme(name) {
+      var standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
+      var theme = !name ? standaloneThemeService.getTheme() : standaloneThemeService._knownThemes.get(name);
+      return theme;
+    }
+  }, {
+    key: "setTheme",
+    value: function setTheme(name, data) {
+      // monaco auto refreshes a theme with new data
+      monaco.editor.defineTheme(name, data);
+    }
+  }, {
+    key: "registerThemes",
+    value: function registerThemes(themeOptions, setTheme) {
+      var _this2 = this;
+      Object.keys(themeOptions).forEach(function (key) {
+        _this2.doRegisterThemes(themeOptions[key], themeOptions, setTheme);
+      });
+    }
+  }, {
+    key: "doRegisterThemes",
+    value: function doRegisterThemes(option, themeOptions, setTheme) {
+      var result = {
+        name: option.name,
+        base: option.base || 'vs',
+        inherit: true,
+        colors: {},
+        rules: [],
+        settings: []
+      };
+      if (typeof option.include !== 'undefined') {
+        var themeName = option.include.replaceAll('/', '').replaceAll('_', '-').replaceAll('.json', '');
+        var parentOption = themeOptions[themeName];
+        if (!parentOption || this.registedTheme.includes(parentOption.name)) {
+          console.error("Couldn't resolve includes theme ".concat(option.include, "."));
+        } else {
+          var _result$rules, _result$settings;
+          var parentTheme = this.doRegisterThemes(parentOption, themeOptions, setTheme);
+          Object.assign(result.colors, parentTheme.colors);
+          (_result$rules = result.rules).push.apply(_result$rules, _toConsumableArray(parentTheme.rules));
+          (_result$settings = result.settings).push.apply(_result$settings, _toConsumableArray(parentTheme.settings));
+        }
+      }
+      var tokenColors = option.tokenColors;
+      if (Array.isArray(tokenColors)) {
+        var _iterator = _createForOfIteratorHelper(tokenColors),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var tokenColor = _step.value;
+            if (tokenColor.scope && tokenColor.settings) {
+              result.settings.push({
+                scope: tokenColor.scope,
+                settings: {
+                  foreground: this.normalizeColor(tokenColor.settings.foreground),
+                  background: this.normalizeColor(tokenColor.settings.background),
+                  fontStyle: tokenColor.settings.fontStyle
+                }
+              });
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      if (option.colors) {
+        Object.assign(result.colors, option.colors);
+        result.encodedTokensColors = Object.keys(result.colors).map(function (key) {
+          return result.colors[key];
+        });
+      }
+      if (option.name && option.base) {
+        var _iterator2 = _createForOfIteratorHelper(result.settings),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var setting = _step2.value;
+            this.transform(setting, function (rule) {
+              return result.rules.push(rule);
+            });
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        var standaloneThemeService = StandaloneServices.get(IStandaloneThemeService);
+
+        // the default rule (scope empty) is always the first rule. Ignore all other default rules.
+        var defaultTheme = standaloneThemeService._knownThemes.get(result.base);
+        var foreground = result.colors['editor.foreground'] || defaultTheme.getColor('editor.foreground');
+        var background = result.colors['editor.background'] || defaultTheme.getColor('editor.background');
+        result.settings.unshift({
+          settings: {
+            foreground: this.normalizeColor(foreground),
+            background: this.normalizeColor(background)
+          }
+        });
+        var reg = this.grammarRegistry.getRegistry(result);
+        reg.setTheme(result);
+        result.encodedTokensColors = reg.getColorMap();
+        // index 0 has to be set to null as it is 'undefined' by default, but monaco code expects it to be null
+        if (result.encodedTokensColors) {
+          result.encodedTokensColors[0] = null;
+        }
+        setTheme(option.name, result);
+      }
+      return result;
+    }
+  }, {
+    key: "transform",
+    value: function transform(tokenColor, acceptor) {
+      if (typeof tokenColor.scope === 'undefined') {
+        tokenColor.scope = [''];
+      } else if (typeof tokenColor.scope === 'string') {
+        tokenColor.scope = tokenColor.scope.split(',').map(function (scope) {
+          return scope.trim();
+        });
+      }
+      var _iterator3 = _createForOfIteratorHelper(tokenColor.scope),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var scope = _step3.value;
+          acceptor(_objectSpread(_objectSpread({}, tokenColor.settings), {}, {
+            token: scope
+          }));
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }, {
+    key: "normalizeColor",
+    value: function normalizeColor(color) {
+      if (!color) {
+        return undefined;
+      }
+      var normalized = String(color).replace(/^#/, '').slice(0, 6);
+      if (normalized.length < 6 || !normalized.match(/^[0-9A-Fa-f]{6}$/)) {
+        // ignoring not normalized colors to avoid breaking token color indexes between monaco and vscode-textmate
+        console.error("Color '".concat(normalized, "' is NOT normalized, it must have 6 positions."));
+        return undefined;
+      }
+      return "#".concat(normalized);
+    }
+  }]);
+  return MonacoThemeRegistry;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "grammarRegistry", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class2)) || _class);
+(function (_MonacoThemeRegistry) {
+  var DARK_DEFAULT_THEME = _MonacoThemeRegistry.DARK_DEFAULT_THEME = 'e2-dark';
+  var LIGHT_DEFAULT_THEME = _MonacoThemeRegistry.LIGHT_DEFAULT_THEME = 'e2-light';
+  var HC_DEFAULT_THEME = _MonacoThemeRegistry.HC_DEFAULT_THEME = 'e2-hc';
+})(MonacoThemeRegistry || (MonacoThemeRegistry = {}));

package/es/monaco-theme-types.d.ts

@@ -0,0 +1,5 @@
+import type * as monaco from '@difizen/monaco-editor-core';
+export interface MonacoTheme extends monaco.editor.IStandaloneThemeData {
+    name: string;
+}
+//# sourceMappingURL=monaco-theme-types.d.ts.map

package/es/monaco-theme-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-theme-types.d.ts","sourceRoot":"","sources":["../src/monaco-theme-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,6BAA6B,CAAC;AAE3D,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,CAAC,oBAAoB;IACrE,IAAI,EAAE,MAAM,CAAC;CACd"}

package/es/monaco-theme-types.js

@@ -0,0 +1 @@
+export {};

package/es/textmate-contribution.d.ts

@@ -0,0 +1,9 @@
+import { Syringe } from '@difizen/mana-app';
+import type { TextmateRegistry } from './textmate-registry.js';
+export declare const LanguageGrammarDefinitionContribution: Syringe.DefinedToken;
+export interface LanguageGrammarDefinitionContribution {
+    registerTextmateLanguage: (registry: TextmateRegistry) => void;
+    _finishRegisterTextmateLanguage?: boolean;
+}
+export declare function getEncodedLanguageId(languageId: string): number;
+//# sourceMappingURL=textmate-contribution.d.ts.map

package/es/textmate-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textmate-contribution.d.ts","sourceRoot":"","sources":["../src/textmate-contribution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAG5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,eAAO,MAAM,qCAAqC,sBAEjD,CAAC;AACF,MAAM,WAAW,qCAAqC;IACpD,wBAAwB,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IAC/D,+BAA+B,CAAC,EAAE,OAAO,CAAC;CAC3C;AACD,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE/D"}

package/es/textmate-contribution.js

@@ -0,0 +1,6 @@
+import { Syringe } from '@difizen/mana-app';
+import * as monaco from '@difizen/monaco-editor-core';
+export var LanguageGrammarDefinitionContribution = Syringe.defineToken('LanguageGrammarDefinitionContribution');
+export function getEncodedLanguageId(languageId) {
+  return monaco.languages.getEncodedLanguageId(languageId);
+}

package/es/textmate-registry.d.ts

@@ -0,0 +1,32 @@
+import { Disposable } from '@difizen/mana-app';
+import type { IGrammarConfiguration } from 'vscode-textmate';
+import type { TokenizerOption } from './textmate-tokenizer.js';
+export interface TextmateGrammarConfiguration extends IGrammarConfiguration {
+    /**
+     * Optional options to further refine the tokenization of the grammar.
+     */
+    readonly tokenizerOption?: TokenizerOption;
+}
+export interface GrammarDefinitionProvider {
+    getGrammarDefinition: () => Promise<GrammarDefinition>;
+    getInjections?: (scopeName: string) => string[];
+}
+export interface GrammarDefinition {
+    format: 'json' | 'plist';
+    content: Record<string, unknown> | string;
+    location?: string;
+}
+export declare class TextmateRegistry {
+    protected readonly scopeToProvider: Map<string, GrammarDefinitionProvider[]>;
+    protected readonly languageToConfig: Map<string, TextmateGrammarConfiguration[]>;
+    protected readonly languageIdToScope: Map<string, string[]>;
+    get languages(): IterableIterator<string>;
+    registerTextmateGrammarScope(scope: string, provider: GrammarDefinitionProvider): Disposable;
+    getProvider(scope: string): GrammarDefinitionProvider | undefined;
+    mapLanguageIdToTextmateGrammar(languageId: string, scope: string): Disposable;
+    getScope(languageId: string): string | undefined;
+    getLanguageId(scope: string): string | undefined;
+    registerGrammarConfiguration(languageId: string, config: TextmateGrammarConfiguration): Disposable;
+    getGrammarConfiguration(languageId: string): TextmateGrammarConfiguration;
+}
+//# sourceMappingURL=textmate-registry.d.ts.map

package/es/textmate-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textmate-registry.d.ts","sourceRoot":"","sources":["../src/textmate-registry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,MAAM,WAAW,4BAA6B,SAAQ,qBAAqB;IACzE;;OAEG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC;CAC5C;AAED,MAAM,WAAW,yBAAyB;IACxC,oBAAoB,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACvD,aAAa,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;CACjD;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,qBACa,gBAAgB;IAC3B,SAAS,CAAC,QAAQ,CAAC,eAAe,2CAAkD;IACpF,SAAS,CAAC,QAAQ,CAAC,gBAAgB,8CAG/B;IACJ,SAAS,CAAC,QAAQ,CAAC,iBAAiB,wBAA+B;IAEnE,IAAI,SAAS,IAAI,gBAAgB,CAAC,MAAM,CAAC,CAExC;IAED,4BAA4B,CAC1B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,yBAAyB,GAClC,UAAU;IA4Bb,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,yBAAyB,GAAG,SAAS;IAKjE,8BAA8B,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU;IAkB7E,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAKhD,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAShD,4BAA4B,CAC1B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,4BAA4B,GACnC,UAAU;IAkBb,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,4BAA4B;CAI1E"}

package/es/textmate-registry.js

@@ -0,0 +1,130 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _class;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable no-console */
+/* eslint-disable no-restricted-syntax */
+
+import { Disposable } from '@difizen/mana-app';
+import { singleton } from '@difizen/mana-app';
+export var TextmateRegistry = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function TextmateRegistry() {
+    _classCallCheck(this, TextmateRegistry);
+    this.scopeToProvider = new Map();
+    this.languageToConfig = new Map();
+    this.languageIdToScope = new Map();
+  }
+  _createClass(TextmateRegistry, [{
+    key: "languages",
+    get: function get() {
+      return this.languageIdToScope.keys();
+    }
+  }, {
+    key: "registerTextmateGrammarScope",
+    value: function registerTextmateGrammarScope(scope, provider) {
+      var providers = this.scopeToProvider.get(scope) || [];
+      var existingProvider = providers[0];
+      if (existingProvider) {
+        Promise.all([existingProvider.getGrammarDefinition(), provider.getGrammarDefinition()]).then(function (_ref) {
+          var _ref2 = _slicedToArray(_ref, 2),
+            a = _ref2[0],
+            b = _ref2[1];
+          if (a.location !== b.location || !a.location && !b.location) {
+            console.warn("a registered grammar provider for '".concat(scope, "' scope is overridden"));
+          }
+          return;
+        }).catch(console.error);
+      }
+      providers.unshift(provider);
+      this.scopeToProvider.set(scope, providers);
+      return Disposable.create(function () {
+        var index = providers.indexOf(provider);
+        if (index !== -1) {
+          providers.splice(index, 1);
+        }
+      });
+    }
+  }, {
+    key: "getProvider",
+    value: function getProvider(scope) {
+      var providers = this.scopeToProvider.get(scope);
+      return providers && providers[0];
+    }
+  }, {
+    key: "mapLanguageIdToTextmateGrammar",
+    value: function mapLanguageIdToTextmateGrammar(languageId, scope) {
+      var scopes = this.languageIdToScope.get(languageId) || [];
+      var existingScope = scopes[0];
+      if (typeof existingScope === 'string') {
+        console.warn("'".concat(languageId, "' language is remapped from '").concat(existingScope, "' to '").concat(scope, "' scope"));
+      }
+      scopes.unshift(scope);
+      this.languageIdToScope.set(languageId, scopes);
+      return Disposable.create(function () {
+        var index = scopes.indexOf(scope);
+        if (index !== -1) {
+          scopes.splice(index, 1);
+        }
+      });
+    }
+  }, {
+    key: "getScope",
+    value: function getScope(languageId) {
+      var scopes = this.languageIdToScope.get(languageId);
+      return scopes && scopes[0];
+    }
+  }, {
+    key: "getLanguageId",
+    value: function getLanguageId(scope) {
+      var _iterator = _createForOfIteratorHelper(this.languageIdToScope.keys()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var languageId = _step.value;
+          if (this.getScope(languageId) === scope) {
+            return languageId;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return undefined;
+    }
+  }, {
+    key: "registerGrammarConfiguration",
+    value: function registerGrammarConfiguration(languageId, config) {
+      var configs = this.languageToConfig.get(languageId) || [];
+      var existingConfig = configs[0];
+      if (existingConfig) {
+        console.warn("a registered grammar configuration for '".concat(languageId, "' language is overridden"));
+      }
+      configs.unshift(config);
+      this.languageToConfig.set(languageId, configs);
+      return Disposable.create(function () {
+        var index = configs.indexOf(config);
+        if (index !== -1) {
+          configs.splice(index, 1);
+        }
+      });
+    }
+  }, {
+    key: "getGrammarConfiguration",
+    value: function getGrammarConfiguration(languageId) {
+      var configs = this.languageToConfig.get(languageId);
+      return configs && configs[0] || {};
+    }
+  }]);
+  return TextmateRegistry;
+}()) || _class);

package/es/textmate-theme-contribution.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeRegistry } from '@difizen/libro-cofine-editor-core';
+import { ThemeContribution } from '@difizen/libro-cofine-editor-core';
+export declare class TextmateThemeContribution implements ThemeContribution {
+    registerItem(registry: ThemeRegistry): void;
+}
+//# sourceMappingURL=textmate-theme-contribution.d.ts.map

package/es/textmate-theme-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textmate-theme-contribution.d.ts","sourceRoot":"","sources":["../src/textmate-theme-contribution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAetE,qBACa,yBAA0B,YAAW,iBAAiB;IACjE,YAAY,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;CAmB5C"}

package/es/textmate-theme-contribution.js

@@ -0,0 +1,50 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _class;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable global-require */
+
+import { ThemeContribution } from '@difizen/libro-cofine-editor-core';
+import { singleton } from '@difizen/mana-app';
+import darkDefaults from "./data/monaco-themes/vscode/dark_defaults.json";
+import darkEditor from "./data/monaco-themes/vscode/dark_editor.json";
+import darkPlus from "./data/monaco-themes/vscode/dark_plus.json";
+import darkVS from "./data/monaco-themes/vscode/dark_vs.json";
+import HCBlack from "./data/monaco-themes/vscode/hc_black.json";
+import HCBlackDefault from "./data/monaco-themes/vscode/hc_black_defaults.json";
+import HCEditor from "./data/monaco-themes/vscode/hc_editor.json";
+import lightDefaults from "./data/monaco-themes/vscode/light_defaults.json";
+import lightEditor from "./data/monaco-themes/vscode/light_editor.json";
+import lightPlus from "./data/monaco-themes/vscode/light_plus.json";
+import lightVS from "./data/monaco-themes/vscode/light_vs.json";
+export var TextmateThemeContribution = (_dec = singleton({
+  contrib: ThemeContribution
+}), _dec(_class = /*#__PURE__*/function () {
+  function TextmateThemeContribution() {
+    _classCallCheck(this, TextmateThemeContribution);
+  }
+  _createClass(TextmateThemeContribution, [{
+    key: "registerItem",
+    value: function registerItem(registry) {
+      if (!registry.mixedThemeEnable) {
+        console.warn('cannot register textmate themes');
+        return;
+      }
+      registry.registerMixedTheme(darkDefaults, 'dark-defaults', 'vs-dark');
+      registry.registerMixedTheme(darkVS, 'dark-vs', 'vs-dark');
+      registry.registerMixedTheme(darkPlus, 'dark-plus', 'vs-dark');
+      registry.registerMixedTheme(darkEditor, 'e2-dark', 'vs-dark');
+      registry.registerMixedTheme(lightDefaults, 'light-defaults', 'vs');
+      registry.registerMixedTheme(lightVS, 'light-vs', 'vs');
+      registry.registerMixedTheme(lightPlus, 'light-plus', 'vs');
+      registry.registerMixedTheme(lightEditor, 'e2-light', 'vs');
+      registry.registerMixedTheme(HCBlackDefault, 'hc-black-defaults', 'hc-black');
+      registry.registerMixedTheme(HCBlack, 'hc-black', 'hc-black');
+      registry.registerMixedTheme(HCEditor, 'e2-hc', 'hc-black');
+    }
+  }]);
+  return TextmateThemeContribution;
+}()) || _class);

package/es/textmate-tokenizer.d.ts

@@ -0,0 +1,25 @@
+import type monaco from '@difizen/monaco-editor-core';
+import type { IGrammar } from 'vscode-textmate';
+/**
+ * Options for the TextMate tokenizer.
+ */
+export interface TokenizerOption {
+    /**
+     * Maximum line length that will be handled by the TextMate tokenizer. If the length of the actual line exceeds this
+     * limit, the tokenizer terminates and the tokenization of any subsequent lines might be broken.
+     *
+     * If the `lineLimit` is not defined, it means, there are no line length limits. Otherwise, it must be a positive
+     * integer or an error will be thrown.
+     */
+    lineLimit?: number;
+}
+export declare namespace TokenizerOption {
+    /**
+     * The default TextMate tokenizer option.
+     *
+     * @deprecated Use the current value of `editor.maxTokenizationLineLength` preference instead.
+     */
+    const DEFAULT: TokenizerOption;
+}
+export declare function createTextmateTokenizer(grammar: IGrammar, options: TokenizerOption): monaco.languages.EncodedTokensProvider;
+//# sourceMappingURL=textmate-tokenizer.d.ts.map

package/es/textmate-tokenizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textmate-tokenizer.d.ts","sourceRoot":"","sources":["../src/textmate-tokenizer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAc,MAAM,iBAAiB,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,yBAAiB,eAAe,CAAC;IAC/B;;;;OAIG;IACI,MAAM,OAAO,EAAE,eAErB,CAAC;CACH;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,eAAe,GACvB,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAoBxC"}

package/es/textmate-tokenizer.js

@@ -0,0 +1,32 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { INITIAL } from 'vscode-textmate';
+
+/**
+ * Options for the TextMate tokenizer.
+ */
+export var TokenizerOption;
+(function (_TokenizerOption) {
+  var DEFAULT = _TokenizerOption.DEFAULT = {
+    lineLimit: 400
+  };
+})(TokenizerOption || (TokenizerOption = {}));
+export function createTextmateTokenizer(grammar, options) {
+  if (options.lineLimit !== undefined && (options.lineLimit <= 0 || !Number.isInteger(options.lineLimit))) {
+    throw new Error("The 'lineLimit' must be a positive integer. It was ".concat(options.lineLimit, "."));
+  }
+  return {
+    getInitialState: function getInitialState() {
+      return INITIAL;
+    },
+    tokenizeEncoded: function tokenizeEncoded(line, state) {
+      var tokenizeLineResult2 = grammar.tokenizeLine2(line, state);
+      var tokens = tokenizeLineResult2.tokens,
+        endState = tokenizeLineResult2.ruleStack;
+      return {
+        tokens: tokens,
+        endState: endState
+      };
+    }
+  };
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@difizen/libro-cofine-textmate",
+  "version": "0.1.2",
+  "description": "",
+  "keywords": [
+    "libro",
+    "notebook",
+    "monaco"
+  ],
+  "repository": "git@github.com:difizen/libro.git",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "typings": "./es/index.d.ts",
+      "default": "./es/index.js"
+    },
+    "./mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./es/mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "es/index.js",
+  "module": "es/index.js",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es",
+    "src"
+  ],
+  "dependencies": {
+    "@difizen/libro-cofine-editor-core": "^0.1.2",
+    "@difizen/mana-app": "latest",
+    "fast-plist": "^0.1.2",
+    "vscode-oniguruma": "^1.5.1",
+    "vscode-textmate": "^9.0.0"
+  },
+  "devDependencies": {
+    "@difizen/monaco-editor-core": "latest",
+    "@types/debug": "^4.1.6"
+  },
+  "scripts": {
+    "setup": "father build",
+    "build": "father build",
+    "test": ": Note: lint task is delegated to test:* scripts",
+    "test:vitest": "vitest run",
+    "test:jest": "jest",
+    "coverage": ": Note: lint task is delegated to coverage:* scripts",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:jest": "jest --coverage",
+    "lint": ": Note: lint task is delegated to lint:* scripts",
+    "lint:eslint": "eslint src",
+    "lint:tsc": "tsc --noEmit"
+  }
+}

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

@@ -0,0 +1,23 @@
+{
+  "$schema": "vscode://schemas/color-theme",
+  "name": "Dark Default Colors",
+  "colors": {
+    "editor.background": "#1E1E1E",
+    "editor.foreground": "#D4D4D4",
+    "editor.inactiveSelectionBackground": "#3A3D41",
+    "editorIndentGuide.background": "#404040",
+    "editorIndentGuide.activeBackground": "#707070",
+    "editor.selectionHighlightBackground": "#ADD6FF26",
+    "list.dropBackground": "#383B3D",
+    "activityBarBadge.background": "#007ACC",
+    "sideBarTitle.foreground": "#BBBBBB",
+    "input.placeholderForeground": "#A6A6A6",
+    "settings.textInputBackground": "#292929",
+    "settings.numberInputBackground": "#292929",
+    "menu.background": "#252526",
+    "menu.foreground": "#CCCCCC",
+    "statusBarItem.remoteForeground": "#FFF",
+    "statusBarItem.remoteBackground": "#16825D"
+  },
+  "tokenColors": []
+}