@difizen/libro-language-client 0.1.18

package/es/common/vscodeAdaptor/services.js

@@ -0,0 +1,3 @@
+export var ILibroWorkspace = Symbol('ILibroWorkspace');
+export var ILibroWindow = Symbol('ILibroWindow');
+export var IMonacoLanguages = Symbol('IMonacoLanguages');

package/es/common/vscodeAdaptor/typings.d.ts

@@ -0,0 +1,10 @@
+declare module '@difizen/monaco-editor-core/esm/vs/editor/common/languageSelector.js' {
+  function score(
+    selector: LanguageSelector | undefined,
+    candidateUri: URI,
+    candidateLanguage: string,
+    candidateIsSynchronized: boolean,
+    candidateNotebookUri: URI | undefined,
+    candidateNotebookType: string | undefined,
+  ): number;
+}

package/es/common/vscodeAdaptor/util.d.ts

@@ -0,0 +1,3 @@
+export declare const unsupported: () => never;
+export declare const noop: () => void;
+//# sourceMappingURL=util.d.ts.map

package/es/common/vscodeAdaptor/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/common/vscodeAdaptor/util.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,aAEvB,CAAC;AAEF,eAAO,MAAM,IAAI,YAEhB,CAAC"}

package/es/common/vscodeAdaptor/util.js

@@ -0,0 +1,6 @@
+export var unsupported = function unsupported() {
+  throw new Error('unsupported');
+};
+export var noop = function noop() {
+  // no-op
+};

package/es/common/vscodeAdaptor/vscodeAdaptor.d.ts

@@ -0,0 +1,77 @@
+import type { Syringe } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-common';
+import * as monaco from '@difizen/monaco-editor-core';
+import type { Disposable } from 'vscode';
+import { URI } from 'vscode-uri';
+import { ILibroWindow, ILibroWorkspace, IMonacoLanguages } from './services.js';
+export declare const CompletionItemTag: typeof monaco.languages.CompletionItemTag;
+export type CompletionItemTag = monaco.languages.CompletionItemTag;
+export declare const SignatureHelpTriggerKind: typeof monaco.languages.SignatureHelpTriggerKind;
+export type SignatureHelpTriggerKind = monaco.languages.SignatureHelpTriggerKind;
+export declare const CompletionTriggerKind: typeof monaco.languages.CompletionTriggerKind;
+export type CompletionTriggerKind = monaco.languages.CompletionTriggerKind;
+export declare const lspEnv: {
+    libroContainer: Syringe.Container;
+};
+export declare let workspace: ILibroWorkspace;
+export declare let window: ILibroWindow;
+export declare let languages: IMonacoLanguages;
+export declare const setupLspEnv: (container: Syringe.Container) => void;
+export declare const initLspEnv: () => void;
+export declare class Uri extends URI {
+}
+export declare const version = "1.85.1";
+declare class VscodeEnv {
+    language: string;
+    appName: string;
+    openExternal(target: Uri): Thenable<boolean>;
+}
+export declare const env: VscodeEnv;
+export declare class CancellationTokenSource extends monaco.CancellationTokenSource {
+}
+export declare class CancellationError extends Error {
+    constructor();
+}
+declare class Commands {
+    registerCommand(command: string, callback: (...args: any[]) => any, thisArg?: any): Disposable;
+}
+export declare const commands: Commands;
+export { Emitter as EventEmitter };
+export declare class TabInputText {
+    readonly uri: Uri;
+    constructor(uri: Uri);
+}
+export declare class TabInputTextDiff {
+    readonly original: Uri;
+    readonly modified: Uri;
+    constructor(original: Uri, modified: Uri);
+}
+export declare class TabInputCustom {
+    readonly uri: Uri;
+    readonly viewType: string;
+    constructor(uri: Uri, viewType: string);
+}
+export declare enum FileType {
+    /**
+     * File is unknown (neither file, directory nor symbolic link).
+     */
+    Unknown = 0,
+    /**
+     * File is a normal file.
+     */
+    File = 1,
+    /**
+     * File is a directory.
+     */
+    Directory = 2,
+    /**
+     * File is a symbolic link.
+     *
+     * Note: even when the file is a symbolic link, you can test for
+     * `FileType.File` and `FileType.Directory` to know the type of
+     * the target the link points to.
+     */
+    SymbolicLink = 64
+}
+export * from './extHostTypes.js';
+//# sourceMappingURL=vscodeAdaptor.d.ts.map

package/es/common/vscodeAdaptor/vscodeAdaptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vscodeAdaptor.d.ts","sourceRoot":"","sources":["../../../src/common/vscodeAdaptor/vscodeAdaptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAC/C,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEhF,eAAO,MAAM,iBAAiB,2CAAqC,CAAC;AACpE,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC;AACnE,eAAO,MAAM,wBAAwB,kDAA4C,CAAC;AAClF,MAAM,MAAM,wBAAwB,GAAG,MAAM,CAAC,SAAS,CAAC,wBAAwB,CAAC;AACjF,eAAO,MAAM,qBAAqB,+CAAyC,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC;AAE3E,eAAO,MAAM,MAAM,EAAE;IACnB,cAAc,EAAE,OAAO,CAAC,SAAS,CAAC;CAGnC,CAAC;AAEF,eAAO,IAAI,SAAS,EAAE,eAAkC,CAAC;AACzD,eAAO,IAAI,MAAM,EAAE,YAA+B,CAAC;AACnD,eAAO,IAAI,SAAS,EAAE,gBAAmC,CAAC;AAE1D,eAAO,MAAM,WAAW,cAAe,QAAQ,SAAS,SAEvD,CAAC;AAEF,eAAO,MAAM,UAAU,YAItB,CAAC;AAEF,qBAAa,GAAI,SAAQ,GAAG;CAAG;AAE/B,eAAO,MAAM,OAAO,WAAW,CAAC;AAEhC,cAAM,SAAS;IACb,QAAQ,SAAY;IACpB,OAAO,SAAW;IAClB,YAAY,CAAC,MAAM,EAAE,GAAG,GAAG,QAAQ,CAAC,OAAO,CAAC;CAG7C;AAED,eAAO,MAAM,GAAG,WAAkB,CAAC;AAEnC,qBAAa,uBAAwB,SAAQ,MAAM,CAAC,uBAAuB;CAAG;AAG9E,qBAAa,iBAAkB,SAAQ,KAAK;;CAK3C;AAED,cAAM,QAAQ;IACZ,eAAe,CACb,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACjC,OAAO,CAAC,EAAE,GAAG,GACZ,UAAU;CAOd;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,CAAC;AAEnC,qBAAa,YAAY;IACX,QAAQ,CAAC,GAAG,EAAE,GAAG;gBAAR,GAAG,EAAE,GAAG;CAC9B;AAED,qBAAa,gBAAgB;IAEzB,QAAQ,CAAC,QAAQ,EAAE,GAAG;IACtB,QAAQ,CAAC,QAAQ,EAAE,GAAG;gBADb,QAAQ,EAAE,GAAG,EACb,QAAQ,EAAE,GAAG;CAEzB;AAED,qBAAa,cAAc;IAEvB,QAAQ,CAAC,GAAG,EAAE,GAAG;IACjB,QAAQ,CAAC,QAAQ,EAAE,MAAM;gBADhB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM;CAE5B;AAED,oBAAY,QAAQ;IAClB;;OAEG;IACH,OAAO,IAAI;IAEX;;OAEG;IACH,IAAI,IAAI;IAER;;OAEG;IACH,SAAS,IAAI;IAEb;;;;;;OAMG;IACH,YAAY,KAAK;CAClB;AAED,cAAc,mBAAmB,CAAC"}

package/es/common/vscodeAdaptor/vscodeAdaptor.js

@@ -0,0 +1,124 @@
+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); }
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct.bind(); } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import { Emitter } from '@difizen/mana-common';
+import * as monaco from '@difizen/monaco-editor-core';
+import { URI } from 'vscode-uri';
+import { ILibroWindow, ILibroWorkspace, IMonacoLanguages } from "./services.js";
+export var CompletionItemTag = monaco.languages.CompletionItemTag;
+export var SignatureHelpTriggerKind = monaco.languages.SignatureHelpTriggerKind;
+export var CompletionTriggerKind = monaco.languages.CompletionTriggerKind;
+export var lspEnv = {
+  libroContainer: {}
+};
+export var workspace = undefined;
+export var window = undefined;
+export var languages = undefined;
+export var setupLspEnv = function setupLspEnv(container) {
+  lspEnv.libroContainer = container;
+};
+export var initLspEnv = function initLspEnv() {
+  workspace = lspEnv.libroContainer.get(ILibroWorkspace);
+  window = lspEnv.libroContainer.get(ILibroWindow);
+  languages = lspEnv.libroContainer.get(IMonacoLanguages);
+};
+export var Uri = /*#__PURE__*/function (_URI) {
+  _inherits(Uri, _URI);
+  var _super = _createSuper(Uri);
+  function Uri() {
+    _classCallCheck(this, Uri);
+    return _super.apply(this, arguments);
+  }
+  return _createClass(Uri);
+}(URI);
+export var version = '1.85.1';
+var VscodeEnv = /*#__PURE__*/function () {
+  function VscodeEnv() {
+    _classCallCheck(this, VscodeEnv);
+    this.language = 'python';
+    this.appName = 'libro';
+  }
+  _createClass(VscodeEnv, [{
+    key: "openExternal",
+    value: function openExternal(target) {
+      return Promise.resolve(true);
+    }
+  }]);
+  return VscodeEnv;
+}();
+export var env = new VscodeEnv();
+export var CancellationTokenSource = /*#__PURE__*/function (_monaco$CancellationT) {
+  _inherits(CancellationTokenSource, _monaco$CancellationT);
+  var _super2 = _createSuper(CancellationTokenSource);
+  function CancellationTokenSource() {
+    _classCallCheck(this, CancellationTokenSource);
+    return _super2.apply(this, arguments);
+  }
+  return _createClass(CancellationTokenSource);
+}(monaco.CancellationTokenSource);
+var canceledName = 'Canceled';
+export var CancellationError = /*#__PURE__*/function (_Error) {
+  _inherits(CancellationError, _Error);
+  var _super3 = _createSuper(CancellationError);
+  function CancellationError() {
+    var _this;
+    _classCallCheck(this, CancellationError);
+    _this = _super3.call(this, canceledName);
+    _this.name = _this.message;
+    return _this;
+  }
+  return _createClass(CancellationError);
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var Commands = /*#__PURE__*/function () {
+  function Commands() {
+    _classCallCheck(this, Commands);
+  }
+  _createClass(Commands, [{
+    key: "registerCommand",
+    value: function registerCommand(command, callback, thisArg) {
+      return {
+        dispose: function dispose() {
+          return;
+        }
+      };
+    }
+  }]);
+  return Commands;
+}();
+export var commands = new Commands();
+export { Emitter as EventEmitter };
+export var TabInputText = /*#__PURE__*/_createClass(function TabInputText(uri) {
+  _classCallCheck(this, TabInputText);
+  this.uri = uri;
+});
+export var TabInputTextDiff = /*#__PURE__*/_createClass(function TabInputTextDiff(original, modified) {
+  _classCallCheck(this, TabInputTextDiff);
+  this.original = original;
+  this.modified = modified;
+});
+export var TabInputCustom = /*#__PURE__*/_createClass(function TabInputCustom(uri, viewType) {
+  _classCallCheck(this, TabInputCustom);
+  this.uri = uri;
+  this.viewType = viewType;
+});
+export var FileType = /*#__PURE__*/function (FileType) {
+  FileType[FileType["Unknown"] = 0] = "Unknown";
+  FileType[FileType["File"] = 1] = "File";
+  FileType[FileType["Directory"] = 2] = "Directory";
+  FileType[FileType["SymbolicLink"] = 64] = "SymbolicLink";
+  return FileType;
+}({});
+export * from "./extHostTypes.js";

package/es/common/workspaceFolder.d.ts

@@ -0,0 +1,32 @@
+import type { ClientCapabilities, InitializeParams, ServerCapabilities, RegistrationType } from '@difizen/vscode-languageserver-protocol';
+import { WorkspaceFoldersRequest } from '@difizen/vscode-languageserver-protocol';
+import type { WorkspaceFolder as VWorkspaceFolder, WorkspaceFoldersChangeEvent as VWorkspaceFoldersChangeEvent } from 'vscode';
+import type { DynamicFeature, RegistrationData, FeatureClient, NextSignature, FeatureState } from './features.js';
+export declare function arrayDiff<T>(left: ReadonlyArray<T>, right: ReadonlyArray<T>): T[];
+export type WorkspaceFolderMiddleware = {
+    workspaceFolders?: WorkspaceFoldersRequest.MiddlewareSignature;
+    didChangeWorkspaceFolders?: NextSignature<VWorkspaceFoldersChangeEvent, Promise<void>>;
+};
+type WorkspaceFolderWorkspaceMiddleware = {
+    workspace?: WorkspaceFolderMiddleware;
+};
+export declare class WorkspaceFoldersFeature implements DynamicFeature<void> {
+    private readonly _client;
+    private readonly _listeners;
+    private _initialFolders;
+    constructor(client: FeatureClient<WorkspaceFolderWorkspaceMiddleware>);
+    getState(): FeatureState;
+    get registrationType(): RegistrationType<void>;
+    fillInitializeParams(params: InitializeParams): void;
+    protected initializeWithFolders(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities): void;
+    protected sendInitialEvent(currentWorkspaceFolders: ReadonlyArray<VWorkspaceFolder> | undefined): void;
+    private doSendEvent;
+    register(data: RegistrationData<undefined>): void;
+    unregister(id: string): void;
+    clear(): void;
+    private asProtocol;
+}
+export {};
+//# sourceMappingURL=workspaceFolder.d.ts.map

package/es/common/workspaceFolder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaceFolder.d.ts","sourceRoot":"","sources":["../../src/common/workspaceFolder.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kBAAkB,EAClB,gBAAgB,EAEhB,kBAAkB,EAGlB,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EACL,uBAAuB,EAExB,MAAM,yCAAyC,CAAC;AACjD,OAAO,KAAK,EAEV,eAAe,IAAI,gBAAgB,EACnC,2BAA2B,IAAI,4BAA4B,EAC5D,MAAM,QAAQ,CAAC;AAEhB,OAAO,KAAK,EACV,cAAc,EACd,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,YAAY,EACb,MAAM,eAAe,CAAC;AAWvB,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAEjF;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,gBAAgB,CAAC,EAAE,uBAAuB,CAAC,mBAAmB,CAAC;IAC/D,yBAAyB,CAAC,EAAE,aAAa,CACvC,4BAA4B,EAC5B,OAAO,CAAC,IAAI,CAAC,CACd,CAAC;CACH,CAAC;AAEF,KAAK,kCAAkC,GAAG;IACxC,SAAS,CAAC,EAAE,yBAAyB,CAAC;CACvC,CAAC;AAEF,qBAAa,uBAAwB,YAAW,cAAc,CAAC,IAAI,CAAC;IAClE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoD;IAC5E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA0B;IACrD,OAAO,CAAC,eAAe,CAA8C;gBAEzD,MAAM,EAAE,aAAa,CAAC,kCAAkC,CAAC;IAKrE,QAAQ,IAAI,YAAY;IAQxB,IAAW,gBAAgB,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAEpD;IAEM,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAW3D,SAAS,CAAC,qBAAqB,CAC7B,uBAAuB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,SAAS;IAK/D,sBAAsB,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI;IAK9D,UAAU,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI;IAiCzD,SAAS,CAAC,gBAAgB,CACxB,uBAAuB,EAAE,aAAa,CAAC,gBAAgB,CAAC,GAAG,SAAS;IA8BtE,OAAO,CAAC,WAAW;IAgBZ,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,SAAS,CAAC,GAAG,IAAI;IAyBjD,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAS5B,KAAK,IAAI,IAAI;IAOpB,OAAO,CAAC,UAAU;CAanB"}

package/es/common/workspaceFolder.js

@@ -0,0 +1,204 @@
+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); }
+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 _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 _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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { WorkspaceFoldersRequest, DidChangeWorkspaceFoldersNotification } from '@difizen/vscode-languageserver-protocol';
+import * as UUID from "./utils/uuid.js";
+import { workspace } from "./vscodeAdaptor/vscodeAdaptor.js";
+function access(target, key) {
+  if (target === undefined || target === null) {
+    return undefined;
+  }
+  return target[key];
+}
+export function arrayDiff(left, right) {
+  return left.filter(function (element) {
+    return right.indexOf(element) < 0;
+  });
+}
+export var WorkspaceFoldersFeature = /*#__PURE__*/function () {
+  function WorkspaceFoldersFeature(client) {
+    _classCallCheck(this, WorkspaceFoldersFeature);
+    this._client = client;
+    this._listeners = new Map();
+  }
+  _createClass(WorkspaceFoldersFeature, [{
+    key: "getState",
+    value: function getState() {
+      return {
+        kind: 'workspace',
+        id: this.registrationType.method,
+        registrations: this._listeners.size > 0
+      };
+    }
+  }, {
+    key: "registrationType",
+    get: function get() {
+      return DidChangeWorkspaceFoldersNotification.type;
+    }
+  }, {
+    key: "fillInitializeParams",
+    value: function fillInitializeParams(params) {
+      var _this = this;
+      var folders = workspace.workspaceFolders;
+      this.initializeWithFolders(folders);
+      if (folders === void 0) {
+        params.workspaceFolders = null;
+      } else {
+        params.workspaceFolders = folders.map(function (folder) {
+          return _this.asProtocol(folder);
+        });
+      }
+    }
+  }, {
+    key: "initializeWithFolders",
+    value: function initializeWithFolders(currentWorkspaceFolders) {
+      this._initialFolders = currentWorkspaceFolders;
+    }
+  }, {
+    key: "fillClientCapabilities",
+    value: function fillClientCapabilities(capabilities) {
+      capabilities.workspace = capabilities.workspace || {};
+      capabilities.workspace.workspaceFolders = true;
+    }
+  }, {
+    key: "initialize",
+    value: function initialize(capabilities) {
+      var _this2 = this;
+      var client = this._client;
+      client.onRequest(WorkspaceFoldersRequest.type, function (token) {
+        var workspaceFolders = function workspaceFolders() {
+          var folders = workspace.workspaceFolders;
+          if (folders === undefined) {
+            return null;
+          }
+          var result = folders.map(function (folder) {
+            return _this2.asProtocol(folder);
+          });
+          return result;
+        };
+        var middleware = client.middleware.workspace;
+        return middleware && middleware.workspaceFolders ? middleware.workspaceFolders(token, workspaceFolders) : workspaceFolders(token);
+      });
+      var value = access(access(access(capabilities, 'workspace'), 'workspaceFolders'), 'changeNotifications');
+      var id;
+      if (typeof value === 'string') {
+        id = value;
+      } else if (value === true) {
+        id = UUID.generateUuid();
+      }
+      if (id) {
+        this.register({
+          id: id,
+          registerOptions: undefined
+        });
+      }
+    }
+  }, {
+    key: "sendInitialEvent",
+    value: function sendInitialEvent(currentWorkspaceFolders) {
+      var _this3 = this;
+      var promise;
+      if (this._initialFolders && currentWorkspaceFolders) {
+        var removed = arrayDiff(this._initialFolders, currentWorkspaceFolders);
+        var added = arrayDiff(currentWorkspaceFolders, this._initialFolders);
+        if (added.length > 0 || removed.length > 0) {
+          promise = this.doSendEvent(added, removed);
+        }
+      } else if (this._initialFolders) {
+        promise = this.doSendEvent([], this._initialFolders);
+      } else if (currentWorkspaceFolders) {
+        promise = this.doSendEvent(currentWorkspaceFolders, []);
+      }
+      if (promise !== undefined) {
+        promise.catch(function (error) {
+          _this3._client.error("Sending notification ".concat(DidChangeWorkspaceFoldersNotification.type.method, " failed"), error);
+        });
+      }
+    }
+  }, {
+    key: "doSendEvent",
+    value: function doSendEvent(addedFolders, removedFolders) {
+      var _this4 = this;
+      var params = {
+        event: {
+          added: addedFolders.map(function (folder) {
+            return _this4.asProtocol(folder);
+          }),
+          removed: removedFolders.map(function (folder) {
+            return _this4.asProtocol(folder);
+          })
+        }
+      };
+      return this._client.sendNotification(DidChangeWorkspaceFoldersNotification.type, params);
+    }
+  }, {
+    key: "register",
+    value: function register(data) {
+      var _this5 = this;
+      var id = data.id;
+      var client = this._client;
+      var disposable = workspace.onDidChangeWorkspaceFolders(function (event) {
+        var didChangeWorkspaceFolders = function didChangeWorkspaceFolders(event) {
+          return _this5.doSendEvent(event.added, event.removed);
+        };
+        var middleware = client.middleware.workspace;
+        var promise = middleware && middleware.didChangeWorkspaceFolders ? middleware.didChangeWorkspaceFolders(event, didChangeWorkspaceFolders) : didChangeWorkspaceFolders(event);
+        promise.catch(function (error) {
+          _this5._client.error("Sending notification ".concat(DidChangeWorkspaceFoldersNotification.type.method, " failed"), error);
+        });
+      });
+      this._listeners.set(id, disposable);
+      this.sendInitialEvent(workspace.workspaceFolders);
+    }
+  }, {
+    key: "unregister",
+    value: function unregister(id) {
+      var disposable = this._listeners.get(id);
+      if (disposable === void 0) {
+        return;
+      }
+      this._listeners.delete(id);
+      disposable.dispose();
+    }
+  }, {
+    key: "clear",
+    value: function clear() {
+      var _iterator = _createForOfIteratorHelper(this._listeners.values()),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var disposable = _step.value;
+          disposable.dispose();
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      this._listeners.clear();
+    }
+  }, {
+    key: "asProtocol",
+    value: function asProtocol(workspaceFolder) {
+      if (workspaceFolder === void 0) {
+        return null;
+      }
+      return {
+        uri: this._client.code2ProtocolConverter.asUri(workspaceFolder.uri),
+        name: workspaceFolder.name
+      };
+    }
+  }]);
+  return WorkspaceFoldersFeature;
+}();

package/es/common/workspaceSymbol.d.ts

@@ -0,0 +1,21 @@
+import type { ClientCapabilities, ServerCapabilities, WorkspaceSymbolRegistrationOptions } from '@difizen/vscode-languageserver-protocol';
+import type { Disposable, CancellationToken, ProviderResult, SymbolInformation as VSymbolInformation, WorkspaceSymbolProvider } from 'vscode';
+import type { FeatureClient } from './features.js';
+import { WorkspaceFeature } from './features.js';
+export interface ProvideWorkspaceSymbolsSignature {
+    (this: void, query: string, token: CancellationToken): ProviderResult<VSymbolInformation[]>;
+}
+export interface ResolveWorkspaceSymbolSignature {
+    (this: void, item: VSymbolInformation, token: CancellationToken): ProviderResult<VSymbolInformation>;
+}
+export interface WorkspaceSymbolMiddleware {
+    provideWorkspaceSymbols?: (this: void, query: string, token: CancellationToken, next: ProvideWorkspaceSymbolsSignature) => ProviderResult<VSymbolInformation[]>;
+    resolveWorkspaceSymbol?: (this: void, item: VSymbolInformation, token: CancellationToken, next: ResolveWorkspaceSymbolSignature) => ProviderResult<VSymbolInformation>;
+}
+export declare class WorkspaceSymbolFeature extends WorkspaceFeature<WorkspaceSymbolRegistrationOptions, WorkspaceSymbolProvider, WorkspaceSymbolMiddleware> {
+    constructor(client: FeatureClient<WorkspaceSymbolMiddleware>);
+    fillClientCapabilities(capabilities: ClientCapabilities): void;
+    initialize(capabilities: ServerCapabilities): void;
+    protected registerLanguageProvider(options: WorkspaceSymbolRegistrationOptions): [Disposable, WorkspaceSymbolProvider];
+}
+//# sourceMappingURL=workspaceSymbol.d.ts.map

package/es/common/workspaceSymbol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspaceSymbol.d.ts","sourceRoot":"","sources":["../../src/common/workspaceSymbol.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,kBAAkB,EAClB,kBAAkB,EAClB,kCAAkC,EACnC,MAAM,yCAAyC,CAAC;AAKjD,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,cAAc,EACd,iBAAiB,IAAI,kBAAkB,EACvC,uBAAuB,EACxB,MAAM,QAAQ,CAAC;AAGhB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAU,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAIzD,MAAM,WAAW,gCAAgC;IAC/C,CACE,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,iBAAiB,GACvB,cAAc,CAAC,kBAAkB,EAAE,CAAC,CAAC;CACzC;AAED,MAAM,WAAW,+BAA+B;IAC9C,CACE,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,iBAAiB,GACvB,cAAc,CAAC,kBAAkB,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,yBAAyB;IACxC,uBAAuB,CAAC,EAAE,CACxB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,gCAAgC,KACnC,cAAc,CAAC,kBAAkB,EAAE,CAAC,CAAC;IAC1C,sBAAsB,CAAC,EAAE,CACvB,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,iBAAiB,EACxB,IAAI,EAAE,+BAA+B,KAClC,cAAc,CAAC,kBAAkB,CAAC,CAAC;CACzC;AAED,qBAAa,sBAAuB,SAAQ,gBAAgB,CAC1D,kCAAkC,EAClC,uBAAuB,EACvB,yBAAyB,CAC1B;gBACa,MAAM,EAAE,aAAa,CAAC,yBAAyB,CAAC;IAIrD,sBAAsB,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI;IAY9D,UAAU,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI;IAazD,SAAS,CAAC,wBAAwB,CAChC,OAAO,EAAE,kCAAkC,GAC1C,CAAC,UAAU,EAAE,uBAAuB,CAAC;CAsEzC"}

package/es/common/workspaceSymbol.js

@@ -0,0 +1,101 @@
+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); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License. See License.txt in the project root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { WorkspaceSymbolRequest, WorkspaceSymbolResolveRequest } from '@difizen/vscode-languageserver-protocol';
+import { SupportedSymbolKinds, SupportedSymbolTags } from "./documentSymbol.js";
+import { ensure, WorkspaceFeature } from "./features.js";
+import * as UUID from "./utils/uuid.js";
+import { languages as Languages } from "./vscodeAdaptor/vscodeAdaptor.js";
+export var WorkspaceSymbolFeature = /*#__PURE__*/function (_WorkspaceFeature) {
+  _inherits(WorkspaceSymbolFeature, _WorkspaceFeature);
+  var _super = _createSuper(WorkspaceSymbolFeature);
+  function WorkspaceSymbolFeature(client) {
+    _classCallCheck(this, WorkspaceSymbolFeature);
+    return _super.call(this, client, WorkspaceSymbolRequest.type);
+  }
+  _createClass(WorkspaceSymbolFeature, [{
+    key: "fillClientCapabilities",
+    value: function fillClientCapabilities(capabilities) {
+      var symbolCapabilities = ensure(ensure(capabilities, 'workspace'), 'symbol');
+      symbolCapabilities.dynamicRegistration = true;
+      symbolCapabilities.symbolKind = {
+        valueSet: SupportedSymbolKinds
+      };
+      symbolCapabilities.tagSupport = {
+        valueSet: SupportedSymbolTags
+      };
+      symbolCapabilities.resolveSupport = {
+        properties: ['location.range']
+      };
+    }
+  }, {
+    key: "initialize",
+    value: function initialize(capabilities) {
+      if (!capabilities.workspaceSymbolProvider) {
+        return;
+      }
+      this.register({
+        id: UUID.generateUuid(),
+        registerOptions: capabilities.workspaceSymbolProvider === true ? {
+          workDoneProgress: false
+        } : capabilities.workspaceSymbolProvider
+      });
+    }
+  }, {
+    key: "registerLanguageProvider",
+    value: function registerLanguageProvider(options) {
+      var _this = this;
+      var provider = {
+        provideWorkspaceSymbols: function provideWorkspaceSymbols(query, token) {
+          var client = _this._client;
+          var provideWorkspaceSymbols = function provideWorkspaceSymbols(query, token) {
+            return client.sendRequest(WorkspaceSymbolRequest.type, {
+              query: query
+            }, token).then(function (result) {
+              if (token.isCancellationRequested) {
+                return null;
+              }
+              return client.protocol2CodeConverter.asSymbolInformations(result, token);
+            }, function (error) {
+              return client.handleFailedRequest(WorkspaceSymbolRequest.type, token, error, null);
+            });
+          };
+          var middleware = client.middleware;
+          return middleware.provideWorkspaceSymbols ? middleware.provideWorkspaceSymbols(query, token, provideWorkspaceSymbols) : provideWorkspaceSymbols(query, token);
+        },
+        resolveWorkspaceSymbol: options.resolveProvider === true ? function (item, token) {
+          var client = _this._client;
+          var resolveWorkspaceSymbol = function resolveWorkspaceSymbol(item, token) {
+            return client.sendRequest(WorkspaceSymbolResolveRequest.type, client.code2ProtocolConverter.asWorkspaceSymbol(item), token).then(function (result) {
+              if (token.isCancellationRequested) {
+                return null;
+              }
+              return client.protocol2CodeConverter.asSymbolInformation(result);
+            }, function (error) {
+              return client.handleFailedRequest(WorkspaceSymbolResolveRequest.type, token, error, null);
+            });
+          };
+          var middleware = client.middleware;
+          return middleware.resolveWorkspaceSymbol ? middleware.resolveWorkspaceSymbol(item, token, resolveWorkspaceSymbol) : resolveWorkspaceSymbol(item, token);
+        } : undefined
+      };
+      return [Languages.registerWorkspaceSymbolProvider(provider), provider];
+    }
+  }]);
+  return WorkspaceSymbolFeature;
+}(WorkspaceFeature);

package/es/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LibroCellURIScheme = "libro-notebook-cell";
+//# sourceMappingURL=constants.d.ts.map

package/es/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,wBAAwB,CAAC"}

package/es/constants.js

@@ -0,0 +1 @@
+export var LibroCellURIScheme = 'libro-notebook-cell';

package/es/index.d.ts

@@ -0,0 +1,6 @@
+export * from './libro-language-client-manager.js';
+export * from './libro-language-client.js';
+export * from './module.js';
+export * from './common/api.js';
+export * from './constants.js';
+//# sourceMappingURL=index.d.ts.map

package/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/es/index.js

@@ -0,0 +1,5 @@
+export * from "./libro-language-client-manager.js";
+export * from "./libro-language-client.js";
+export * from "./module.js";
+export * from "./common/api.js";
+export * from "./constants.js";