@pirireis/webglobeplugins 0.2.0 → 0.3.1

package/programs/rings/distancering/circlepaddingfreeangleprogram.js

@@ -9,7 +9,7 @@ const vertexShader = `#version 300 es ` +
     shaderfunctions.R +
     shaderfunctions.POLE +
     CameraUniformBlockString +
-    shaderfunctions.mercatorXYTo2DPoint +
+    shaderfunctions.mercatorXYToGLPosition +
     shaderfunctions.longLatRadToMercator +
     shaderfunctions.longLatRadToCartesian3D +
     shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
@@ -56,7 +56,7 @@ void main() {
         limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
     }
     v_limp = limp;
-    gl_Position = mercatorXYTo2DPoint(limp);
+    gl_Position = mercatorXYToGLPosition(limp);
 }`;
 
 const fragmentShader = `#version 300 es

package/programs/rings/distancering/paddyflatprogram.js

@@ -7,7 +7,7 @@ const vertexShader = `#version 300 es ` +
     shaderfunctions.R +
     shaderfunctions.POLE +
     CameraUniformBlockString +
-    shaderfunctions.mercatorXYTo2DPoint +
+    shaderfunctions.mercatorXYToGLPosition +
     shaderfunctions.longLatRadToMercator +
     shaderfunctions.longLatRadToCartesian3D +
     shaderfunctions.circleLimpFromLongLatRadCenterCartesian3D +
@@ -58,7 +58,7 @@ void main() {
         limp = circleLimpFromLongLatRadCenterMercatorRealDistance(center, radius_, angle);
     }
     v_limp = limp;
-    gl_Position = mercatorXYTo2DPoint(limp);
+    gl_Position = mercatorXYToGLPosition(limp);
 }`;
 
 const fragmentShader = `#version 300 es

package/programs/totems/camerauniformblock.js

@@ -1,3 +1,6 @@
+import { globeProgramCache } from "../programcache";
+
+
 export const CameraUniformBlockString = `
 layout(std140) uniform CameraUniformBlock {
     mat4 view; // 64 bytes           0
@@ -126,3 +129,9 @@ export default class
         }
     }
 }
+
+
+export const CameraUniformBlockTotemCache = Object.freeze({
+    get: (globe) => { return globeProgramCache.getProgram(globe, CameraUniformBlockTotem) },
+    release: (globe) => { return globeProgramCache.releaseProgram(globe, CameraUniformBlockTotem) }
+});

package/programs/totems/index.js

@@ -1,2 +1,2 @@
-import CameraUniformBlockTotem, { CameraUniformBlockString } from "./camerauniformblock";
-export { CameraUniformBlockTotem, CameraUniformBlockString };
+import CameraUniformBlockTotem, { CameraUniformBlockString, CameraUniformBlockTotemCache } from "./camerauniformblock";
+export { CameraUniformBlockTotem, CameraUniformBlockString, CameraUniformBlockTotemCache };

package/rangerings/rangerings.js

@@ -87,8 +87,6 @@ export default class {
         const { circleFlatProgram, paddyFlatProgram, paddingFreeAngleProgram, bufferManager, compass, gl, circleEdgeCount, paddingBufferManager, _opacity } = this;
         if (this.bufferManager !== null && bufferManager.length > 0) {
             gl.disable(gl.DEPTH_TEST);
-            // gl.enable(gl.BLEND);
-            // gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
             console.log("the opacity", _opacity);
             circleFlatProgram.draw(bufferManager, compass, circleEdgeCount, _opacity);
             if (this._onedegreepaddingOn) paddyFlatProgram.draw(bufferManager, 360, compass, _opacity);

package/util/account/bufferoffsetmanager.js

@@ -89,7 +89,6 @@ export default class {
         gl.bindBuffer(gl.ARRAY_BUFFER, null);
     }
 
-
     offsetMapIterator() { // can be used for defraging the real buffer.
         return this.offSetMap.entries();
     }

package/util/account/index.js

@@ -1,3 +1,7 @@
 import BufferOffsetManager from './bufferoffsetmanager.js';
 
-export { BufferOffsetManager };
+export { BufferOffsetManager };
+
+
+
+export * from './single-attribute-buffer-management';

package/util/account/single-attribute-buffer-management/buffer-manager.js

@@ -0,0 +1,119 @@
+/**
+ * BufferOffsetManager
+ * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer. 
+ * ------------------------------------------------------------------------------------------------------------------------------------------- * Functions:
+ * 1. getOffet(key) : return the offset of the key if not found return false.
+ * 2. setOffset(key, offset) : set the offset of the key.
+ * 3. nextOffset() : return the next available offset if not return false.
+ * 4. delete(key) : delete the key and return true if not found return false.
+ * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
+ * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
+ * -------------------------------------------------------------------------------------------------------------------------------------------
+ * What this class does NOT do:
+ * ADD, DELETE, READ
+ * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
+ * DELETE, might be a set to single byte to indicate the tombstone.
+ * READ, most of the time is not needed to be read, unless for defraging.
+ * This unpredicatable behavior is not handled by this class.
+ */
+
+export class BufferManager {
+    constructor(gl, itemSize, { bufferType = "STATIC_DRAW", buffer = null, initialCapacity = null } = {}) {
+        this.gl = gl;
+        this.itemSize = itemSize;
+        this.bufferType = bufferType;
+        this.buffer = buffer === null ? gl.createBuffer() : buffer;
+        if (initialCapacity !== null) this.resetWithCapacity(initialCapacity);
+    }
+
+    resetWithCapacity(capacity) {
+        const { gl, buffer, bufferType, itemSize } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+
+    deleteBulk(offsets) {
+        const { gl, buffer, itemSize } = this;
+        const emptyBlock = new Float32Array(this.itemSize).fill(0)
+        const offsetMultiplier = itemSize * 4;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (let offset of offsets) {
+            if (offset !== undefined) {
+
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset * offsetMultiplier, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+
+
+    insertBulk(blocks, offsets) {
+        const { gl, buffer, itemSize } = this;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        const offsetMultiplier = itemSize * 4;
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            const offset = offsets[i] * offsetMultiplier;
+            if (offset !== undefined) gl.bufferSubData(gl.ARRAY_BUFFER, offset, block);
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+
+
+    // TODO: this is broken
+    defrag(offsetValues, occupiedCapacity, newCapacity) {
+        const { gl, buffer, bufferType, itemSize } = this;
+
+        const newArray = new Float32Array(newCapacity * itemSize);
+        const bufferData = this._getBufferData(occupiedCapacity);
+        console.log("bufferData", bufferData);
+        let newOffset = 0;
+        for (const offset of offsetValues) {
+            const itemOffset = offset * itemSize;
+            newArray.set(bufferData.slice(itemOffset, itemOffset + itemSize), newOffset);
+            console.log("oldOffset", itemOffset, "newOffset", newOffset);
+            newOffset += itemSize;
+        }
+
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+
+    }
+
+    extendBuffer(occupiedCapacity, newCapacity) {
+        const { gl, buffer, bufferType } = this;
+        const itemSize = this.itemSize;
+        const bufferData = this._getBufferData(occupiedCapacity);
+        console.log("extending buffer from", occupiedCapacity, "to", newCapacity, 'item size', itemSize);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+
+    _getBufferData(occupiedCapacity) {
+        const { gl, buffer } = this;
+        console.log(occupiedCapacity, this.itemSize)
+        const size = occupiedCapacity * this.itemSize;
+        console.log("size", size);
+        const bufferData = new Float32Array(size);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return bufferData;
+    }
+
+    free() {
+        if (this.isFreed) return;
+        this.gl.deleteBuffer(this.buffer);
+        this.buffer = null;
+        this.gl = null;
+        this.isFreed = true;
+    }
+}
+
+
+

package/util/account/single-attribute-buffer-management/buffer-orchestrator.js

@@ -0,0 +1,256 @@
+
+
+/**
+ * OffsetManager
+ * 1) Capacity
+ * 2) Offset account
+ * 3) Command Buffers in its regisration list. 
+ * 
+ * How insertBulk works:
+ * 0) autoExtendBuffers..
+ * 1) assign offset to all keys if not already assigned.
+ * 2) send item list to each buffer manager and let them do their job. 
+ *          This cannot work. BufferManager does not know the which data to insert.
+ *          Solutions:
+ *          1) selectMethod: insertBulk(items, offsets, selectMethod)
+ *             selectMethod(item) => itemToBlock(item)
+ *          2) att1manager.insertBulk(items.map(item => this.att1ItemToBlock(item)), offsets)
+ *   Idea about future:
+ *      insert first tombstone.length items one by one.
+ *      insert the rest in a big float32array. IT CAN BE DONE
+ * 3) DrawRender
+ * 
+ * How autoExtendBuffers works:
+ * 1) if incoming items length is greater then space left in buffer, calculate new capacity and extend all buffers.
+ * 
+ * 
+ 
+*/
+
+
+
+/**
+ * Scratchpad
+ * 
+ * plugin insertBulk(items){
+ *  this.offsetManager.autoExtendBuffers(items.length);
+ *  this.offsetManager.assignOffsets(items); // read item.keys and assign offsets to them.
+ *  this.attrib1BufferManager.insertBulk(items.map(item => this.attrib1Block(item)), ); 
+ *  this.attrib2BufferManager.insertBulk();
+ *  if (this.attrib3isInNeed) this.attrib3BufferManager.insertBulk(items);
+ *  this.globe.DrawRender();
+ * }
+ * 
+ * useTheCaseThatRequiresAttrib3(){
+ *  // generate items from other buffers if possible.
+ * }
+ * 
+ * 
+ * assignOffsets(items){
+ * for (const item of items){
+ * const offset = this.offsetManager.getOffset(item.key) || this.offsetManager.nextOffset();
+ * item.__offset__ = offset;
+ * 
+ * allBuffers = [attrib1BufferManager, attrib2BufferManager, attrib3BufferManager]
+ *  // // not single responsibility .. 
+ * defrag(allBuffers){
+ *  for (const bufferManager of allBuffers){
+ *     bufferManager.defrag(this.offsetManager.offsetMap);
+ *  }
+ *  this.offsetManager._defrag();  
+ * }
+ * 
+ */
+
+
+/**
+ * 
+ * attrib1BufferManager.insertBulk( items) { 
+ *  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+ *  for (const item of items) {
+ *      const block = this.itemToBlock(item); // this changes based on inserted data structure and expected block structure.
+ *      gl.bufferSubData(gl.ARRAY_BUFFER, item.__offset__, block);
+ *  }
+ * gl.bindBuffer(gl.ARRAY_BUFFER, null);
+ * }
+ * 
+ * deleteBulk(offsets){
+ *  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+ * for (const offset of offsets) {
+ * gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
+ * }
+ * gl.bindBuffer(gl.ARRAY_BUFFER, null);
+ * }
+ * 
+ * 
+ * // 
+ * defrag(offsetMap){
+ *  const newArray = new Float32Array(itemCount * itemSize);
+ *  const bufferData = this._getBufferData();
+ *  let newOffSet = 0;
+ *  for (const [key, offSet] of offsetMap) {
+ *     const bufferOffset = offset;
+ *    newArray.set(bufferData.slice(bufferOffset, bufferOffset + itemSize), newOffSet);
+        newOffset += itemSize * 4;
+    }
+    *
+    * gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    * 
+ * }
+ * 
+ * ---------------- 
+ 
+ */
+
+export class BufferOrchestrator {
+
+    constructor({ capacity = 10 } = {}) {
+        this._capacity = capacity;
+        this.offsetMap = new Map();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    }
+
+
+    resetWithCapacity(bufferManagersMap, capacity = null) {
+        this._capacity = capacity !== null ? capacity : this._capacity;
+        for (const [key, { bufferManager }] of bufferManagersMap) {
+            bufferManager.resetWithCapacity(this._capacity);
+        }
+        this.offsetMap.clear();
+        this.tombstoneOffsets = [];
+        this._length = 0;
+    }
+
+    insertBulk(items, bufferManagersMap) {
+        this.autoExtendBuffers(items.length, bufferManagersMap);
+        const { offsetMap } = this;
+        const offsets = [];
+        for (const item of items) {
+            const offset = offsetMap.get(item.key) || this.nextOffset();
+            offsetMap.set(item.key, offset);
+            offsets.push(offset);
+        }
+        for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+            bufferManager.insertBulk(items.map(adaptor), offsets);
+        }
+    }
+
+
+    // doesnot assign offset to the new items.
+    updateBulk(items, bufferManagersMap, bufferKeys) {
+        const { offsetMap } = this;
+        const offsets = [];
+        for (const item of items) {
+            const offset = offsetMap.get(item.key);
+            offsets.push(offset);
+        }
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const { bufferManager, adaptor } = bufferManagersMap.get(key);
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        } else {
+            for (const [key, { bufferManager, adaptor }] of bufferManagersMap) {
+                bufferManager.insertBulk(items.map(adaptor), offsets);
+            }
+        }
+
+    }
+
+
+    deleteBulk(keys, bufferManagersMap) {
+        const offsets = [];
+        for (const key of keys) {
+            const offset = this.getOffset(key);
+            if (offset !== undefined) {
+                offsets.push(offset);
+                this.offsetMap.delete(key);
+                this.tombstoneOffsets.push(offset);
+            }
+        }
+        for (const [key, { bufferManager }] of bufferManagersMap) {
+            bufferManager.deleteBulk(offsets);
+        }
+        console.log("deleteBulk after item size", this.offsetMap.size);
+    }
+
+
+
+    getOffset(key) {
+        return this.offsetMap.get(key);
+    }
+
+    nextOffset() {
+        if (this.tombstoneOffsets.length > 0) {
+            const offset = this.tombstoneOffsets.pop();
+            return offset;
+        }
+        if (this._length < this._capacity) {
+            return this._length++;
+        }
+        return false;
+    }
+
+
+    autoExtendBuffers(itemsLength, bufferManagersMap) {
+        if (itemsLength <= this.emptySpace) return;
+        const newCapacity = this.length + itemsLength;
+        console.log("autoExtendBuffers", "item L", itemsLength, "E space", this.emptySpace, "cap", this.capacity, "length", this.length, 'new Cap', newCapacity);
+        for (const [key, { bufferManager }] of bufferManagersMap) {
+            console.log("length", this.length, "newCapacity", newCapacity);
+            bufferManager.extendBuffer(this.length, newCapacity);
+        }
+        this._capacity = newCapacity;
+    }
+
+
+    defrag(bufferManagers, bufferKeys) { // TODO defrag and leave some empty space
+        const offsetMap = this.offsetMap;
+        console.log("defrag size", offsetMap.size, "cap", this.capacity, "length", this.length);
+        if (bufferKeys) {
+            for (const key of bufferKeys) {
+                const offset = offsetMap.get(key);
+                if (offset !== undefined) {
+                    for (const [key, { bufferManager }] of bufferManagers) {
+                        bufferManager.defrag([offset], this.length, offsetMap.size);
+                    }
+                }
+            }
+        } else {
+            for (const [key, { bufferManager }] of bufferManagers) {
+                bufferManager.defrag(offsetMap.values(), this.length, offsetMap.size);
+            }
+        }
+        this._defrag();
+        this._length = this._capacity = offsetMap.size;
+        this.tombstoneOffsets = [];
+    }
+
+
+
+    _defrag() {
+        const newOffsetMap = new Map();
+        let newOffset = 0;
+        for (const [key, offset] of this.offsetMap) {
+            console.log("defrag", key, offset, newOffset);
+            newOffsetMap.set(key, newOffset++);
+        }
+        this.offsetMap = newOffsetMap
+    }
+
+    get length() {
+        return this._length;
+    }
+
+    get emptySpace() {
+        return this._capacity - this.offsetMap.size;
+    }
+
+    get capacity() {
+        return this._capacity;
+    }
+}
+
+
+

package/util/account/single-attribute-buffer-management/index.js

@@ -0,0 +1,4 @@
+import { BufferOrchestrator } from "./buffer-orchestrator";
+import { BufferManager } from "./buffer-manager";
+
+export { BufferOrchestrator, BufferManager };

package/util/account/util.js

@@ -0,0 +1,9 @@
+export const vaoAttributeLoader = (gl, buffer, position, length, stride, offset, divisor = null) => {
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(position);
+    gl.vertexAttribPointer(position, length, gl.FLOAT, false, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(position, divisor);
+    }
+
+}

package/util/shaderfunctions/geometrytransformations.js

@@ -11,7 +11,7 @@ export const POLE = `
 
 export const R = `
 #ifndef R
-#define R 6378136.99911
+#define R 6378137.0
 #endif
 `;
 
@@ -23,13 +23,13 @@ export const PI = `
 
 export const POLE_BY_PI = ` 
 #ifndef POLE_BY_PI
-#define POLE_BY_PI 6378136.99911
+#define POLE_BY_PI 6378137.0
 #endif
 `;
 
 export const R_3D = `
 #ifndef R_3D
-#define R_3D 6378.137699911
+#define R_3D 6378.137
 #endif
 `;
 
@@ -55,9 +55,9 @@ vec2 pixelXYToCartesian2DPoint( vec2 position, vec2 translate, vec2 mapWH, vec2
 }
 `;
 
-
-export const mercatorXYTo2DPoint = `
-vec4 mercatorXYTo2DPoint( vec2 position) { // projection, translate, mapWH, screenWH comes from camera uniform block
+// TODO: rename it to mercatorXYToGLPosition
+export const mercatorXYToGLPosition = `
+vec4 mercatorXYToGLPosition( vec2 position) { // projection, translate, mapWH, screenWH comes from camera uniform block
     float x = (( position.x - translate.x ) / mapWH.x) * screenWH.x;
     float y = (1.0 - (position.y - translate.y) / mapWH.y) * screenWH.y;
     return projection * vec4(x, y, 0.0, 1.0);
@@ -220,8 +220,8 @@ float circleCircumferenceInterPolationOf2PointsRadian(vec2 center, vec2 target,
 }
 `
 
-export const circumferencePoints = `
-vec2 circumferencePoints(vec2 center, vec2 target, vec2 target2, float phase, float radius) {
+const circumferencePoints = `
+vec2 circumferencePoints(vec2 center, vec2 target, vec2 target2, float phase) {
     // Calculate vectors from center to target and target2
     vec2 v1 = target - center;
     vec2 v2 = target2 - center;
@@ -246,6 +246,17 @@ vec2 circumferencePoints(vec2 center, vec2 target, vec2 target2, float phase, fl
     vec2 result = vec2(cos(interpolatedAngle), sin(interpolatedAngle));
 
     // Scale back to the original circle radius and shift to center
-    return center + radius * result;
+    return center + length(target - center) * result;
+}
+`
+
+
+export const realDistanceOnSphereR1 = `
+float realDistanceOnSphereR1(vec2 longLat1, vec2 longLat2) {
+    float dLat = longLat2.y - longLat1.y;
+    float dLong = longLat2.x - longLat1.x;
+    float a = sin(dLat / 2.0) * sin(dLat / 2.0) + cos(longLat1.y) * cos(longLat2.y) * sin(dLong / 2.0) * sin(dLong / 2.0);
+    float c = 2.0 * atan(sqrt(a), sqrt(1.0 - a));
+    return c;
 }
-`
+`;

package/wind/plugin.js

@@ -700,7 +700,7 @@ export default class WindPlugin {
             if (depthTest) gl.disable(gl.DEPTH_TEST);
             // if (gl.disable(gl.STENCIL_TEST); // 
             this._draw();
-            // if (depthTest) gl.enable(gl.DEPTH_TEST); // TODO: stencil 
+            if (depthTest) gl.enable(gl.DEPTH_TEST);
 
         }
 

package/write-text/context-text.js

@@ -0,0 +1,86 @@
+import { CSZMode } from "@pirireis/webglobe";
+
+const defaultStyle = {
+    textFont: {
+        name: 'Arial',
+        textColor: '#FFFFFF', // beyaz
+        hollowColor: '#000000', // siyah
+        size: 12, // piksel
+        hollow: true,
+        bold: true,
+        italic: false,
+    },
+    opacity: 1.0,
+    zMode: CSZMode.Z_GROUND_PERVERTEX,
+}
+
+export class ContextTextWriter {
+    constructor(globe, { style = null } = {}) {
+        this.globe = globe;
+        this.itemMap = new Map();
+        this.style = style || defaultStyle;
+    }
+
+    setStyle(style) {
+        this.style = style;
+    }
+
+
+    draw() {
+        const { globe, style, itemMap } = this;
+        const { textFont, opacity } = style;
+        for (const [key, { lat, long, text }] of itemMap) {
+            const { x, y } = globe.api_GetScreenPointFromGeo(
+                {
+                    long: long,
+                    lat: lat,
+                    z: 0,
+                },
+                style.zMode === CSZMode.Z_MSL,
+            );
+
+            globe.api_DrawContextTextMultiLine(text, textFont, opacity, { x, y });
+        }
+    }
+
+
+    insertText(key, lat, long, text) {
+        this.itemMap.set(key, { lat, long, text });
+    }
+
+
+    updateText(key, text) {
+        const item = this.itemMap.get(key);
+        item.text = text;
+    }
+
+    updateCoords(key, lat, long) {
+        const item = this.itemMap.get(key);
+        item.lat = lat; item.long = long;
+    }
+
+
+    insertTextBulk(items) {
+        for (const item of items) {
+            this.itemMap.set(item.key, item);
+        }
+    }
+
+    updateTextCoordsBulk(items) {
+        for (const { key, lat, long } of items) {
+            const item = this.itemMap.get(key);
+            item.lat = lat; item.long = long;
+        }
+    }
+
+
+    deleteTextBulk(keys) {
+        for (const key of keys) {
+            this.itemMap.delete(key);
+        }
+    }
+
+    clear() {
+        this.itemMap.clear();
+    }
+}

package/write-text/index.js

@@ -0,0 +1 @@
+export { ContextTextWriter } from "./context-text";