monaco-editor11 1.0.7 → 1.0.9

package/dist/index.d.ts

@@ -1,8 +1,3 @@
-export declare const createEditorWorker: () => Worker;
-export declare const createHtmlWorker: () => Worker;
-export declare const createCssWorker: () => Worker;
-export declare const createJsonWorker: () => Worker;
-export declare const createTsWorker: () => Worker;
 declare global {
     interface Window {
         MonacoEnvironment?: {
@@ -11,4 +6,3 @@ declare global {
     }
 }
 export declare const initMonacoWorker: () => void;
-export * from 'monaco-editor';

package/dist/monaco-editor11.es.js

@@ -1,83 +1,54 @@
-export * from "monaco-editor";
-const n = `import { isWorkerInitialized } from '../common/initialize.js';
-export { initialize } from '../common/initialize.js';
-import { start } from './editor.worker.start.js';
-
-self.onmessage = () => {
-  if (!isWorkerInitialized()) {
-    start(() => {
-      return {};
-    });
-  }
-};
-`, o = `import { initialize } from '../../common/initialize.js';
-import { HTMLWorker } from './htmlWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new HTMLWorker(ctx, createData);
-  });
-};
-`, i = `import { initialize } from '../../common/initialize.js';
-import { CSSWorker } from './cssWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new CSSWorker(ctx, createData);
-  });
-};
-`, s = `import { initialize } from '../../common/initialize.js';
-import { JSONWorker } from './jsonWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new JSONWorker(ctx, createData);
-  });
-};
-`, a = `import { initialize } from '../../common/initialize.js';
-import * as typescriptServices from './lib/typescriptServices.js';
-export { typescriptServices as ts };
-import { create } from './tsWorker.js';
-export { TypeScriptWorker } from './tsWorker.js';
-export { libFileMap } from './lib/lib.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return create(ctx, createData);
-  });
-};
-
-export { create, initialize };
-`, e = (t) => {
-  const r = new Blob([t], { type: "application/javascript" });
-  return new Worker(URL.createObjectURL(r), { type: "module" });
-}, c = () => e(n), m = () => e(o), l = () => e(i), p = () => e(s), k = () => e(a), W = () => {
-  window.MonacoEnvironment = {
-    getWorker(t, r) {
-      switch (r) {
-        case "json":
-          return p();
-        case "css":
-        case "scss":
-        case "less":
-          return l();
-        case "html":
-        case "handlebars":
-          return m();
-        case "typescript":
-        case "javascript":
-          return k();
-        default:
-          return c();
-      }
+function n(r) {
+  return new Worker(
+    "/assets/editor.worker-iXcRX1Tq.js",
+    {
+      name: r == null ? void 0 : r.name
     }
-  };
+  );
+}
+function a(r) {
+  return new Worker(
+    "/assets/html.worker-C8VxctEJ.js",
+    {
+      name: r == null ? void 0 : r.name
+    }
+  );
+}
+function c(r) {
+  return new Worker(
+    "/assets/css.worker-C7FogG4G.js",
+    {
+      name: r == null ? void 0 : r.name
+    }
+  );
+}
+function k(r) {
+  return new Worker(
+    "/assets/json.worker-CMC9kgPL.js",
+    {
+      name: r == null ? void 0 : r.name
+    }
+  );
+}
+function s(r) {
+  return new Worker(
+    "/assets/ts.worker-CtTJ3hNN.js",
+    {
+      name: r == null ? void 0 : r.name
+    }
+  );
+}
+const W = () => {
+  try {
+    self.MonacoEnvironment = {
+      getWorker(r, e) {
+        return e == "json" ? new k() : e == "css" || e == "scss" || e == "less" ? new c() : e == "html" || e == "handlebars" || e == "razor" ? new a() : e == "typescript" || e == "javascript" ? new s() : new n();
+      }
+    };
+  } catch (r) {
+    console.log("initMonacoWorker资源加载失败", r);
+  }
 };
 export {
-  l as createCssWorker,
-  c as createEditorWorker,
-  m as createHtmlWorker,
-  p as createJsonWorker,
-  k as createTsWorker,
   W as initMonacoWorker
 };

package/dist/monaco-editor11.umd.js

@@ -1,50 +1 @@
-(function(e,t){typeof exports=="object"&&typeof module<"u"?t(exports,require("monaco-editor")):typeof define=="function"&&define.amd?define(["exports","monaco-editor"],t):(e=typeof globalThis<"u"?globalThis:e||self,t(e.monacoEditor11={},e.monacoEditor))})(this,(function(e,t){"use strict";const l=`import { isWorkerInitialized } from '../common/initialize.js';
-export { initialize } from '../common/initialize.js';
-import { start } from './editor.worker.start.js';
-
-self.onmessage = () => {
-  if (!isWorkerInitialized()) {
-    start(() => {
-      return {};
-    });
-  }
-};
-`,f=`import { initialize } from '../../common/initialize.js';
-import { HTMLWorker } from './htmlWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new HTMLWorker(ctx, createData);
-  });
-};
-`,p=`import { initialize } from '../../common/initialize.js';
-import { CSSWorker } from './cssWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new CSSWorker(ctx, createData);
-  });
-};
-`,W=`import { initialize } from '../../common/initialize.js';
-import { JSONWorker } from './jsonWorker.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return new JSONWorker(ctx, createData);
-  });
-};
-`,k=`import { initialize } from '../../common/initialize.js';
-import * as typescriptServices from './lib/typescriptServices.js';
-export { typescriptServices as ts };
-import { create } from './tsWorker.js';
-export { TypeScriptWorker } from './tsWorker.js';
-export { libFileMap } from './lib/lib.js';
-
-self.onmessage = () => {
-  initialize((ctx, createData) => {
-    return create(ctx, createData);
-  });
-};
-
-export { create, initialize };
-`,n=r=>{const o=new Blob([r],{type:"application/javascript"});return new Worker(URL.createObjectURL(o),{type:"module"})},i=()=>n(l),s=()=>n(f),a=()=>n(p),c=()=>n(W),m=()=>n(k),u=()=>{window.MonacoEnvironment={getWorker(r,o){switch(o){case"json":return c();case"css":case"scss":case"less":return a();case"html":case"handlebars":return s();case"typescript":case"javascript":return m();default:return i()}}}};e.createCssWorker=a,e.createEditorWorker=i,e.createHtmlWorker=s,e.createJsonWorker=c,e.createTsWorker=m,e.initMonacoWorker=u,Object.keys(t).forEach(r=>{r!=="default"&&!Object.prototype.hasOwnProperty.call(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:()=>t[r]})}),Object.defineProperty(e,Symbol.toStringTag,{value:"Module"})}));
+(function(n,t){typeof exports=="object"&&typeof module<"u"?t(exports):typeof define=="function"&&define.amd?define(["exports"],t):(n=typeof globalThis<"u"?globalThis:n||self,t(n.monacoEditor11={}))})(this,(function(n){"use strict";function t(e){return new Worker("/assets/editor.worker-iXcRX1Tq.js",{name:e==null?void 0:e.name})}function s(e){return new Worker("/assets/html.worker-C8VxctEJ.js",{name:e==null?void 0:e.name})}function c(e){return new Worker("/assets/css.worker-C7FogG4G.js",{name:e==null?void 0:e.name})}function a(e){return new Worker("/assets/json.worker-CMC9kgPL.js",{name:e==null?void 0:e.name})}function u(e){return new Worker("/assets/ts.worker-CtTJ3hNN.js",{name:e==null?void 0:e.name})}const f=()=>{try{self.MonacoEnvironment={getWorker(e,r){return r=="json"?new a:r=="css"||r=="scss"||r=="less"?new c:r=="html"||r=="handlebars"||r=="razor"?new s:r=="typescript"||r=="javascript"?new u:new t}}}catch(e){console.log("initMonacoWorker资源加载失败",e)}};n.initMonacoWorker=f,Object.defineProperty(n,Symbol.toStringTag,{value:"Module"})}));

package/dist/monaco.d.ts

@@ -0,0 +1,8 @@
+declare global {
+    interface Window {
+        MonacoEnvironment?: {
+            getWorker: (moduleId: string, label: string) => Worker;
+        };
+    }
+}
+export declare const initMonacoWorker: () => void;

package/dist/workers/common/initialize.js

@@ -0,0 +1,16 @@
+import { start } from '../editor/editor.worker.start.js';
+
+let initialized = false;
+function isWorkerInitialized() {
+  return initialized;
+}
+function initialize(callback) {
+  initialized = true;
+  self.onmessage = (m) => {
+    start((ctx) => {
+      return callback(ctx, m.data);
+    });
+  };
+}
+
+export { initialize, isWorkerInitialized };

package/dist/workers/common/workers.js

@@ -0,0 +1,141 @@
+import '../editor/browser/coreCommands.js';
+import '../editor/browser/widget/codeEditor/codeEditorWidget.js';
+import '../editor/browser/widget/diffEditor/diffEditor.contribution.js';
+import '../editor/contrib/anchorSelect/browser/anchorSelect.js';
+import '../editor/contrib/bracketMatching/browser/bracketMatching.js';
+import '../editor/contrib/caretOperations/browser/caretOperations.js';
+import '../editor/contrib/caretOperations/browser/transpose.js';
+import '../editor/contrib/clipboard/browser/clipboard.js';
+import '../editor/contrib/codeAction/browser/codeActionContributions.js';
+import '../editor/contrib/codelens/browser/codelensController.js';
+import '../editor/contrib/colorPicker/browser/colorPickerContribution.js';
+import '../editor/contrib/comment/browser/comment.js';
+import '../editor/contrib/contextmenu/browser/contextmenu.js';
+import '../editor/contrib/cursorUndo/browser/cursorUndo.js';
+import '../editor/contrib/dnd/browser/dnd.js';
+import '../editor/contrib/dropOrPasteInto/browser/copyPasteContribution.js';
+import '../editor/contrib/dropOrPasteInto/browser/dropIntoEditorContribution.js';
+import '../editor/contrib/find/browser/findController.js';
+import '../editor/contrib/folding/browser/folding.js';
+import '../editor/contrib/fontZoom/browser/fontZoom.js';
+import '../editor/contrib/format/browser/formatActions.js';
+import '../editor/contrib/documentSymbols/browser/documentSymbols.js';
+import '../editor/contrib/inlineCompletions/browser/inlineCompletions.contribution.js';
+import '../editor/contrib/inlineProgress/browser/inlineProgress.js';
+import '../editor/contrib/gotoSymbol/browser/goToCommands.js';
+import '../editor/contrib/gotoSymbol/browser/link/goToDefinitionAtPosition.js';
+import '../editor/contrib/gotoError/browser/gotoError.js';
+import '../editor/contrib/gpu/browser/gpuActions.js';
+import '../editor/contrib/hover/browser/hoverContribution.js';
+import '../editor/contrib/indentation/browser/indentation.js';
+import '../editor/contrib/inlayHints/browser/inlayHintsContribution.js';
+import '../editor/contrib/inPlaceReplace/browser/inPlaceReplace.js';
+import '../editor/contrib/insertFinalNewLine/browser/insertFinalNewLine.js';
+import '../editor/contrib/lineSelection/browser/lineSelection.js';
+import '../editor/contrib/linesOperations/browser/linesOperations.js';
+import '../editor/contrib/linkedEditing/browser/linkedEditing.js';
+import '../editor/contrib/links/browser/links.js';
+import '../editor/contrib/longLinesHelper/browser/longLinesHelper.js';
+import '../editor/contrib/middleScroll/browser/middleScroll.contribution.js';
+import '../editor/contrib/multicursor/browser/multicursor.js';
+import '../editor/contrib/parameterHints/browser/parameterHints.js';
+import '../editor/contrib/placeholderText/browser/placeholderText.contribution.js';
+import '../editor/contrib/rename/browser/rename.js';
+import '../editor/contrib/sectionHeaders/browser/sectionHeaders.js';
+import '../editor/contrib/semanticTokens/browser/documentSemanticTokens.js';
+import '../editor/contrib/semanticTokens/browser/viewportSemanticTokens.js';
+import '../editor/contrib/smartSelect/browser/smartSelect.js';
+import '../editor/contrib/snippet/browser/snippetController2.js';
+import '../editor/contrib/stickyScroll/browser/stickyScrollContribution.js';
+import '../editor/contrib/suggest/browser/suggestController.js';
+import '../editor/contrib/suggest/browser/suggestInlineCompletions.js';
+import '../editor/contrib/tokenization/browser/tokenization.js';
+import '../editor/contrib/toggleTabFocusMode/browser/toggleTabFocusMode.js';
+import '../editor/contrib/unicodeHighlighter/browser/unicodeHighlighter.js';
+import '../editor/contrib/unusualLineTerminators/browser/unusualLineTerminators.js';
+import '../editor/contrib/wordHighlighter/browser/wordHighlighter.js';
+import '../editor/contrib/wordOperations/browser/wordOperations.js';
+import '../editor/contrib/wordPartOperations/browser/wordPartOperations.js';
+import '../editor/contrib/readOnlyMessage/browser/contribution.js';
+import '../editor/contrib/diffEditorBreadcrumbs/browser/contribution.js';
+import '../editor/contrib/floatingMenu/browser/floatingMenu.contribution.js';
+import '../editor/common/standaloneStrings.js';
+import '../base/browser/ui/codicons/codicon/codicon.css';
+import '../base/browser/ui/codicons/codicon/codicon-modifiers.css';
+import '../editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard.js';
+import '../editor/standalone/browser/inspectTokens/inspectTokens.js';
+import '../editor/standalone/browser/quickAccess/standaloneHelpQuickAccess.js';
+import '../editor/standalone/browser/quickAccess/standaloneGotoLineQuickAccess.js';
+import '../editor/standalone/browser/quickAccess/standaloneGotoSymbolQuickAccess.js';
+import '../editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess.js';
+import '../editor/standalone/browser/referenceSearch/standaloneReferenceSearch.js';
+import '../editor/standalone/browser/toggleHighContrast/toggleHighContrast.js';
+import { editor } from '../editor/editor.api2.js';
+
+function createTrustedTypesPolicy(policyName, policyOptions) {
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment?.createTrustedTypesPolicy) {
+    try {
+      return monacoEnvironment.createTrustedTypesPolicy(policyName, policyOptions);
+    } catch (err) {
+      console.error(err);
+      return void 0;
+    }
+  }
+  try {
+    return globalThis.trustedTypes?.createPolicy(policyName, policyOptions);
+  } catch (err) {
+    console.error(err);
+    return void 0;
+  }
+}
+let ttPolicy;
+if (typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope" && globalThis.workerttPolicy !== void 0) {
+  ttPolicy = globalThis.workerttPolicy;
+} else {
+  ttPolicy = createTrustedTypesPolicy("defaultWorkerFactory", {
+    createScriptURL: (value) => value
+  });
+}
+function getWorker(descriptor) {
+  const label = descriptor.label;
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment) {
+    if (typeof monacoEnvironment.getWorker === "function") {
+      return monacoEnvironment.getWorker("workerMain.js", label);
+    }
+    if (typeof monacoEnvironment.getWorkerUrl === "function") {
+      const workerUrl = monacoEnvironment.getWorkerUrl("workerMain.js", label);
+      return new Worker(
+        ttPolicy ? ttPolicy.createScriptURL(workerUrl) : workerUrl,
+        { name: label, type: "module" }
+      );
+    }
+  }
+  if (descriptor.createWorker) {
+    return descriptor.createWorker();
+  }
+  throw new Error(
+    `You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`
+  );
+}
+function createWebWorker(opts) {
+  const worker = Promise.resolve(
+    getWorker({
+      label: opts.label ?? "monaco-editor-worker",
+      moduleId: opts.moduleId,
+      createWorker: opts.createWorker
+    })
+  ).then((w) => {
+    w.postMessage("ignore");
+    w.postMessage(opts.createData);
+    return w;
+  });
+  return editor.createWebWorker({
+    worker,
+    host: opts.host,
+    keepIdleModels: opts.keepIdleModels
+  });
+}
+
+export { createWebWorker };

package/dist/workers/editor/common/abstractSyntaxTokenBackend.js

@@ -0,0 +1,128 @@
+import { equals } from '../../../../base/common/arrays.js';
+import { RunOnceScheduler } from '../../../../base/common/async.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { LineRange } from '../../core/ranges/lineRange.js';
+import '../../../../base/common/observableInternal/index.js';
+import { itemsEquals, itemEquals, equalsIfDefined } from '../../../../base/common/equals.js';
+import { observableSignal } from '../../../../base/common/observableInternal/observables/observableSignal.js';
+import { observableValueOpts } from '../../../../base/common/observableInternal/observables/observableValueOpts.js';
+import { derivedOpts } from '../../../../base/common/observableInternal/observables/derived.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * @internal
+ */
+class AttachedViews {
+    constructor() {
+        this._onDidChangeVisibleRanges = new Emitter();
+        this.onDidChangeVisibleRanges = this._onDidChangeVisibleRanges.event;
+        this._views = new Set();
+        this._viewsChanged = observableSignal(this);
+        this.visibleLineRanges = derivedOpts({
+            owner: this,
+            equalsFn: itemsEquals(itemEquals())
+        }, reader => {
+            this._viewsChanged.read(reader);
+            const ranges = LineRange.joinMany([...this._views].map(view => view.state.read(reader)?.visibleLineRanges ?? []));
+            return ranges;
+        });
+    }
+    attachView() {
+        const view = new AttachedViewImpl((state) => {
+            this._onDidChangeVisibleRanges.fire({ view, state });
+        });
+        this._views.add(view);
+        this._viewsChanged.trigger(undefined);
+        return view;
+    }
+    detachView(view) {
+        this._views.delete(view);
+        this._onDidChangeVisibleRanges.fire({ view, state: undefined });
+        this._viewsChanged.trigger(undefined);
+    }
+}
+/**
+ * @internal
+ */
+class AttachedViewState {
+    constructor(visibleLineRanges, stabilized) {
+        this.visibleLineRanges = visibleLineRanges;
+        this.stabilized = stabilized;
+    }
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (!equals(this.visibleLineRanges, other.visibleLineRanges, (a, b) => a.equals(b))) {
+            return false;
+        }
+        if (this.stabilized !== other.stabilized) {
+            return false;
+        }
+        return true;
+    }
+}
+class AttachedViewImpl {
+    get state() { return this._state; }
+    constructor(handleStateChange) {
+        this.handleStateChange = handleStateChange;
+        this._state = observableValueOpts({ owner: this, equalsFn: equalsIfDefined((a, b) => a.equals(b)) }, undefined);
+    }
+    setVisibleLines(visibleLines, stabilized) {
+        const visibleLineRanges = visibleLines.map((line) => new LineRange(line.startLineNumber, line.endLineNumber + 1));
+        const state = new AttachedViewState(visibleLineRanges, stabilized);
+        this._state.set(state, undefined, undefined);
+        this.handleStateChange(state);
+    }
+}
+class AttachedViewHandler extends Disposable {
+    get lineRanges() { return this._lineRanges; }
+    constructor(_refreshTokens) {
+        super();
+        this._refreshTokens = _refreshTokens;
+        this.runner = this._register(new RunOnceScheduler(() => this.update(), 50));
+        this._computedLineRanges = [];
+        this._lineRanges = [];
+    }
+    update() {
+        if (equals(this._computedLineRanges, this._lineRanges, (a, b) => a.equals(b))) {
+            return;
+        }
+        this._computedLineRanges = this._lineRanges;
+        this._refreshTokens();
+    }
+    handleStateChange(state) {
+        this._lineRanges = state.visibleLineRanges;
+        if (state.stabilized) {
+            this.runner.cancel();
+            this.update();
+        }
+        else {
+            this.runner.schedule();
+        }
+    }
+}
+class AbstractSyntaxTokenBackend extends Disposable {
+    get backgroundTokenizationState() {
+        return this._backgroundTokenizationState;
+    }
+    constructor(_languageIdCodec, _textModel) {
+        super();
+        this._languageIdCodec = _languageIdCodec;
+        this._textModel = _textModel;
+        this._onDidChangeTokens = this._register(new Emitter());
+        /** @internal, should not be exposed by the text model! */
+        this.onDidChangeTokens = this._onDidChangeTokens.event;
+    }
+    tokenizeIfCheap(lineNumber) {
+        if (this.isCheapToTokenize(lineNumber)) {
+            this.forceTokenization(lineNumber);
+        }
+    }
+}
+
+export { AbstractSyntaxTokenBackend, AttachedViewHandler, AttachedViewState, AttachedViews };

package/dist/workers/editor/common/abstractText.js

@@ -0,0 +1,89 @@
+import { assert } from '../../../../base/common/assert.js';
+import { Position } from '../position.js';
+import { Range } from '../range.js';
+import { TextLength } from './textLength.js';
+import { PositionOffsetTransformer } from './positionToOffsetImpl.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class AbstractText {
+    constructor() {
+        this._transformer = undefined;
+    }
+    get endPositionExclusive() {
+        return this.length.addToPosition(new Position(1, 1));
+    }
+    get lineRange() {
+        return this.length.toLineRange();
+    }
+    getValue() {
+        return this.getValueOfRange(this.length.toRange());
+    }
+    getValueOfOffsetRange(range) {
+        return this.getValueOfRange(this.getTransformer().getRange(range));
+    }
+    getLineLength(lineNumber) {
+        return this.getValueOfRange(new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER)).length;
+    }
+    getTransformer() {
+        if (!this._transformer) {
+            this._transformer = new PositionOffsetTransformer(this.getValue());
+        }
+        return this._transformer;
+    }
+    getLineAt(lineNumber) {
+        return this.getValueOfRange(new Range(lineNumber, 1, lineNumber, Number.MAX_SAFE_INTEGER));
+    }
+}
+class LineBasedText extends AbstractText {
+    constructor(_getLineContent, _lineCount) {
+        assert(_lineCount >= 1);
+        super();
+        this._getLineContent = _getLineContent;
+        this._lineCount = _lineCount;
+    }
+    getValueOfRange(range) {
+        if (range.startLineNumber === range.endLineNumber) {
+            return this._getLineContent(range.startLineNumber).substring(range.startColumn - 1, range.endColumn - 1);
+        }
+        let result = this._getLineContent(range.startLineNumber).substring(range.startColumn - 1);
+        for (let i = range.startLineNumber + 1; i < range.endLineNumber; i++) {
+            result += '\n' + this._getLineContent(i);
+        }
+        result += '\n' + this._getLineContent(range.endLineNumber).substring(0, range.endColumn - 1);
+        return result;
+    }
+    getLineLength(lineNumber) {
+        return this._getLineContent(lineNumber).length;
+    }
+    get length() {
+        const lastLine = this._getLineContent(this._lineCount);
+        return new TextLength(this._lineCount - 1, lastLine.length);
+    }
+}
+class ArrayText extends LineBasedText {
+    constructor(lines) {
+        super(lineNumber => lines[lineNumber - 1], lines.length);
+    }
+}
+class StringText extends AbstractText {
+    constructor(value) {
+        super();
+        this.value = value;
+        this._t = new PositionOffsetTransformer(this.value);
+    }
+    getValueOfRange(range) {
+        return this._t.getOffsetRange(range).substring(this.value);
+    }
+    get length() {
+        return this._t.textLength;
+    }
+    // Override the getTransformer method to return the cached transformer
+    getTransformer() {
+        return this._t;
+    }
+}
+
+export { AbstractText, ArrayText, LineBasedText, StringText };