cvdl-ts 1.0.11 → 1.0.13

package/dist/Elem.js

@@ -0,0 +1,302 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instantiate = exports.boundWidth = exports.break_lines = exports.justifiedLines = exports.fillFonts = exports.parseMarkdownItem = exports.scaleWidth = exports.withBackgroundColor = exports.withWidth = exports.withAlignment = exports.withMargin = exports.withFont = exports.withTextWidth = exports.withIsFill = exports.asRef = exports.withIsRef = exports.withUrl = exports.withItem = exports.from = exports.default_ = exports.copy = exports.elem = void 0;
+const Font = __importStar(require("./Font"));
+const _1 = require(".");
+const Row_1 = require("./Row");
+const Resume_1 = require("./Resume");
+const marked = __importStar(require("marked"));
+const ts_pattern_1 = require("ts-pattern");
+const Utils_1 = require("./Utils");
+function defaultSpanProps() {
+    return {
+        is_italic: false,
+        is_bold: false,
+        is_code: false,
+        is_link: false,
+    };
+}
+function elem(item, url, is_ref, is_fill, is_markdown, text_width, font, margin, alignment, width, background_color) {
+    return {
+        tag: "Elem",
+        item,
+        url,
+        is_ref,
+        is_fill,
+        is_markdown,
+        text_width,
+        font,
+        margin,
+        alignment,
+        width,
+        background_color,
+    };
+}
+exports.elem = elem;
+function copy(e) {
+    return { ...e };
+}
+exports.copy = copy;
+function default_() {
+    return {
+        tag: "Elem",
+        item: "",
+        url: null,
+        is_ref: false,
+        is_fill: false,
+        is_markdown: false,
+        text_width: _1.Width.default_(),
+        font: Font.default_(),
+        margin: _1.Margin.default_(),
+        alignment: _1.Alignment.default_(),
+        width: _1.Width.default_(),
+        background_color: "Transparent",
+    };
+}
+exports.default_ = default_;
+function from(w) {
+    return { ...default_(), ...w };
+}
+exports.from = from;
+function withItem(e, item) {
+    return { ...e, item };
+}
+exports.withItem = withItem;
+function withUrl(e, url) {
+    return { ...e, url };
+}
+exports.withUrl = withUrl;
+function withIsRef(e, is_ref) {
+    return { ...e, is_ref };
+}
+exports.withIsRef = withIsRef;
+function asRef(e) {
+    return withIsRef(e, true);
+}
+exports.asRef = asRef;
+function withIsFill(e, is_fill) {
+    return { ...e, is_fill };
+}
+exports.withIsFill = withIsFill;
+function withTextWidth(e, text_width) {
+    return { ...e, text_width };
+}
+exports.withTextWidth = withTextWidth;
+function withFont(e, font) {
+    return { ...e, font };
+}
+exports.withFont = withFont;
+function withMargin(e, margin) {
+    return { ...e, margin };
+}
+exports.withMargin = withMargin;
+function withAlignment(e, alignment) {
+    return { ...e, alignment };
+}
+exports.withAlignment = withAlignment;
+function withWidth(e, width) {
+    return { ...e, width };
+}
+exports.withWidth = withWidth;
+function withBackgroundColor(e, background_color) {
+    return { ...e, background_color };
+}
+exports.withBackgroundColor = withBackgroundColor;
+function scaleWidth(e, scale) {
+    return withWidth(e, _1.Width.scale(e.width, scale));
+}
+exports.scaleWidth = scaleWidth;
+function flatten(ts, sp) {
+    const spans = [];
+    for (const t of ts) {
+        spans.push(...flattenToken(t, sp));
+    }
+    return spans;
+}
+function flattenToken(t, sp) {
+    return (0, ts_pattern_1.match)(t)
+        .returnType()
+        .with({ type: "paragraph", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        // console.log("[paragraph]", tokens);
+        return flatten(tokens, sp);
+    })
+        .with({ type: "strong", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        // console.log("[strong]", tokens);
+        return flatten(tokens, { ...sp, is_bold: true });
+    })
+        .with({ type: "em", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        // console.log("[em]", tokens);
+        return flatten(tokens, { ...sp, is_italic: true });
+    })
+        .with({ type: "codespan", text: ts_pattern_1.P.select("text") }, ({ text }) => {
+        // console.log("[codespan]", text);
+        return [{ ...sp, is_code: true, text, link: null }];
+    })
+        .with({ type: "text", tokens: ts_pattern_1.P.select("tokens") }, ({ tokens }) => {
+        return flatten(tokens, sp);
+    })
+        .with({ type: "text", text: ts_pattern_1.P.select("text") }, ({ text }) => {
+        const result = [];
+        if (text.startsWith(" ")) {
+            result.push({ ...sp, text: " ", link: null });
+        }
+        result.push({ ...sp, text: text.trim(), link: null });
+        if (text.endsWith(" ")) {
+            result.push({ ...sp, text: " ", link: null });
+        }
+        else if (text.endsWith("\n")) {
+            result.push({ ...sp, text: "\n", link: null });
+        }
+        return result;
+    })
+        .otherwise((e) => {
+        // console.log(`Unknown token type: ${JSON.stringify(e)}`);
+        return [{ ...defaultSpanProps(), text: e.raw, link: null }];
+    });
+}
+function parseMarkdownItem(item) {
+    const spans = [];
+    for (const token of marked.lexer(item)) {
+        spans.push(...flatten([token], defaultSpanProps()));
+    }
+    return spans;
+}
+exports.parseMarkdownItem = parseMarkdownItem;
+function fillFonts(e, fonts) {
+    const simpleSpans = e.is_markdown ? parseMarkdownItem(e.item) : [{ ...defaultSpanProps(), text: e.item, font: e.font, link: null }];
+    const spans = [];
+    for (const span of simpleSpans) {
+        const font = e.is_markdown ? (0, Utils_1.with_)(e.font, ({
+            // style: span.is_italic ? "Italic" : "Normal",
+            weight: span.is_bold ? "Bold" : "Medium",
+        })) : e.font;
+        if (span.text === " " || span.text === "\n") {
+            const width = Font.get_width(font, span.text, fonts);
+            spans.push({ ...span, font, width });
+            continue;
+        }
+        span.text.split(/\s+/).forEach(word => {
+            const width = Font.get_width(font, word, fonts);
+            spans.push({ ...span, text: word, font, width });
+            spans.push({ ...span, text: " ", font, width: Font.get_width(font, " ", fonts) });
+        });
+    }
+    const text_width = spans.reduce((acc, span) => acc + span.width, 0);
+    if (e.is_fill) {
+        return (0, Utils_1.with_)(e, {
+            width: _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), text_width)),
+            text_width: _1.Width.absolute(text_width),
+            spans
+        });
+    }
+    else {
+        return (0, Utils_1.with_)(e, { text_width: _1.Width.absolute(text_width), spans });
+    }
+}
+exports.fillFonts = fillFonts;
+function justifiedLines(e, lines, font_dict) {
+    const rowLines = [];
+    for (const line of lines.slice(0, -1)) {
+        const words = line.item.split(/\s+/);
+        const r = (0, Row_1.row)([], line.margin, line.alignment, line.width, false, false);
+        words.forEach(word => {
+            const word_width = Font.get_width(e.font, word, font_dict);
+            r.elements.push(elem(word, null, false, false, false, _1.Width.absolute(word_width), this.font, _1.Margin.default_(), _1.Alignment.default_(), _1.Width.absolute(word_width), this.background_color));
+        });
+        rowLines.push(Row_1.row);
+    }
+    rowLines.push((0, Row_1.row)([withAlignment(lines[lines.length - 1], "Left")], lines[0].margin, "Left", lines[0].width, false, false));
+    return rowLines;
+}
+exports.justifiedLines = justifiedLines;
+function break_lines(e, font_dict) {
+    if (_1.Width.get_fixed_unchecked(e.text_width) <= _1.Width.get_fixed_unchecked(e.width)) {
+        return [e];
+    }
+    const lines = [];
+    // todo: I'm sure this implementation is pretty buggy. Note to future me, fix
+    // this.
+    const words = e.item.split(/\s+/);
+    const widths = words.map((word) => Font.get_width(e.font, word, font_dict));
+    const space_width = Font.get_width(e.font, " ", font_dict);
+    let start = 0;
+    let width = widths[0];
+    const max_width = _1.Width.get_fixed_unchecked(e.width);
+    for (let i = 1; i < words.length; i++) {
+        const candidate_width = width + space_width + widths[i];
+        if (candidate_width > max_width) {
+            const line = words.slice(start, i).join(" ");
+            const line_width = Font.get_width(e.font, line, font_dict);
+            lines.push(withTextWidth(withItem(e, line), _1.Width.absolute(line_width)));
+            start = i;
+            width = widths[i];
+        }
+        else {
+            width += space_width + widths[i];
+        }
+    }
+    const line = words.slice(start).join(" ");
+    const line_width = Font.get_width(e.font, line, font_dict);
+    lines.push(withTextWidth(withItem(e, line), _1.Width.absolute(line_width)));
+    if (e.alignment === "Justified") {
+        return justifiedLines(e, lines, font_dict);
+    }
+    return lines;
+}
+exports.break_lines = break_lines;
+function boundWidth(e, width) {
+    if (!_1.Width.is_fill(e.width)) {
+        return withIsFill(withWidth(e, _1.Width.absolute(Math.min(_1.Width.get_fixed_unchecked(e.width), width))), false);
+    }
+    else {
+        return withIsFill(withWidth(e, _1.Width.absolute(width)), true);
+    }
+}
+exports.boundWidth = boundWidth;
+function instantiate(e, section, fields) {
+    if (!e.is_ref) {
+        return e;
+    }
+    const itemType = fields.find(f => f.name === e.item);
+    console.log(`Found item type: ${JSON.stringify(itemType)}`);
+    if (itemType.type.tag === "MarkdownString") {
+        console.log(`Found markdown string: ${e.item}`);
+        e.is_markdown = true;
+    }
+    const text = section.get(e.item);
+    if (text === undefined) {
+        return withIsRef(withItem(e, ""), false);
+    }
+    else {
+        if (text.tag === "Url") {
+            return withIsRef(withUrl(withItem(e, text.value.text), text.value.url), false);
+        }
+        else {
+            return withIsRef(withItem(e, Resume_1.ItemContent.toString(text)), false);
+        }
+    }
+}
+exports.instantiate = instantiate;

package/dist/FileStorage.d.ts

@@ -4,11 +4,11 @@ import { DataSchema } from "./DataSchema";
 import { LayoutSchema } from "./LayoutSchema";
 import { ResumeLayout } from "./ResumeLayout";
 import { Storage } from "./Storage";
-import { Font } from "./Font";
+import * as Font from "./Font";
 export declare class FileStorage implements Storage {
     dir: string;
     constructor(dir: string);
-    load_font(font: Font): Promise<Buffer>;
+    load_font(font: Font.t): Promise<Buffer>;
     initiate_storage(): Promise<void>;
     list_resumes(): Promise<string[]>;
     list_data_schemas(): Promise<string[]>;

package/dist/FileStorage.js

@@ -1,5 +1,28 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-explicit-any */
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,13 +53,14 @@ const Resume_1 = require("./Resume");
 const DataSchema_1 = require("./DataSchema");
 const LayoutSchema_1 = require("./LayoutSchema");
 const ResumeLayout_1 = require("./ResumeLayout");
+const Font = __importStar(require("./Font"));
 class FileStorage {
     constructor(dir) {
         this.dir = "";
         this.dir = dir;
     }
     load_font(font) {
-        return Promise.resolve(fs_1.default.readFileSync(this.dir + font.full_name() + ".ttf"));
+        return Promise.resolve(fs_1.default.readFileSync(this.dir + Font.full_name(font) + ".ttf"));
     }
     initiate_storage() {
         // Create data_dir/resumes if it does not exist

package/dist/Font.d.ts

@@ -1,18 +1,19 @@
 import { FontDict } from "./AnyLayout";
-export declare class Font {
+export type t = {
     name: string;
     size: number;
     weight: FontWeight;
     style: FontStyle;
     source: FontSource;
-    constructor(name: string, size: number, weight: FontWeight, style: FontStyle, source: FontSource);
-    static fromJson(json: unknown): Font;
-    toJson(): unknown;
-    static default_(): Font;
-    full_name(): string;
-    get_width(text: string, fonts: FontDict): number;
-    get_height(fonts: FontDict): number;
-}
+};
+type Font = t;
+export declare function font(name: string, size: number, weight: FontWeight, style: FontStyle, source: FontSource): Font;
+export declare function fromJson(json: unknown): Font;
+export declare function default_(): Font;
+export declare function full_name(f: Font): string;
+export declare function get_width(f: Font, text: string, fonts: FontDict): number;
+export declare function get_height(f: Font, fonts: FontDict): number;
 export type FontSource = "Local" | "System" | "Remote";
 export type FontWeight = "Light" | "Medium" | "Bold";
 export type FontStyle = "Normal" | "Italic";
+export {};

package/dist/Font.js

@@ -1,47 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Font = void 0;
-class Font {
-    constructor(name, size, weight, style, source) {
-        this.name = name;
-        this.size = size;
-        this.weight = weight;
-        this.style = style;
-        this.source = source;
-    }
-    static fromJson(json) {
-        if (typeof json !== "object" || json === null) {
-            return Font.default_();
-        }
-        const name = ("name" in json) ? json.name : "Exo";
-        const size = ("size" in json) ? json.size : 12;
-        const weight = ("weight" in json) ? json.weight : "Medium";
-        const style = ("style" in json) ? json.style : "Normal";
-        const source = ("source" in json) ? json.source : "System";
-        return new Font(name, size, weight, style, source);
-    }
-    toJson() {
-        return {
-            name: this.name,
-            size: this.size,
-            weight: this.weight,
-            style: this.style,
-            source: this.source
-        };
-    }
-    static default_() {
-        return new Font("Exo", 12, "Medium", "Normal", "System");
-    }
-    full_name() {
-        return this.name + "-" + this.weight + (this.style === "Italic" ? "Italic" : "");
-    }
-    get_width(text, fonts) {
-        const font = fonts.get_font(this.full_name());
-        return (font.layout(text).glyphs.reduce((acc, glyph) => acc + glyph.advanceWidth, 0) / font.unitsPerEm) * this.size;
-    }
-    get_height(fonts) {
-        const font = fonts.get_font(this.full_name());
-        return (font.bbox.height / font.unitsPerEm) * this.size;
-    }
+exports.get_height = exports.get_width = exports.full_name = exports.default_ = exports.fromJson = exports.font = void 0;
+function font(name, size, weight, style, source) {
+    return {
+        name,
+        size,
+        weight,
+        style,
+        source,
+    };
 }
-exports.Font = Font;
+exports.font = font;
+function fromJson(json) {
+    return {
+        ...default_(),
+        name: json["name"],
+        size: json["size"],
+        weight: json["weight"],
+        style: json["style"],
+        source: json["source"],
+    };
+}
+exports.fromJson = fromJson;
+function default_() {
+    return {
+        name: "Exo",
+        size: 12,
+        weight: "Medium",
+        style: "Normal",
+        source: "System",
+    };
+}
+exports.default_ = default_;
+function full_name(f) {
+    return f.name + "-" + f.weight + (f.style === "Italic" ? "Italic" : "");
+}
+exports.full_name = full_name;
+function get_width(f, text, fonts) {
+    const font = fonts.get_font(full_name(f));
+    return (font.layout(text).glyphs.reduce((acc, glyph) => acc + glyph.advanceWidth, 0) / font.unitsPerEm) * f.size;
+}
+exports.get_width = get_width;
+function get_height(f, fonts) {
+    const font = fonts.get_font(full_name(f));
+    return (font.bbox.height / font.unitsPerEm) * f.size;
+}
+exports.get_height = get_height;

package/dist/Layout.d.ts

@@ -1,85 +1,56 @@
 import * as Margin from "./Margin";
 import * as Alignment from "./Alignment";
 import * as Width from "./Width";
-import { Font } from "./Font";
+import * as Font from "./Font";
 import { ItemContent } from "./Resume";
 import { Box } from "./Box";
-import { ElementBox, FontDict } from "./AnyLayout";
+import { FontDict } from "./AnyLayout";
 import { Point } from "./Point";
-export type ContainerType = Stack | Row;
-export type LayoutType = Stack | Row | Elem;
-export declare class SectionLayout {
-    inner: Stack | Row | Elem;
-    bounding_box: Box | null;
-    constructor(inner: Stack | Row | Elem);
-    copy(): SectionLayout;
-    static constrMap(tag: string): Stack | Row | Elem;
-    static empty(): SectionLayout;
-    static fromJson(json: unknown): SectionLayout;
-    toJson(): any;
-    width(): Width.t;
-    is_container(): boolean;
-    is_fill(): boolean;
-    is_ref(): boolean;
-    type_(): "Stack" | "Row" | "Elem";
-    tag_(): "Stack" | "FlexRow" | "FrozenRow" | "Ref" | "Text";
-    fonts(): Font[];
-    with_margin(margin: Margin.t): SectionLayout;
-    with_alignment(alignment: Alignment.t): SectionLayout;
-    with_width(width: Width.t): SectionLayout;
-    total_elements_width(): number;
-    is_instantiated(): boolean;
-    instantiate(section: Map<string, ItemContent>): SectionLayout;
-    static instantiate_ref_element(element: Elem, section: Map<string, ItemContent>): SectionLayout;
-    bound_width(width: number): SectionLayout;
-    scale_width(document_width: number): SectionLayout;
-    normalize(width: number, font_dict: FontDict): SectionLayout;
-    fill_fonts(font_dict: FontDict): SectionLayout;
-    break_lines(font_dict: FontDict): SectionLayout;
-    compute_boxes(font_dict: FontDict): [ElementBox, SectionLayout];
-    compute_textbox_positions(textbox_positions: [Box, Elem][], top_left: Point, font_dict: FontDict): number;
-}
-export declare class Stack {
-    tag: "Stack";
-    elements: SectionLayout[];
-    margin: Margin.t;
-    alignment: Alignment.t;
-    width: Width.t;
-    is_fill: boolean;
-    constructor(elements: SectionLayout[], margin?: Margin.t, alignment?: Alignment.t, width?: Width.t, is_fill?: boolean);
-    static stack(elements: SectionLayout[], margin?: Margin.t, alignment?: Alignment.t, width?: Width.t, is_fill?: boolean): SectionLayout;
-    copy(): Stack;
-    static default_(): Stack;
-    instantiate(section: Map<string, ItemContent>): Stack;
-    with_elements(elements: SectionLayout[]): Stack;
-    with_margin(margin: Margin.t): Stack;
-    with_alignment(alignment: Alignment.t): Stack;
-    with_width(width: Width.t): Stack;
-    bound_width(width: number): Stack;
-    scale_width(w: number): Stack;
-}
-export declare class Row {
-    tag: "Row";
-    elements: SectionLayout[];
-    margin: Margin.t;
-    alignment: Alignment.t;
-    width: Width.t;
-    is_frozen: boolean;
-    is_fill: boolean;
-    constructor(elements: SectionLayout[], is_frozen?: boolean, margin?: Margin.t, alignment?: Alignment.t, width?: Width.t, is_fill?: boolean);
-    static row(elements: SectionLayout[], is_frozen?: boolean, margin?: Margin.t, alignment?: Alignment.t, width?: Width.t, is_fill?: boolean): SectionLayout;
-    copy(): Row;
-    static default_(): Row;
-    instantiate(section: Map<string, ItemContent>): Row;
-    with_elements(elements: SectionLayout[]): Row;
-    with_margin(margin: Margin.t): Row;
-    with_alignment(alignment: Alignment.t): Row;
-    with_width(width: Width.t): Row;
-    elements_width(): number;
-    bound_width(width: number): Row;
-    scale_width(w: number): Row;
-    break_lines(font_dict: FontDict): Row[];
-}
+import * as Stack from "./Stack";
+import * as Row from "./Row";
+import * as Elem from "./Elem";
+import { Field } from "./DataSchema";
+export type Container = Stack.t | Row.t;
+export type t = Stack.t | Row.t | Elem.t;
+type Layout = t;
+export type RenderedStack = Stack.t & {
+    bounding_box: Box;
+    elements: RenderedLayout[];
+};
+export type RenderedRow = Row.t & {
+    bounding_box: Box;
+    elements: RenderedLayout[];
+};
+export type RenderedElem = Elem.t & {
+    bounding_box: Box;
+};
+export type RenderedLayout = RenderedStack | RenderedRow | RenderedElem;
+export declare function default_(tag: string): Stack.t | Row.t | Elem.t;
+export declare function empty(): Layout;
+export declare function fromJson(json: unknown): Layout;
+export declare function type_(l: Layout): string;
+export declare function tag_(l: Layout): string;
+export declare function toJson(l: Layout): unknown;
+export declare function isContainer(l: Layout): boolean;
+export declare function isFill(l: Layout): boolean;
+export declare function isRef(l: Layout): boolean;
+export declare function fonts(l: Layout): Font.t[];
+export declare function withMargin(l: Layout, margin: Margin.t): Layout;
+export declare function withAlignment(l: Layout, alignment: Alignment.t): Layout;
+export declare function withWidth(l: Layout, width: Width.t): Layout;
+export declare function totalElementsWidth(l: Layout): number;
+export declare function isInstantiated(l: Layout): boolean;
+export declare function instantiate(l: Layout, section: Map<string, ItemContent>, fields: Field.t[]): Layout;
+export declare function boundWidth(l: Layout, width: number): Layout;
+export declare function scaleWidth(l: Layout, document_width: number): Layout;
+export declare function normalize(l: Layout, width: number, font_dict: FontDict): Layout;
+export declare function fillFonts(l: Layout, font_dict: FontDict): Layout;
+export declare function breakLines(l: Layout, font_dict: FontDict): Layout;
+export declare function computeBoxes(l: Layout, font_dict: FontDict): RenderedLayout;
+export declare function computeTextboxPositions(l: Layout, top_left: Point, font_dict: FontDict): {
+    depth: number;
+    renderedLayout: RenderedLayout;
+};
 export type Color = "Transparent" | "Light Yellow" | "Light Brown" | "Light Green" | "Light Beige" | "Light Blue" | "Blue";
 export declare const ColorMap: {
     Transparent: string;
@@ -90,34 +61,4 @@ export declare const ColorMap: {
     "Light Blue": string;
     Blue: string;
 };
-export declare class Elem {
-    tag: "Elem";
-    item: string;
-    url: string | null;
-    is_ref: boolean;
-    is_fill: boolean;
-    text_width: Width.t;
-    font: Font;
-    margin: Margin.t;
-    alignment: Alignment.t;
-    width: Width.t;
-    background_color: Color;
-    constructor(item: string, url: string | null, is_ref: boolean, is_fill: boolean, text_width: Width.t, font: Font, margin: Margin.t, alignment: Alignment.t, width: Width.t, background_color: Color);
-    static elem(item: string, url: string | null, is_ref: boolean, is_fill: boolean, text_width: Width.t, font: Font, margin: Margin.t, alignment: Alignment.t, width: Width.t, background_color: Color): SectionLayout;
-    copy(): Elem;
-    static default_(): Elem;
-    with_item(item: string): Elem;
-    as_ref(): Elem;
-    with_font(font: Font): Elem;
-    with_url(url: string): Elem;
-    with_margin(margin: Margin.t): Elem;
-    with_alignment(alignment: Alignment.t): Elem;
-    with_width(width: Width.t): Elem;
-    with_text_width(text_width: Width.t): Elem;
-    with_is_fill(is_fill: boolean): Elem;
-    scale_width(w: number): Elem;
-    fill_fonts(fonts: FontDict): Elem;
-    justified_lines(lines: Elem[], font_dict: FontDict): Row[];
-    break_lines(font_dict: FontDict): LayoutType[];
-    bound_width(width: number): Elem;
-}
+export {};