@asciidoctor/core 3.0.3 → 4.0.0-alpha.1

package/types/table.d.ts

@@ -0,0 +1,231 @@
+export class Table extends AbstractBlock<string> {
+    constructor(parent: any, attributes: any);
+    rows: {
+        head: any[];
+        foot: any[];
+        body: any[];
+        /**
+         * Retrieve the rows grouped by section as a nested Array.
+         * @returns {Array<[string, Array]>}
+         */
+        bySection(): Array<[string, any[]]>;
+        toObject(): {
+            head: any[];
+            body: any[];
+            foot: any[];
+        };
+    };
+    columns: any[];
+    hasHeaderOption: boolean;
+}
+export namespace Table {
+    export { Rows };
+    export { Column };
+    export { Cell };
+    export { ParserContext };
+}
+import { AbstractBlock } from './abstract_block.js';
+import { AbstractNode } from './abstract_node.js';
+declare class Rows {
+    constructor(head?: any[], foot?: any[], body?: any[]);
+    head: any[];
+    foot: any[];
+    body: any[];
+    /**
+     * Retrieve the rows grouped by section as a nested Array.
+     * @returns {Array<[string, Array]>}
+     */
+    bySection(): Array<[string, any[]]>;
+    toObject(): {
+        head: any[];
+        body: any[];
+        foot: any[];
+    };
+}
+declare class Column extends AbstractNode {
+    constructor(table: any, index: any, attributes?: {});
+    style: any;
+    /** Alias for parent (always a Table). */
+    get table(): AbstractNode;
+    /**
+     * Get the parent table of this column.
+     * @returns {Table}
+     */
+    getTable(): Table;
+}
+/** @extends {AbstractBlock<string | string[]>} */
+declare class Cell extends AbstractBlock<string | string[]> {
+    static get DOUBLE_LF(): string;
+    /**
+     * Factory — create and fully initialize a Cell asynchronously.
+     * For AsciiDoc cells, parses the nested document.
+     *
+     * NOTE: _innerContent is NOT pre-computed here. Document.convert() will call
+     * _convertAsciiDocCells() after parse completes (so callouts are rewound and
+     * all cross-references from the parent document are already registered).
+     * @param {Table.Column} column
+     * @param {string} cellText
+     * @param {Object} [attributes={}]
+     * @param {Object} [opts={}]
+     * @returns {Promise<Table.Cell>}
+     */
+    static create(column: {
+        style: any;
+        /** Alias for parent (always a Table). */
+        get table(): AbstractNode;
+        isBlock(): boolean;
+        isInline(): boolean;
+        /**
+         * Get the parent table of this column.
+         * @returns {Table}
+         */
+        getTable(): Table;
+        document: Document;
+        context: string;
+        nodeName: string;
+        id: string;
+        attributes: any;
+        passthroughs: any[];
+        get parent(): AbstractNode;
+        set parent(parent: AbstractNode);
+        get role(): string | string[];
+        set role(names: string | string[]);
+        get roles(): any;
+        get converter(): object;
+        getAttribute(name: string, defaultValue?: any, fallbackName?: string | boolean | null): any;
+        hasAttribute(name: string, expectedValue?: any, fallbackName?: string | boolean | null): boolean;
+        setAttribute(name: string, value?: any, overwrite?: boolean): string | boolean | null;
+        isAttribute(name: any, expectedValue?: any): boolean;
+        removeAttribute(name: string): any;
+        hasOption(name: string): boolean;
+        setOption(name: string): void;
+        enabledOptions(): Set<string>;
+        updateAttributes(newAttributes: any): any;
+        hasRoleAttribute(expectedValue?: string | null): boolean;
+        hasRole(name: string): boolean;
+        addRole(name: string): boolean;
+        removeRole(name: string): boolean;
+        get reftext(): string | null;
+        precomputeReftext(): Promise<void>;
+        hasReftext(): boolean;
+        isReftext(): boolean;
+        iconUri(name: string): Promise<string>;
+        imageUri(targetImage: string, assetDirKey?: string): Promise<string>;
+        mediaUri(target: string, assetDirKey?: string): string;
+        generateDataUri(targetImage: string, assetDirKey?: string | null): Promise<string>;
+        generateDataUriFromUri(imageUri: string, cacheUri?: boolean): Promise<string>;
+        normalizeAssetPath(assetRef: string, assetName?: string, autocorrect?: boolean): string;
+        normalizeSystemPath(target: string, start?: string | null, jail?: string | null, opts?: any): string;
+        normalizeWebPath(target: string, start?: string | null, preserveUriTarget?: boolean): string;
+        readAsset(path: string, opts?: any): Promise<string | null>;
+        readContents(target: string, opts?: any): Promise<string | null>;
+        isUri(str: string): boolean;
+        readonly logger: any;
+        getLogger(): object;
+        getRole(): string | undefined;
+        setRole(...names: (string | string[])[]): string;
+        getRoles(): string[];
+        getAttributes(): any;
+        getDocument(): Document;
+        getParent(): AbstractNode | undefined;
+        setParent(parent: any): void;
+        getNodeName(): string;
+        getId(): string | undefined;
+        setId(id: string): void;
+        getContext(): string;
+        getConverter(): object;
+        getIconUri(name: string): Promise<string>;
+        getMediaUri(target: string, assetDirKey?: string): string;
+        getImageUri(targetImage: string, assetDirKey?: string | null): Promise<string>;
+        getReftext(): string | undefined;
+    }, cellText: string, attributes?: any, opts?: any): Promise<typeof Cell>;
+    constructor(column: any, cellText: any, attributes?: {}, opts?: {});
+    _cursor: any;
+    sourceLocation: any;
+    colspan: number;
+    rowspan: number;
+    style: any;
+    /** Alias for parent (always a Column). */
+    get column(): AbstractNode;
+    /** @returns {Promise<Table.Cell>} */
+    reinitialize(hasHeader: any): Promise<typeof Cell>;
+    _catalogInlineAnchor(cellText?: any, cursor?: any): void;
+    set text(val: string | null);
+    /**
+     * Get the text with substitutions applied.
+     * The result is pre-computed during Document.parse() via precomputeText().
+     * Falls back to the raw text if precomputeText() has not been called yet.
+     * @returns {string|null}
+     */
+    get text(): string | null;
+    /**
+     * Pre-compute the converted text asynchronously.
+     * Called during Document.parse() so the synchronous getter works during conversion.
+     * @returns {Promise<void>}
+     */
+    precomputeText(): Promise<void>;
+    lines(): any;
+    source(): any;
+    get innerDocument(): any;
+    get file(): any;
+    get lineno(): any;
+    /**
+     * Get the text with substitutions applied.
+     * @returns {string|null}
+     */
+    getText(): string | null;
+    /**
+     * Set the raw text of this cell.
+     * @param {string|null} val
+     */
+    setText(val: string | null): void;
+    /**
+     * Get the inner document for AsciiDoc-style cells.
+     * @returns {Document|null}
+     */
+    getInnerDocument(): Document | null;
+}
+declare class ParserContext {
+    static get FORMATS(): Set<string>;
+    static get DELIMITERS(): {
+        psv: (string | RegExp)[];
+        csv: (string | RegExp)[];
+        dsv: (string | RegExp)[];
+        tsv: (string | RegExp)[];
+        '!sv': (string | RegExp)[];
+    };
+    constructor(reader: any, table: any, attributes?: {});
+    _reader: any;
+    _startCursor: any;
+    table: any;
+    buffer: string;
+    format: unknown;
+    delimiter: any;
+    delimiterRe: any;
+    colcount: any;
+    _cellspecs: any[];
+    _cellOpen: boolean;
+    _activeRowspans: number[];
+    _columnVisits: number;
+    _currentRow: any[];
+    _linenum: number;
+    startsWith(line: any): any;
+    matchDelimiter(line: any): any;
+    skipPastDelimiter(pre: any): void;
+    skipPastEscapedDelimiter(pre: any): void;
+    bufferHasUnclosedQuotesInText(text: any, q?: string): boolean;
+    bufferHasUnclosedQuotes(append?: any, q?: string): boolean;
+    takeCellspec(): any;
+    pushCellspec(cellspec?: {}): void;
+    keepCellOpen(): void;
+    markCellClosed(): void;
+    isCellOpen(): boolean;
+    isCellClosed(): boolean;
+    closeOpenCell(nextCellspec?: {}): Promise<void>;
+    closeCell(eol?: boolean): Promise<void>;
+    closeTable(): void;
+    _activateRowspan(rowspan: any, colspan: any): void;
+    _endOfRow(): 0 | 1 | -1;
+    _advance(): void;
+}
+export {};

package/types/timings.d.ts

@@ -0,0 +1,25 @@
+export class Timings {
+    static create(): Timings;
+    _log: {};
+    _timers: {};
+    start(key: any): void;
+    record(key: any): void;
+    time(...keys: any[]): any;
+    read(): any;
+    parse(): any;
+    readParse(): any;
+    convert(): any;
+    readParseConvert(): any;
+    write(): any;
+    total(): any;
+    /**
+     * Print a summary report.
+     * @param {{ write?: (s: string) => void, log?: (s: string) => void }} [out=console] - Output sink.
+     * @param {string|null} [subject=null] - Optional label for the input file.
+     */
+    printReport(out?: {
+        write?: (s: string) => void;
+        log?: (s: string) => void;
+    }, subject?: string | null): void;
+    _now(): any;
+}

package/types/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "strict": false,
+    "types": ["node"]
+  },
+  "include": ["./**/*.d.ts"]
+}

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright (C) 2019 Dan Allen, Guillaume Grossetie, Anthonny Quérouil and the Asciidoctor Project
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.