@office-kit/xlsx 0.8.0

package/dist/styles/fills.d.ts

@@ -0,0 +1,54 @@
+import { type Color } from './colors';
+/** Predefined Excel pattern types. `'none'` lives here too as an explicit value. */
+export type PatternType = 'none' | 'solid' | 'darkDown' | 'darkGray' | 'darkGrid' | 'darkHorizontal' | 'darkTrellis' | 'darkUp' | 'darkVertical' | 'gray0625' | 'gray125' | 'lightDown' | 'lightGray' | 'lightGrid' | 'lightHorizontal' | 'lightTrellis' | 'lightUp' | 'lightVertical' | 'mediumGray';
+export declare const PATTERN_TYPES: ReadonlyArray<PatternType>;
+export interface PatternFill {
+    readonly kind: 'pattern';
+    readonly patternType?: PatternType;
+    readonly fgColor?: Color;
+    readonly bgColor?: Color;
+}
+export declare function makePatternFill(opts?: Partial<Omit<PatternFill, 'kind'>>): PatternFill;
+export interface GradientStop {
+    /** 0..1 ratio along the gradient. */
+    readonly position: number;
+    readonly color: Color;
+}
+export type GradientFillType = 'linear' | 'path';
+export interface GradientFill {
+    readonly kind: 'gradient';
+    readonly type: GradientFillType;
+    /** Rotation angle (degrees). Ignored when `type === 'path'`. */
+    readonly degree?: number;
+    /** path-mode insets (0..1 from each edge). */
+    readonly left?: number;
+    readonly right?: number;
+    readonly top?: number;
+    readonly bottom?: number;
+    /** Colour stops along the gradient. */
+    readonly stops: ReadonlyArray<GradientStop>;
+}
+export declare function makeGradientStop(position: number, color: Color | Partial<Color>): GradientStop;
+export declare function makeGradientFill(opts?: Partial<Omit<GradientFill, 'kind'>>): GradientFill;
+export type Fill = PatternFill | GradientFill;
+/**
+ * Single-arg constructor that defers to the variant-specific maker based on
+ * `kind`. Useful when the caller has a plain object in hand and wants the
+ * freeze invariant applied uniformly.
+ */
+export declare function makeFill(opts: Partial<PatternFill> | Partial<GradientFill>): Fill;
+/** The empty PatternFill — Excel's default cellXf[0] points here. */
+export declare const DEFAULT_EMPTY_FILL: Fill;
+/** The 'gray125' PatternFill — Excel's default cellXf[1]. */
+export declare const DEFAULT_GRAY_FILL: Fill;
+/**
+ * Translate a {@link Fill} to a CSS-property record suitable for HTML preview.
+ * `'solid'` PatternFill renders as `background-color`, other pattern types
+ * collapse to bgColor (CSS has no built-in equivalent of Excel hatch patterns).
+ * GradientFill emits a CSS `background-image` with `linear-gradient(<angle>,
+ * …)` for `type='linear'` or `radial-gradient(circle, …)` for `type='path'`.
+ *
+ * theme/auto colours and unresolvable inputs are skipped (returns `{}`) so
+ * callers can spread without overwriting upstream defaults.
+ */
+export declare function fillToCss(fill: Fill | undefined): Record<string, string>;

package/dist/styles/fills.schema.d.ts

@@ -0,0 +1,6 @@
+import { type XmlNode } from '../xml/tree';
+import { type Fill } from './fills';
+/** Build the `<fill>…</fill>` envelope around either variant. */
+export declare function fillToTree(fill: Fill): XmlNode;
+/** Inverse of {@link fillToTree}. Reads `<fill>` and dispatches on the child tag. */
+export declare function fillFromTree(node: XmlNode): Fill;

package/dist/styles/fonts.d.ts

@@ -0,0 +1,44 @@
+import { type Color } from './colors';
+/** Underline styles per openpyxl's NestedNoneSet. */
+export type UnderlineStyle = 'single' | 'double' | 'singleAccounting' | 'doubleAccounting';
+export declare const UNDERLINE_STYLES: ReadonlyArray<UnderlineStyle>;
+export type VertAlign = 'baseline' | 'superscript' | 'subscript';
+export declare const VERT_ALIGNS: ReadonlyArray<VertAlign>;
+export type FontScheme = 'major' | 'minor';
+export declare const FONT_SCHEMES: ReadonlyArray<FontScheme>;
+export interface Font {
+    readonly name?: string;
+    readonly charset?: number;
+    /** Font family code (0..14). */
+    readonly family?: number;
+    /** Point size; openpyxl name = `sz`. */
+    readonly size?: number;
+    readonly color?: Color;
+    readonly bold?: boolean;
+    readonly italic?: boolean;
+    readonly strike?: boolean;
+    readonly outline?: boolean;
+    readonly shadow?: boolean;
+    readonly condense?: boolean;
+    readonly extend?: boolean;
+    readonly underline?: UnderlineStyle;
+    readonly vertAlign?: VertAlign;
+    readonly scheme?: FontScheme;
+}
+export declare function makeFont(opts?: Partial<Font>): Font;
+/** Excel's default cell font: Calibri 11, minor scheme, theme=1 colour. */
+export declare const DEFAULT_FONT: Font;
+/**
+ * Translate a {@link Font} to a CSS-property record suitable for HTML
+ * rendering / preview. Boolean toggles map to weight/style/decoration,
+ * `size` becomes `font-size: <n>pt`, and an explicit rgb/indexed
+ * `color` is rendered as `#RRGGBB` (alpha dropped). theme/auto colours
+ * are skipped — callers without a theme can't resolve them.
+ *
+ * `vertAlign='superscript'|'subscript'` lowers `font-size` to 0.83em
+ * (W3C convention) and sets `vertical-align`.
+ *
+ * Returns `{}` for an empty Font so callers can spread it without
+ * overwriting upstream defaults.
+ */
+export declare function fontToCss(font: Font | undefined): Record<string, string>;

package/dist/styles/fonts.schema.d.ts

@@ -0,0 +1,3 @@
+import { type Schema } from '../schema/core';
+import type { Font } from './fonts';
+export declare const FontSchema: Schema<Font>;

package/dist/styles/index.d.ts

@@ -0,0 +1,21 @@
+export type { Alignment, HorizontalAlignment, VerticalAlignment } from './alignment';
+export { alignmentToCss, makeAlignment } from './alignment';
+export type { Border, Side, SideStyle } from './borders';
+export { borderToCss, makeBorder, makeSide } from './borders';
+export { alignCellHorizontal, alignCellVertical, applyBuiltinStyle, applyNamedStyle, cellStyleToCss, centerCell, clearCellBackground, clearCellStyle, clearRangeStyle, cloneCellStyle, copyCellStyle, formatAsHeader, indentCell, rotateCellText, setBold, setCellBackgroundColor, setFontColor, setFontName, setFontSize, setItalic, setStrikethrough, setUnderline, wrapCellText, getCellAlignment, getCellBorder, getCellFill, getCellFont, getCellNumberFormat, getCellProtection, setCellAlignment, setCellAsCurrency, setCellAsDate, setCellAsNumber, setCellAsPercent, setCellBorder, setCellBorderAll, setCellFill, setCellFont, setCellNumberFormat, setCellProtection, setCellStyle, setRangeBackgroundColor, setRangeBorderBox, setRangeFont, setRangeNumberFormat, setRangeAlignment, setRangeProtection, setRangeStyle, setRangeWrapText, } from './cell-style';
+export type { DifferentialStyle } from './differential';
+export { addDxf, makeDifferentialStyle } from './differential';
+export type { NamedStyle, StylesheetNamedStyle } from './named-styles';
+export { addNamedStyle, BUILTIN_NAMED_STYLES, ensureBuiltinStyle } from './named-styles';
+export type { Color } from './colors';
+export { adjustLightness, adjustSaturation, colorToHex, contrastRatio, darken, hexToHsl, hslToHex, lighten, luminance, makeColor, mixColors, normaliseRgb, pickReadableTextColor, resolveIndexedColor, rgbColor, rotateHue, } from './colors';
+export type { Fill, GradientFill, GradientFillType, GradientStop, PatternFill, PatternType } from './fills';
+export { fillToCss, makeFill, makeGradientFill, makeGradientStop, makePatternFill } from './fills';
+export type { Font, FontScheme, UnderlineStyle, VertAlign } from './fonts';
+export { DEFAULT_FONT, fontToCss, makeFont } from './fonts';
+export type { Protection } from './protection';
+export { makeProtection } from './protection';
+export type { CellXf, Stylesheet } from './stylesheet';
+export { addBorder, addCellStyleXf, addCellXf, addFill, addFont, addNumFmt, defaultCellXf, listBorders, listCellStyleXfs, listCellXfs, listFills, listFonts, makeStylesheet, } from './stylesheet';
+export type { NumberFormat } from './numbers';
+export { BUILTIN_FORMATS, BUILTIN_FORMATS_MAX_SIZE, builtinFormatCode, builtinFormatId, classifyDateFormat, FORMAT_DATE_DATETIME, FORMAT_DATE_TIMEDELTA, FORMAT_DATE_YYYYMMDD2, FORMAT_GENERAL, FORMAT_NUMBER, FORMAT_NUMBER_00, FORMAT_PERCENTAGE, FORMAT_PERCENTAGE_00, FORMAT_TEXT, isBuiltinFormat, isDateFormat, isTimedeltaFormat, makeNumberFormat, } from './numbers';

package/dist/styles/named-styles.d.ts

@@ -0,0 +1,52 @@
+import type { Alignment } from './alignment';
+import type { Border } from './borders';
+import type { Fill } from './fills';
+import type { Font } from './fonts';
+import { type Stylesheet } from './stylesheet';
+export interface NamedStyle {
+    readonly name: string;
+    /** OOXML built-in id (0..N); absent for user-defined styles. */
+    readonly builtinId?: number;
+    readonly customBuiltin?: boolean;
+    readonly hidden?: boolean;
+    readonly iLevel?: number;
+    readonly font?: Font;
+    readonly fill?: Fill;
+    readonly border?: Border;
+    readonly alignment?: Alignment;
+    readonly protection?: Protection;
+    readonly numberFormat?: string;
+}
+import type { Protection } from './protection';
+/**
+ * NamedStyle as it sits inside the Stylesheet (an `<cellStyles>` entry).
+ * Captures the resolved cellStyleXfs index so the writer can emit the
+ * `<cellStyle xfId="…" name="…" builtinId="…"/>` element directly.
+ */
+export interface StylesheetNamedStyle {
+    readonly name: string;
+    readonly xfId: number;
+    readonly builtinId?: number;
+    readonly customBuiltin?: boolean;
+    readonly hidden?: boolean;
+    readonly iLevel?: number;
+}
+/**
+ * Register a NamedStyle on the Stylesheet:
+ *  1. add Font / Fill / Border / NumberFormat to their pools
+ *  2. push a CellXf with apply* flags into cellStyleXfs
+ *  3. append a {name, xfId, builtinId} entry into the workbook's
+ *     namedStyles list (caller-managed; this function returns the
+ *     xfId so callers can connect the dots)
+ * Idempotent on (name): re-registering by the same name returns the
+ * cached xfId.
+ */
+export declare function addNamedStyle(ss: Stylesheet, style: NamedStyle): number;
+/** Curated subset of openpyxl's `styles` dict. Keys match the user-visible names. */
+export declare const BUILTIN_NAMED_STYLES: Readonly<Record<string, NamedStyle>>;
+/**
+ * Register a built-in style with the supplied Stylesheet (idempotent).
+ * Returns the cellStyleXfs index. Throws OpenXmlSchemaError when the
+ * name is unknown.
+ */
+export declare function ensureBuiltinStyle(ss: Stylesheet, name: keyof typeof BUILTIN_NAMED_STYLES | string): number;

package/dist/styles/numbers.d.ts

@@ -0,0 +1,39 @@
+/** Canonical OOXML built-in number formats — verbatim from openpyxl. */
+export declare const BUILTIN_FORMATS: Readonly<Record<number, string>>;
+/** First numFmtId Excel reserves for user-defined formats. */
+export declare const BUILTIN_FORMATS_MAX_SIZE = 164;
+export declare const FORMAT_GENERAL = "General";
+export declare const FORMAT_TEXT = "@";
+export declare const FORMAT_NUMBER = "0";
+export declare const FORMAT_NUMBER_00 = "0.00";
+export declare const FORMAT_PERCENTAGE = "0%";
+export declare const FORMAT_PERCENTAGE_00 = "0.00%";
+export declare const FORMAT_DATE_DATETIME = "yyyy-mm-dd h:mm:ss";
+export declare const FORMAT_DATE_TIMEDELTA = "[hh]:mm:ss";
+export declare const FORMAT_DATE_YYYYMMDD2 = "yyyy-mm-dd";
+/** Look up the format code for a given numFmtId, or `undefined` if unknown. */
+export declare function builtinFormatCode(id: number): string | undefined;
+/** Look up the numFmtId for a given format code, or `undefined` if not built-in. */
+export declare function builtinFormatId(code: string): number | undefined;
+/** True iff `code` is one of the OOXML built-in format strings. */
+export declare function isBuiltinFormat(code: string): boolean;
+/**
+ * Heuristic: does the format string imply a date / time interpretation?
+ * Looks at only the first format section (positive-value branch); strips
+ * literals, colour codes and locale modifiers before scanning for date
+ * tokens (d/m/h/y/s, case-insensitive) that aren't escaped.
+ */
+export declare function isDateFormat(code: string | undefined | null): boolean;
+/** Heuristic: does the format string indicate a duration ([h]:mm:ss etc.)? */
+export declare function isTimedeltaFormat(code: string | undefined | null): boolean;
+/** Categorise a date format as 'date', 'time', 'datetime' or undefined. */
+export declare function classifyDateFormat(code: string | undefined | null): 'date' | 'time' | 'datetime' | undefined;
+export interface NumberFormat {
+    /** Stylesheet-relative numFmtId. */
+    readonly numFmtId: number;
+    readonly formatCode: string;
+}
+export declare function makeNumberFormat(opts: {
+    numFmtId: number;
+    formatCode: string;
+}): NumberFormat;

package/dist/styles/numbers.schema.d.ts

@@ -0,0 +1,3 @@
+import { type Schema } from '../schema/core';
+import type { NumberFormat } from './numbers';
+export declare const NumberFormatSchema: Schema<NumberFormat>;

package/dist/styles/protection.d.ts

@@ -0,0 +1,9 @@
+export interface Protection {
+    /** When true (the default), the cell can't be edited if the sheet is locked. */
+    readonly locked?: boolean;
+    /** When true, the formula bar hides this cell's contents on a protected sheet. */
+    readonly hidden?: boolean;
+}
+export declare function makeProtection(opts?: Partial<Protection>): Protection;
+/** Excel's Stylesheet always contains an entry equal to {locked:true, hidden:false}. */
+export declare const DEFAULT_PROTECTION: Protection;

package/dist/styles/protection.schema.d.ts

@@ -0,0 +1,3 @@
+import { type Schema } from '../schema/core';
+import type { Protection } from './protection';
+export declare const ProtectionSchema: Schema<Protection>;

package/dist/styles/stylesheet-reader.d.ts

@@ -0,0 +1,7 @@
+import { type Stylesheet } from './stylesheet';
+/**
+ * Parse `xl/styles.xml` and return a fully-populated {@link Stylesheet}. Slot
+ * ordering is preserved verbatim; the dedup index Maps are rebuilt after the
+ * fact so future `addFont` / `addCellXf` calls keep working.
+ */
+export declare function parseStylesheetXml(bytes: Uint8Array | string): Stylesheet;

package/dist/styles/stylesheet-writer.d.ts

@@ -0,0 +1,3 @@
+import type { Stylesheet } from './stylesheet';
+/** Serialise a Stylesheet to its `xl/styles.xml` payload. */
+export declare function stylesheetToBytes(ss: Stylesheet): Uint8Array;

package/dist/styles/stylesheet.d.ts

@@ -0,0 +1,95 @@
+import type { Alignment } from './alignment';
+import type { Border } from './borders';
+import type { Fill } from './fills';
+import type { Font } from './fonts';
+import type { Protection } from './protection';
+/**
+ * One entry in the cellXfs / cellStyleXfs pool. Represents the union of
+ * indexes-into-other-pools that a cell or named style points at.
+ *
+ * Mirrors openpyxl's CellStyle (styles/cell_style.py). The TS port keeps it as
+ * a plain readonly object — no class, no methods. The Stylesheet `addCellXf`
+ * allocates the index; cells store only that.
+ */
+export interface CellXf {
+    readonly fontId: number;
+    readonly fillId: number;
+    readonly borderId: number;
+    readonly numFmtId: number;
+    /** Index into cellStyleXfs — only set for direct-cell xfs that point at a NamedStyle. */
+    readonly xfId?: number;
+    readonly alignment?: Alignment;
+    readonly protection?: Protection;
+    readonly applyFont?: boolean;
+    readonly applyFill?: boolean;
+    readonly applyBorder?: boolean;
+    readonly applyNumberFormat?: boolean;
+    readonly applyAlignment?: boolean;
+    readonly applyProtection?: boolean;
+    readonly pivotButton?: boolean;
+    readonly quotePrefix?: boolean;
+}
+export interface Stylesheet {
+    fonts: Font[];
+    fills: Fill[];
+    borders: Border[];
+    /** numFmtId → format code (custom IDs only; built-ins implicit). */
+    numFmts: Map<number, string>;
+    cellXfs: CellXf[];
+    cellStyleXfs: CellXf[];
+    /** Named styles (Excel's "Cell Styles" gallery; populated by addNamedStyle). */
+    namedStyles?: Array<import('./named-styles').StylesheetNamedStyle>;
+    _fontIdByKey: Map<string, number>;
+    _fillIdByKey: Map<string, number>;
+    _borderIdByKey: Map<string, number>;
+    _xfIdByKey: Map<string, number>;
+    _styleXfIdByKey: Map<string, number>;
+    _numFmtIdByCode: Map<string, number>;
+    _namedStyleByName?: Map<string, import('./named-styles').StylesheetNamedStyle>;
+}
+/**
+ * Build a fresh Stylesheet pre-populated with Excel's required default entries.
+ * Mirrors openpyxl's empty Stylesheet: fonts: [DEFAULT_FONT] (index 0) fills:
+ * [DEFAULT_EMPTY_FILL,
+ *             DEFAULT_GRAY_FILL]          (indices 0, 1 — required)
+ * borders: [DEFAULT_BORDER] (index 0) cellXfs: empty (indices allocated on
+ * demand)
+ */
+export declare function makeStylesheet(): Stylesheet;
+/** Add a Font to the pool, returning its 0-based index. Idempotent. */
+export declare function addFont(ss: Stylesheet, font: Font): number;
+/** Add a Fill to the pool, returning its 0-based index. Idempotent. */
+export declare function addFill(ss: Stylesheet, fill: Fill): number;
+/** Add a Border to the pool, returning its 0-based index. Idempotent. */
+export declare function addBorder(ss: Stylesheet, border: Border): number;
+/**
+ * Resolve a number-format string to its numFmtId.
+ * - Built-in codes return their canonical OOXML ID.
+ * - Otherwise the custom code is registered (and allocated an ID
+ * ≥ {@link BUILTIN_FORMATS_MAX_SIZE}). Idempotent.
+ */
+export declare function addNumFmt(ss: Stylesheet, formatCode: string): number;
+/** Add a CellXf to the cellXfs pool, returning its 0-based index. Idempotent. */
+export declare function addCellXf(ss: Stylesheet, xf: CellXf): number;
+/** Add a CellXf to the cellStyleXfs pool. Idempotent. */
+export declare function addCellStyleXf(ss: Stylesheet, xf: CellXf): number;
+/** Returns the currently registered numFmt entries (built-ins are implicit and not included). */
+export declare function getCustomNumFmts(ss: Stylesheet): ReadonlyArray<{
+    id: number;
+    code: string;
+}>;
+/** Read-only snapshot of every Font entry in the pool, indexed by id. */
+export declare function listFonts(ss: Stylesheet): ReadonlyArray<Font>;
+/** Read-only snapshot of every Fill entry in the pool, indexed by id. */
+export declare function listFills(ss: Stylesheet): ReadonlyArray<Fill>;
+/** Read-only snapshot of every Border entry in the pool, indexed by id. */
+export declare function listBorders(ss: Stylesheet): ReadonlyArray<Border>;
+/** Read-only snapshot of every CellXf entry in the cellXfs pool. */
+export declare function listCellXfs(ss: Stylesheet): ReadonlyArray<CellXf>;
+/** Read-only snapshot of every CellStyleXf entry (named-style xfs). */
+export declare function listCellStyleXfs(ss: Stylesheet): ReadonlyArray<CellXf>;
+/**
+ * Convenience: build the default `cellXfs[0]` Excel emits — points at the
+ * workbook's font 0 / fill 0 / border 0 / numFmtId 0 (General).
+ */
+export declare function defaultCellXf(): CellXf;

package/dist/styles.mjs

@@ -0,0 +1,4 @@
+import { an as hexToHsl, cn as luminance, dn as normaliseRgb, en as adjustLightness, fn as pickReadableTextColor, hn as rotateHue, in as darken, ln as makeColor, mn as rgbColor, nn as colorToHex, on as hslToHex, pn as resolveIndexedColor, rn as contrastRatio, sn as lighten, tn as adjustSaturation, un as mixColors } from "./worksheet-CmCNoIgD.mjs";
+import { $ as ensureBuiltinStyle, A as setCellFill, At as makeNumberFormat, B as setRangeBackgroundColor, Bt as makeGradientFill, C as setCellAsCurrency, Ct as FORMAT_TEXT, D as setCellBackgroundColor, Dt as isBuiltinFormat, E as setCellAsPercent, Et as classifyDateFormat, F as setFontColor, Ft as fontToCss, G as setRangeStyle, Gt as makeBorder, H as setRangeFont, Ht as makePatternFill, I as setFontName, It as makeFont, J as setUnderline, K as setRangeWrapText, Kt as makeSide, L as setFontSize, M as setCellNumberFormat, N as setCellProtection, O as setCellBorder, Ot as isDateFormat, P as setCellStyle, Q as addNamedStyle, R as setItalic, Rt as fillToCss, S as setCellAlignment, St as FORMAT_PERCENTAGE_00, T as setCellAsNumber, Tt as builtinFormatId, U as setRangeNumberFormat, V as setRangeBorderBox, Vt as makeGradientStop, W as setRangeProtection, Wt as borderToCss, X as makeProtection, Xt as makeAlignment, Y as wrapCellText, Yt as alignmentToCss, Z as BUILTIN_NAMED_STYLES, _ as getCellNumberFormat, _t as FORMAT_DATE_YYYYMMDD2, a as cellStyleToCss, at as addNumFmt, b as rotateCellText, bt as FORMAT_NUMBER_00, c as clearCellStyle, ct as listCellStyleXfs, d as copyCellStyle, dt as listFonts, et as addBorder, f as formatAsHeader, ft as makeStylesheet, g as getCellFont, gt as FORMAT_DATE_TIMEDELTA, h as getCellFill, ht as FORMAT_DATE_DATETIME, i as applyNamedStyle, it as addFont, j as setCellFont, jt as DEFAULT_FONT, k as setCellBorderAll, kt as isTimedeltaFormat, l as clearRangeStyle, lt as listCellXfs, m as getCellBorder, mt as BUILTIN_FORMATS_MAX_SIZE, n as alignCellVertical, nt as addCellXf, o as centerCell, ot as defaultCellXf, p as getCellAlignment, pt as BUILTIN_FORMATS, q as setStrikethrough, r as applyBuiltinStyle, rt as addFill, s as clearCellBackground, st as listBorders, t as alignCellHorizontal, tt as addCellStyleXf, u as cloneCellStyle, ut as listFills, v as getCellProtection, vt as FORMAT_GENERAL, w as setCellAsDate, wt as builtinFormatCode, x as setBold, xt as FORMAT_PERCENTAGE, y as indentCell, yt as FORMAT_NUMBER, z as setRangeAlignment, zt as makeFill } from "./cell-style-BEDjMX1y.mjs";
+import { r as makeDifferentialStyle, t as addDxf } from "./differential-D4dg-qtZ.mjs";
+export { BUILTIN_FORMATS, BUILTIN_FORMATS_MAX_SIZE, BUILTIN_NAMED_STYLES, DEFAULT_FONT, FORMAT_DATE_DATETIME, FORMAT_DATE_TIMEDELTA, FORMAT_DATE_YYYYMMDD2, FORMAT_GENERAL, FORMAT_NUMBER, FORMAT_NUMBER_00, FORMAT_PERCENTAGE, FORMAT_PERCENTAGE_00, FORMAT_TEXT, addBorder, addCellStyleXf, addCellXf, addDxf, addFill, addFont, addNamedStyle, addNumFmt, adjustLightness, adjustSaturation, alignCellHorizontal, alignCellVertical, alignmentToCss, applyBuiltinStyle, applyNamedStyle, borderToCss, builtinFormatCode, builtinFormatId, cellStyleToCss, centerCell, classifyDateFormat, clearCellBackground, clearCellStyle, clearRangeStyle, cloneCellStyle, colorToHex, contrastRatio, copyCellStyle, darken, defaultCellXf, ensureBuiltinStyle, fillToCss, fontToCss, formatAsHeader, getCellAlignment, getCellBorder, getCellFill, getCellFont, getCellNumberFormat, getCellProtection, hexToHsl, hslToHex, indentCell, isBuiltinFormat, isDateFormat, isTimedeltaFormat, lighten, listBorders, listCellStyleXfs, listCellXfs, listFills, listFonts, luminance, makeAlignment, makeBorder, makeColor, makeDifferentialStyle, makeFill, makeFont, makeGradientFill, makeGradientStop, makeNumberFormat, makePatternFill, makeProtection, makeSide, makeStylesheet, mixColors, normaliseRgb, pickReadableTextColor, resolveIndexedColor, rgbColor, rotateCellText, rotateHue, setBold, setCellAlignment, setCellAsCurrency, setCellAsDate, setCellAsNumber, setCellAsPercent, setCellBackgroundColor, setCellBorder, setCellBorderAll, setCellFill, setCellFont, setCellNumberFormat, setCellProtection, setCellStyle, setFontColor, setFontName, setFontSize, setItalic, setRangeAlignment, setRangeBackgroundColor, setRangeBorderBox, setRangeFont, setRangeNumberFormat, setRangeProtection, setRangeStyle, setRangeWrapText, setStrikethrough, setUnderline, wrapCellText };