ts-server-lib 0.0.48

package/ussd/providers/AirtelDRC.d.ts

@@ -0,0 +1,9 @@
+export declare function response(text: string, { response }: {
+    response: {
+        set: (key: string, val: string) => void;
+    };
+}): string;
+export declare function request(request: {
+    body?: Record<string, unknown>;
+}, response: Record<string, unknown>): Record<string, unknown>;
+export declare function text(prev: string | undefined, body: Record<string, unknown>): string;

package/ussd/providers/AirtelDRC.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+function response(text, { response }) {
+    const action = text.startsWith('CON ');
+    response.set('Freeflow', action ? 'FC' : 'FB');
+    text = text.replace(/CON\s|END\s/g, '');
+    return text;
+}
+function request(request, response) {
+    const body = (0, _1.body)(request);
+    response.type('text/html');
+    response.charset = 'UTF-8';
+    if (!String(body.MBILE_NUMBER ?? '').startsWith('+')) {
+        body.MBILE_NUMBER = '+' + String(body.MBILE_NUMBER);
+    }
+    if (Object.hasOwn(body, 'INPUT')) {
+        body.message = body.INPUT;
+    }
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.airteldrc]);
+    return request.body;
+}
+function text(prev = '', body) {
+    if (Object.hasOwn(body, 'message') && body.message !== body.serviceCode) {
+        prev += '*' + (0, _1.purify)(String(body.message ?? ''));
+    }
+    return prev;
+}

package/ussd/providers/OrangeDRC.d.ts

@@ -0,0 +1,5 @@
+export declare function response(text: string, _rr?: unknown): string;
+export declare function request(request: {
+    body?: Record<string, unknown>;
+}, response: Record<string, unknown>): Record<string, unknown>;
+export declare function text(prev: string | undefined, body: Record<string, unknown>): string;

package/ussd/providers/OrangeDRC.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+class OrangeTextUSSD {
+    text;
+    description;
+    attribute;
+    constructor() {
+        this.text = '';
+        this.description = String(Math.random().toFixed(9));
+        this.attribute = { nav: 'default' };
+    }
+    /**
+     * Append a line text without <br/>
+     * @param text
+     */
+    appendText(text) {
+        this.text += text;
+    }
+    /**
+     * Append a line text with <br/>
+     * @param text
+     */
+    appendLineText(text) {
+        this.text += '<br/>' + text;
+    }
+    /**
+     * define the text of page
+     * @param text
+     */
+    setText(text) {
+        this.text = text;
+    }
+    /**
+     * define the value of description of the page
+     * @param value
+     */
+    setPageDescription(value) {
+        this.description = value;
+    }
+    /**
+     * add a attribute in page header
+     * @param key
+     * @param value
+     */
+    setAttribute(key, value) {
+        this.attribute[key] = value;
+    }
+    /**
+     * remove a key in a header page
+     * @param key
+     */
+    removeAttribute(key) {
+        delete this.attribute[key];
+    }
+    /**
+     * get the value of the key in the header page
+     * @param key
+     * @return {*}
+     */
+    getAttribute(key) {
+        return this.attribute[key];
+    }
+    /**
+     * get all attributes values in a object
+     * @return {{count: boolean}|*}
+     */
+    getAllAttributes() {
+        return this.attribute;
+    }
+    /**
+     * generate a string of key and value
+     * @return {string}
+     * @private
+     */
+    __attributeToString() {
+        const attr = this.attribute;
+        let result = '';
+        for (const key in attr) {
+            if (Object.hasOwn(attr, key)) {
+                result += key + '=\'' + attr[key] + '\' ';
+            }
+        }
+        return result;
+    }
+    /**
+     * Generate the body of page
+     * @return {string|*}
+     * @protected
+     */
+    __toGenerateBody() {
+        return this.text;
+    }
+    /**
+     * generate the page
+     * @param body the body of page
+     * @return {string}
+     * @private
+     */
+    __toGeneratePage(body) {
+        let page = '<?xml version=\'1.0\' encoding=\'UTF-8\'?>';
+        page += '<!DOCTYPE pages SYSTEM \'cellflash-1.3.dtd\'>';
+        page += '<pages descr=\'' + this.description + '\'>';
+        page += '<page ' + this.__attributeToString() + '>';
+        page += body;
+        page += '</page></pages>';
+        return page;
+    }
+    /**
+     * generate the form
+     * @param text
+     * @param action
+     * @param name
+     * @return {string}
+     */
+    form(text = ' ', action = '', name = '_input') {
+        return '<form keywords=\'disable\' action=\'' + action + '\'><entry var=\'' + name + '\'><prompt>' + text + '</prompt></entry></form>';
+    }
+    /**
+     * generate a anchor
+     * @param key
+     * @param href
+     * @param text
+     * @return {string}
+     */
+    anchor(text = ' ', href, key) {
+        let attr = '';
+        if (key) {
+            attr += 'key=\'' + key + '\' ';
+        }
+        if (href) {
+            attr += 'href=\'' + href + '\'';
+        }
+        return '<a ' + attr + '>' + text + '</a>';
+    }
+    /**
+     * generate the page
+     * @return {string}
+     */
+    toXml() {
+        return this.__toGeneratePage(this.__toGenerateBody());
+    }
+    escapeXml(unsafe) {
+        return this.unEscapeXml(unsafe).replace(/[&<>'"]/g, c => {
+            if (c === '&')
+                return '&amp;';
+            if (c === '<')
+                return '&lt;';
+            if (c === '>')
+                return '&gt;';
+            if (c === '\'')
+                return '&apos;';
+            if (c === '"')
+                return '&quot;';
+            return c;
+        });
+    }
+    unEscapeXml(text) {
+        const entities = [
+            ['amp', '&'], ['apos', '\''], ['#x27', '\''], ['#x2F', '/'],
+            ['nbsp', ' '], ['#39', '\''], ['#47', '/'], ['lt', '<'], ['gt', '>'], ['quot', '"']
+        ];
+        for (let i = 0, max = entities.length; i < max; ++i) {
+            text = text.replace(new RegExp('&' + entities[i][0] + ';', 'g'), entities[i][1]);
+        }
+        return text;
+    }
+}
+function response(text, _rr) {
+    let action = 'request', oText;
+    const otu = new OrangeTextUSSD();
+    if (text.startsWith('END ')) {
+        otu.setAttribute('nav', 'end');
+        action = 'end';
+    }
+    oText = otu.escapeXml(text.replace(/CON\s|END\s/g, '')).replace(/\n/g, '<br />');
+    otu.setAttribute('volatile', true);
+    otu.setAttribute('menutext', 'notext');
+    otu.setAttribute('backtext', 'notext');
+    if (action !== 'end') {
+        oText += otu.form();
+    }
+    if (oText.match(/#0/g)) {
+        // outputText = outputText.replace('#0)', otu.anchor('#0)', '/?_input=#0'));
+    }
+    if (oText.match(/#1/g)) {
+        // outputText = outputText.replace('#1)', otu.anchor('#1)', '/?_input=#1'));
+    }
+    otu.setText(oText);
+    return otu.toXml();
+}
+function request(request, response) {
+    const body = (0, _1.body)(request);
+    response.type('application/xml');
+    response.charset = 'UTF-8';
+    if (!String(body['user-msisdn'] ?? '').startsWith('+')) {
+        body['user-msisdn'] = '+' + body['user-msisdn'];
+    }
+    if (Object.hasOwn(body, '_input')) {
+        body.message = body._input;
+    }
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.orangedrc]);
+    return request.body;
+}
+function text(prev = '', body) {
+    if (Object.hasOwn(body, 'message')) {
+        prev += '*' + (0, _1.purify)(String(body.message ?? ''));
+    }
+    return prev;
+}

package/ussd/providers/VodacomDRC.d.ts

@@ -0,0 +1,9 @@
+export declare function response(text: string, { request: { body } }: {
+    request: {
+        body: Record<string, unknown>;
+    };
+}): string;
+export declare function request(request: {
+    body?: Record<string, unknown>;
+}, response: Record<string, unknown>): Record<string, unknown>;
+export declare function text(prev: string | undefined, body: Record<string, unknown>): string;

package/ussd/providers/VodacomDRC.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.response = response;
+exports.request = request;
+exports.text = text;
+const _1 = require("./_");
+function response(text, { request: { body } }) {
+    let action = 'request';
+    if (text.startsWith('END ')) {
+        action = 'end';
+    }
+    text = text.replace(/CON\s|END\s/g, '');
+    text = '<?xml version="1.0" encoding="UTF-8" ?>' +
+        '<methodResponse><params><param><value><struct>' +
+        '<member><name>USSDResponseString</name><value><string>' + text + '</string></value></member>' +
+        '<member><name>action</name><value><string>' + action + '</string></value></member>' +
+        '<member><name>TransactionTime</name><value><dateTime.iso8601>' + body.transactionTime + '</dateTime.iso8601></value></member>' +
+        '<member><name>TransactionId</name><value><string>' + body.sessionId + '</string></value></member>' +
+        '</struct></value></param></params></methodResponse>';
+    return text;
+}
+function request(request, response) {
+    const body = (0, _1.body)(request);
+    response.type('text/xml');
+    response.charset = 'UTF-8';
+    const transTime = body.TransactionTime;
+    body.transactionTime = transTime?.['datetime.iso8601']?.[0];
+    if (!String(body.MSISDN ?? '').startsWith('+')) {
+        body.MSISDN = '+' + String(body.MSISDN);
+    }
+    delete body.TransactionTime;
+    request.body = (0, _1.mapArgs)(body, {
+        vodacom: 'provider',
+        TransactionId: 'sessionId',
+        USSDServiceCode: 'serviceCode',
+        MSISDN: 'phoneNumber',
+        networkCode: 'networkCode',
+        USSDRequestString: 'message'
+    });
+    request.body = (0, _1.mapArgs)(body, _1.providersMap[_1.TSUssdProviders.vodacomdrc]);
+    return request.body;
+}
+function text(prev = '', body) {
+    if (!/(null|fecofa)/i.test(String(body.message ?? ''))) {
+        prev += '*' + (0, _1.purify)(String(body.message ?? ''));
+    }
+    return prev;
+}

package/ussd/providers/_.d.ts

@@ -0,0 +1,55 @@
+export declare enum TSUssdProviders {
+    vodacomdrc = "vodacom",
+    orangedrc = "orange",
+    airteldrc = "airtel",
+    africastalking = "africastalking"
+}
+export declare function body(request: {
+    headers?: Record<string, unknown>;
+    body?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    params?: Record<string, unknown>;
+}): {
+    [x: string]: unknown;
+};
+export declare function mapArgs(args?: Record<string, unknown>, map?: Record<string, unknown>): Record<string, unknown>;
+export declare function purify(text?: string): string;
+export declare function provider({ headers, body, query }: {
+    headers?: Record<string, unknown>;
+    body?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+}): TSUssdProviders;
+export declare const providersMap: {
+    africastalking: {
+        africastalking: string;
+        sessionId: string;
+        serviceCode: string;
+        phoneNumber: string;
+        networkCode: string;
+        text: string;
+    };
+    vodacom: {
+        vodacom: string;
+        TransactionId: string;
+        USSDServiceCode: string;
+        MSISDN: string;
+        networkCode: string;
+        USSDRequestString: string;
+    };
+    orange: {
+        orange: string;
+        'user-session': string;
+        'user-imsi': string;
+        'user-msisdn': string;
+        networkCode: string;
+        'user-identity': string;
+    };
+    airtel: {
+        airtel: string;
+        MBILE_NUMBER: string;
+        USSDServiceCode: string;
+        SESSION_ID: string;
+        INPUT: string;
+        IMEI: string;
+    };
+};

package/ussd/providers/_.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providersMap = exports.TSUssdProviders = void 0;
+exports.body = body;
+exports.mapArgs = mapArgs;
+exports.purify = purify;
+exports.provider = provider;
+var TSUssdProviders;
+(function (TSUssdProviders) {
+    TSUssdProviders["vodacomdrc"] = "vodacom";
+    TSUssdProviders["orangedrc"] = "orange";
+    TSUssdProviders["airteldrc"] = "airtel";
+    TSUssdProviders["africastalking"] = "africastalking";
+})(TSUssdProviders || (exports.TSUssdProviders = TSUssdProviders = {}));
+function body(request) {
+    const { headers = {}, body = {}, query = {}, params = {} } = request;
+    return { ...headers, ...body, ...query, ...params };
+}
+function mapArgs(args = {}, map = {}) {
+    const results = { provider: map.provider };
+    for (const p in args) {
+        if (Object.hasOwn(args, p) && Object.hasOwn(map, p)) {
+            results[String(map[p])] = args[p];
+        }
+        else if (Object.hasOwn(args, p)) {
+            results[p] = args[p];
+        }
+    }
+    return results;
+}
+function purify(text = '') {
+    return text ? text.replace(/[^\w\s]/g, '') : '';
+}
+function provider({ headers = {}, body, query }) {
+    const h = headers;
+    if (body && typeof body === 'object' && 'methodcall' in body) {
+        return TSUssdProviders.vodacomdrc;
+    }
+    else if (h['user-session'] && h['user-msisdn']) {
+        return TSUssdProviders.orangedrc;
+    }
+    else if (query && typeof query === 'object' && 'MBILE_NUMBER' in query) {
+        return TSUssdProviders.airteldrc;
+    }
+    else if (body && typeof body === 'object' && 'text' in body) {
+        return TSUssdProviders.africastalking;
+    }
+    return TSUssdProviders.africastalking;
+}
+exports.providersMap = {
+    [TSUssdProviders.africastalking]: {
+        africastalking: 'provider',
+        sessionId: 'sessionId',
+        serviceCode: 'serviceCode',
+        phoneNumber: 'phoneNumber',
+        networkCode: 'networkCode',
+        text: 'message'
+    },
+    [TSUssdProviders.vodacomdrc]: {
+        vodacom: 'provider',
+        TransactionId: 'sessionId',
+        USSDServiceCode: 'serviceCode',
+        MSISDN: 'phoneNumber',
+        networkCode: 'networkCode',
+        USSDRequestString: 'message'
+    },
+    [TSUssdProviders.orangedrc]: {
+        orange: 'provider',
+        'user-session': 'sessionId',
+        'user-imsi': 'serviceCode',
+        'user-msisdn': 'phoneNumber',
+        networkCode: 'networkCode',
+        'user-identity': 'message'
+    },
+    [TSUssdProviders.airteldrc]: {
+        airtel: 'provider',
+        MBILE_NUMBER: 'phoneNumber',
+        USSDServiceCode: 'serviceCode',
+        SESSION_ID: 'sessionId',
+        INPUT: 'message',
+        IMEI: 'networkCode'
+    }
+};

package/ussd/providers/index.d.ts

@@ -0,0 +1,13 @@
+import * as africastalking from './AfricasTalking';
+import * as airteldrc from './AirtelDRC';
+import * as orangedrc from './OrangeDRC';
+import * as vodacomdrc from './VodacomDRC';
+import { TSUssdProviders } from './_';
+export * from './_';
+export declare const providers: {
+    vodacom: typeof vodacomdrc;
+    orange: typeof orangedrc;
+    airtel: typeof airteldrc;
+    africastalking: typeof africastalking;
+};
+export declare const providersAvailable: TSUssdProviders[];

package/ussd/providers/index.js

@@ -0,0 +1,56 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.providersAvailable = exports.providers = void 0;
+const africastalking = __importStar(require("./AfricasTalking"));
+const airteldrc = __importStar(require("./AirtelDRC"));
+const orangedrc = __importStar(require("./OrangeDRC"));
+const vodacomdrc = __importStar(require("./VodacomDRC"));
+const _1 = require("./_");
+__exportStar(require("./_"), exports);
+exports.providers = {
+    [_1.TSUssdProviders.vodacomdrc]: vodacomdrc,
+    [_1.TSUssdProviders.orangedrc]: orangedrc,
+    [_1.TSUssdProviders.airteldrc]: airteldrc,
+    [_1.TSUssdProviders.africastalking]: africastalking
+};
+exports.providersAvailable = [
+    _1.TSUssdProviders.vodacomdrc,
+    _1.TSUssdProviders.orangedrc,
+    _1.TSUssdProviders.airteldrc
+];

package/utils/TSFifo.d.ts

@@ -0,0 +1,109 @@
+/**
+ * TSFifo — O(1) FIFO queue. The canonical replacement for `array.shift()` and `array.splice(0, n)`.
+ *
+ * ### Why this exists as a primitive
+ *
+ * `shift()` re-indexes every remaining element, so draining a queue of N with `shift()` is O(N²). The
+ * cost arrives at exactly the worst moment: queues are only deep when the system is already stressed, so
+ * the drain gets more expensive the more there is to drain. That is a positive feedback loop, not a
+ * constant factor — the same shape as the O(N) in-flight scan that was removed from the sports feed's
+ * pressure signal for the same reason.
+ *
+ * ### Why it lives HERE, in ts-server-lib
+ *
+ * It started in core-service, which was one layer too high: {@link TSRQWPool}'s own task backlog — the
+ * FIFTH instance of this defect — could not use it, because core-service depends on ts-server-lib and not
+ * the reverse. Copying it down would have produced two implementations of a module whose entire purpose is
+ * being the only one. So it sits at the bottom layer and core-service re-exports it, leaving
+ * `import { TSFifo } from 'core-service'` working for every service-side caller.
+ *
+ * It had already been diagnosed and hand-fixed once (`sports-service` `capacity-pump.ts`, head pointer plus
+ * periodic compaction, with the reasoning written out) while four other queues kept their own shape:
+ *
+ *   - `feed/amqp/dispatch-admission.ts` — the admission gate's `hotQueue` / `moneyQueue`. Its own doc
+ *     records `hotQueued` reaching **683** with 24.2 s waits; releasing 683 waiters by `shift()` is ~233 K
+ *     element moves, on the money path, during a backlog.
+ *   - `feed/amqp/worker.ts` — `pendingOutcomePublishes`, an uncapped array drained `splice(0, 32)` at a
+ *     time, so each batch re-indexes everything still queued behind it.
+ *   - `resolvers/outcomes.ts` — a 64-cap subscriber backlog. Cheap at that size, but it is the site that
+ *     proves the point: its correct eviction is `'drop-oldest'`, the OPPOSITE of the admission queue's, and
+ *     that decision was previously an unexplained `queue.shift()` in a callback.
+ *   - `db/TSRQW.ts` `TSRQWPool.tasks` — the parse-pool backlog, right in the AMQP drain path. Inert while
+ *     the pool keeps up (`parseQueued ~0` measured) and quadratic exactly when it stops keeping up, which
+ *     is the moment a super-linear drain hurts most.
+ *
+ * Five queues, five shapes, one of them correct. That is what a per-site fix always converges to, so the
+ * shape is not the interesting part of this module — having exactly one of it is, and naming the overflow
+ * policy so the difference between those sites is a type rather than a comment.
+ *
+ * ALL FIVE now use this class; a sixth hand-rolled queue is the thing to reject in review.
+ *
+ * ### Design
+ *
+ * A head index makes `shift` O(1); the consumed prefix is reclaimed in one `splice` once it passes
+ * {@link TSFIFO_COMPACT_THRESHOLD}, which keeps the backing array from growing without bound while keeping
+ * amortised cost O(1). `maxSize` is optional and, when set, makes overflow an explicit, observable event
+ * rather than unbounded memory — a queue with no ceiling is a slower way to run out of RAM.
+ */
+/**
+ * Consumed slots tolerated before the backing array is compacted.
+ *
+ * Compaction is one O(size) `splice` amortised over that many O(1) shifts, so a larger value trades
+ * transient memory for fewer memmoves. 1024 matches the value `capacity-pump` arrived at empirically.
+ */
+export declare const TSFIFO_COMPACT_THRESHOLD = 1024;
+export interface TSFifoOptions {
+    /**
+     * Hard cap on queued items. Omit for unbounded (correct only when an upstream gate already bounds the
+     * producer — e.g. a dedup key set, where the ceiling is the key space and not the event rate).
+     */
+    maxSize?: number;
+    /**
+     * WHICH END to sacrifice when `maxSize` is reached. There is no safe default for this question, which is
+     * why it is a named option rather than a per-site `if`:
+     *
+     * - `'reject-new'` (default) — keep the queued items, refuse the arrival. Correct when order carries
+     *   meaning and the oldest entry is the one that has waited longest for its turn: an admission queue,
+     *   a heal backlog. `push` returns false and the caller MUST handle it.
+     * - `'drop-oldest'` — evict the head to make room. Correct for a LIVE stream, where a late consumer
+     *   wants current state and a replay of stale values is worse than a gap: an odds subscription.
+     *
+     * Getting this backwards is silent: both shapes "work", one just serves the wrong data.
+     */
+    overflow?: 'reject-new' | 'drop-oldest';
+    /** Compaction threshold override — see {@link TSFIFO_COMPACT_THRESHOLD}. */
+    compactThreshold?: number;
+}
+export declare class TSFifo<T> {
+    private items;
+    private head;
+    private peak;
+    private lost;
+    private readonly compactThreshold;
+    private readonly maxSize;
+    private readonly overflow;
+    constructor(opts?: TSFifoOptions);
+    /** Items currently queued. */
+    get size(): number;
+    /** Highest `size` observed since construction — the number a gauge should report. */
+    get peakSize(): number;
+    /**
+     * Items lost to `maxSize` — rejected arrivals under `'reject-new'`, evicted heads under `'drop-oldest'`.
+     * Non-zero means the cap is doing something and should be visible: a silent drop is how data loss hides.
+     */
+    get dropped(): number;
+    /**
+     * Append. Returns false only under `'reject-new'` overflow when the queue is full — nothing was
+     * enqueued. Under `'drop-oldest'` it always returns true, having evicted the head to make room.
+     */
+    push(item: T): boolean;
+    /** Remove and return the oldest item, or undefined when empty. O(1). */
+    shift(): T | undefined;
+    /** Oldest item without removing it, or undefined when empty. */
+    peek(): T | undefined;
+    /** Drain up to `max` items, oldest first. Amortised O(returned), never O(remaining). */
+    drain(max: number): T[];
+    /** Discard everything. Use on shutdown/reset paths. */
+    clear(): void;
+    private compactIfNeeded;
+}