@bilig/headless 0.1.28 → 0.1.29

package/dist/work-paper-types.d.ts

@@ -0,0 +1,267 @@
+import type { CellValue, LiteralInput, RecalcMetrics } from "@bilig/protocol";
+import type { EvaluationResult } from "@bilig/formula";
+export type RawCellContent = LiteralInput | string;
+export type WorkPaperContextValue = string | number | boolean | null | WorkPaperContextObject | readonly WorkPaperContextValue[];
+export interface WorkPaperContextObject {
+    [key: string]: WorkPaperContextValue;
+}
+export interface WorkPaperChooseAddressMappingPolicy {
+    mode: "dense" | "sparse";
+}
+export type WorkPaperSheet = readonly (readonly RawCellContent[])[];
+export type WorkPaperSheets = Record<string, WorkPaperSheet>;
+export interface WorkPaperCellAddress {
+    sheet: number;
+    col: number;
+    row: number;
+}
+export interface WorkPaperCellRange {
+    start: WorkPaperCellAddress;
+    end: WorkPaperCellAddress;
+}
+export interface WorkPaperAddressFormatOptions {
+    includeSheetName?: boolean;
+}
+export type WorkPaperAddressLike = WorkPaperCellAddress | WorkPaperCellRange;
+export type WorkPaperAxisInterval = readonly [start: number, count?: number];
+export type WorkPaperAxisSwapMapping = readonly [from: number, to: number];
+export interface WorkPaperSheetDimensions {
+    width: number;
+    height: number;
+}
+export type WorkPaperChange = WorkPaperCellChange | WorkPaperNamedExpressionChange;
+export interface WorkPaperCellChange {
+    kind: "cell";
+    address: WorkPaperCellAddress;
+    sheetName: string;
+    a1: string;
+    newValue: CellValue;
+}
+export interface WorkPaperNamedExpressionChange {
+    kind: "named-expression";
+    name: string;
+    scope?: number;
+    newValue: CellValue | CellValue[][];
+}
+export interface WorkPaperNamedExpression {
+    name: string;
+    expression: RawCellContent;
+    scope?: number;
+    options?: Record<string, string | number | boolean>;
+}
+export interface SerializedWorkPaperNamedExpression extends WorkPaperNamedExpression {
+}
+export interface WorkPaperSimpleDate {
+    year: number;
+    month: number;
+    day: number;
+}
+export interface WorkPaperSimpleTime {
+    hours: number;
+    minutes: number;
+    seconds: number;
+}
+export interface WorkPaperDateTime extends WorkPaperSimpleDate, WorkPaperSimpleTime {
+}
+export type WorkPaperParsedDateTime = WorkPaperSimpleDate | WorkPaperSimpleTime | WorkPaperDateTime;
+export type WorkPaperParseDateTime = (dateTimeString: string, dateFormat?: string, timeFormat?: string) => WorkPaperParsedDateTime | undefined;
+export type WorkPaperStringifyDateTime = (dateTime: WorkPaperDateTime, dateTimeFormat: string) => string | undefined;
+export type WorkPaperStringifyDuration = (time: WorkPaperSimpleTime, timeFormat: string) => string | undefined;
+export type WorkPaperFunctionArgumentType = "STRING" | "NUMBER" | "BOOLEAN" | "SCALAR" | "NOERROR" | "RANGE" | "INTEGER" | "COMPLEX" | "ANY";
+export interface WorkPaperFunctionArgument {
+    argumentType: WorkPaperFunctionArgumentType;
+    passSubtype?: boolean;
+    defaultValue?: unknown;
+    optionalArg?: boolean;
+    minValue?: number;
+    maxValue?: number;
+    lessThan?: number;
+    greaterThan?: number;
+}
+export interface WorkPaperFunctionMetadata {
+    method: string;
+    parameters?: WorkPaperFunctionArgument[];
+    repeatLastArgs?: number;
+    expandRanges?: boolean;
+    returnNumberType?: string;
+    sizeOfResultArrayMethod?: string;
+    isVolatile?: boolean;
+    isDependentOnSheetStructureChange?: boolean;
+    doesNotNeedArgumentsToBeComputed?: boolean;
+    enableArrayArithmeticForArguments?: boolean;
+    vectorizationForbidden?: boolean;
+}
+export interface WorkPaperFunctionPlugin {
+    implementedFunctions: Record<string, WorkPaperFunctionMetadata>;
+    aliases?: Record<string, string>;
+}
+export interface WorkPaperFunctionPluginDefinition extends WorkPaperFunctionPlugin {
+    id: string;
+    functions?: Record<string, (...args: CellValue[]) => EvaluationResult | CellValue>;
+}
+export type WorkPaperFunctionTranslationsPackage = Record<string, Record<string, string>>;
+export interface WorkPaperLanguagePackage {
+    readonly functions?: Record<string, string>;
+    readonly errors?: Record<string, string>;
+    readonly ui?: Record<string, string>;
+    readonly [key: string]: unknown;
+}
+export type WorkPaperLicenseKeyValidityState = "valid" | "invalid" | "expired" | "missing";
+export interface WorkPaperConfig {
+    accentSensitive?: boolean;
+    caseSensitive?: boolean;
+    caseFirst?: "upper" | "lower" | "false";
+    chooseAddressMappingPolicy?: WorkPaperChooseAddressMappingPolicy;
+    context?: WorkPaperContextValue;
+    currencySymbol?: string[];
+    dateFormats?: string[];
+    functionArgSeparator?: string;
+    decimalSeparator?: "." | ",";
+    evaluateNullToZero?: boolean;
+    functionPlugins?: WorkPaperFunctionPluginDefinition[];
+    ignorePunctuation?: boolean;
+    language?: string;
+    ignoreWhiteSpace?: "standard" | "any";
+    leapYear1900?: boolean;
+    licenseKey?: string;
+    localeLang?: string;
+    matchWholeCell?: boolean;
+    arrayColumnSeparator?: "," | ";";
+    arrayRowSeparator?: ";" | "|";
+    maxRows?: number;
+    maxColumns?: number;
+    nullDate?: {
+        year: number;
+        month: number;
+        day: number;
+    };
+    nullYear?: number;
+    parseDateTime?: WorkPaperParseDateTime;
+    precisionEpsilon?: number;
+    precisionRounding?: number;
+    stringifyDateTime?: WorkPaperStringifyDateTime;
+    stringifyDuration?: WorkPaperStringifyDuration;
+    smartRounding?: boolean;
+    thousandSeparator?: "" | "," | ".";
+    timeFormats?: string[];
+    useArrayArithmetic?: boolean;
+    useColumnIndex?: boolean;
+    useStats?: boolean;
+    undoLimit?: number;
+    useRegularExpressions?: boolean;
+    useWildcards?: boolean;
+}
+export interface WorkPaperDetailedEventMap {
+    sheetAdded: {
+        sheetId: number;
+        sheetName: string;
+    };
+    sheetRemoved: {
+        sheetId: number;
+        sheetName: string;
+        changes: WorkPaperChange[];
+    };
+    sheetRenamed: {
+        sheetId: number;
+        oldName: string;
+        newName: string;
+    };
+    namedExpressionAdded: {
+        name: string;
+        scope?: number;
+        changes: WorkPaperChange[];
+    };
+    namedExpressionRemoved: {
+        name: string;
+        scope?: number;
+        changes: WorkPaperChange[];
+    };
+    valuesUpdated: {
+        changes: WorkPaperChange[];
+    };
+    evaluationSuspended: {};
+    evaluationResumed: {
+        changes: WorkPaperChange[];
+    };
+}
+export interface WorkPaperEventMap {
+    sheetAdded: [sheetName: string];
+    sheetRemoved: [sheetName: string, changes: WorkPaperChange[]];
+    sheetRenamed: [oldName: string, newName: string];
+    namedExpressionAdded: [name: string, changes: WorkPaperChange[]];
+    namedExpressionRemoved: [name: string, changes: WorkPaperChange[]];
+    valuesUpdated: [changes: WorkPaperChange[]];
+    evaluationSuspended: [];
+    evaluationResumed: [changes: WorkPaperChange[]];
+}
+export type WorkPaperEventName = keyof WorkPaperEventMap;
+export type WorkPaperListener<EventName extends WorkPaperEventName> = (...args: WorkPaperEventMap[EventName]) => void;
+export type WorkPaperDetailedListener<EventName extends WorkPaperEventName> = (payload: WorkPaperDetailedEventMap[EventName]) => void;
+export type WorkPaperCellType = "EMPTY" | "VALUE" | "FORMULA" | "ARRAY";
+export type WorkPaperCellValueType = "EMPTY" | "NUMBER" | "STRING" | "BOOLEAN" | "ERROR";
+export type WorkPaperCellValueDetailedType = WorkPaperCellValueType | "DATE" | "TIME" | "DATETIME";
+export type WorkPaperDependencyRef = {
+    kind: "cell";
+    address: WorkPaperCellAddress;
+} | {
+    kind: "range";
+    range: WorkPaperCellRange;
+} | {
+    kind: "name";
+    name: string;
+};
+export interface WorkPaperStats {
+    batchDepth: number;
+    evaluationSuspended: boolean;
+    lastMetrics: RecalcMetrics;
+}
+export interface WorkPaperGraphAdapter {
+    getDependents(reference: WorkPaperAddressLike): WorkPaperDependencyRef[];
+    getPrecedents(reference: WorkPaperAddressLike): WorkPaperDependencyRef[];
+}
+export interface WorkPaperRangeMappingAdapter {
+    getValues(range: WorkPaperCellRange): CellValue[][];
+    getSerialized(range: WorkPaperCellRange): RawCellContent[][];
+}
+export interface WorkPaperArrayMappingAdapter {
+    isPartOfArray(address: WorkPaperCellAddress): boolean;
+    getFormula(address: WorkPaperCellAddress): string | undefined;
+}
+export interface WorkPaperSheetMappingAdapter {
+    getSheetName(sheetId: number): string | undefined;
+    getSheetId(name: string): number | undefined;
+    getSheetNames(): string[];
+    countSheets(): number;
+}
+export interface WorkPaperAddressMappingAdapter {
+    has(address: WorkPaperCellAddress): boolean;
+    getValue(address: WorkPaperCellAddress): CellValue;
+    getFormula(address: WorkPaperCellAddress): string | undefined;
+}
+export interface WorkPaperDependencyGraphAdapter {
+    getCellDependents(reference: WorkPaperAddressLike): WorkPaperDependencyRef[];
+    getCellPrecedents(reference: WorkPaperAddressLike): WorkPaperDependencyRef[];
+}
+export interface WorkPaperEvaluatorAdapter {
+    recalculate(): WorkPaperChange[];
+    calculateFormula(formula: string, scope?: number): CellValue | CellValue[][];
+}
+export interface WorkPaperColumnSearchAdapter {
+    find(sheetId: number, column: number, matcher: string | ((value: CellValue) => boolean)): WorkPaperCellAddress[];
+}
+export interface WorkPaperLazilyTransformingAstServiceAdapter {
+    normalizeFormula(formula: string): string;
+    validateFormula(formula: string): boolean;
+    getNamedExpressionsFromFormula(formula: string): string[];
+}
+export interface WorkPaperInternals {
+    graph: WorkPaperGraphAdapter;
+    rangeMapping: WorkPaperRangeMappingAdapter;
+    arrayMapping: WorkPaperArrayMappingAdapter;
+    sheetMapping: WorkPaperSheetMappingAdapter;
+    addressMapping: WorkPaperAddressMappingAdapter;
+    dependencyGraph: WorkPaperDependencyGraphAdapter;
+    evaluator: WorkPaperEvaluatorAdapter;
+    columnSearch: WorkPaperColumnSearchAdapter;
+    lazilyTransformingAstService: WorkPaperLazilyTransformingAstServiceAdapter;
+}

package/dist/work-paper-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=work-paper-types.js.map

package/dist/work-paper-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-paper-types.js","sourceRoot":"","sources":["../src/work-paper-types.ts"],"names":[],"mappings":""}

package/dist/work-paper.d.ts

@@ -1,48 +1,3 @@
-import { HeadlessWorkbook } from "./headless-workbook.js";
-import type { HeadlessAddressFormatOptions, HeadlessAddressLike, HeadlessArrayMappingAdapter, HeadlessAxisInterval, HeadlessAxisSwapMapping, HeadlessCellAddress, HeadlessCellChange, HeadlessCellRange, HeadlessCellType, HeadlessCellValueDetailedType, HeadlessCellValueType, HeadlessChange, HeadlessColumnSearchAdapter, HeadlessConfig, HeadlessDateTime, HeadlessDependencyGraphAdapter, HeadlessDependencyRef, HeadlessEvaluatorAdapter, HeadlessFunctionArgument, HeadlessFunctionArgumentType, HeadlessFunctionMetadata, HeadlessFunctionPlugin, HeadlessFunctionPluginDefinition, HeadlessFunctionTranslationsPackage, HeadlessGraphAdapter, HeadlessLanguagePackage, HeadlessLazilyTransformingAstServiceAdapter, HeadlessLicenseKeyValidityState, HeadlessNamedExpression, HeadlessNamedExpressionChange, HeadlessRangeMappingAdapter, HeadlessSheet, HeadlessSheetDimensions, HeadlessSheetMappingAdapter, HeadlessSheets, HeadlessStats, HeadlessWorkbookDetailedEventMap, HeadlessWorkbookDetailedListener, HeadlessWorkbookEventMap, HeadlessWorkbookEventName, HeadlessWorkbookInternals, HeadlessWorkbookListener, RawCellContent, SerializedHeadlessNamedExpression } from "./types.js";
-export declare const WorkPaper: typeof HeadlessWorkbook;
-export type WorkPaper = HeadlessWorkbook;
-export type WorkPaperConfig = HeadlessConfig;
-export type WorkPaperSheet = HeadlessSheet;
-export type WorkPaperSheets = HeadlessSheets;
-export type WorkPaperCellAddress = HeadlessCellAddress;
-export type WorkPaperCellRange = HeadlessCellRange;
-export type WorkPaperAddressLike = HeadlessAddressLike;
-export type WorkPaperAddressFormatOptions = HeadlessAddressFormatOptions;
-export type WorkPaperAxisInterval = HeadlessAxisInterval;
-export type WorkPaperAxisSwapMapping = HeadlessAxisSwapMapping;
-export type WorkPaperChange = HeadlessChange;
-export type WorkPaperCellChange = HeadlessCellChange;
-export type WorkPaperNamedExpressionChange = HeadlessNamedExpressionChange;
-export type WorkPaperNamedExpression = HeadlessNamedExpression;
-export type SerializedWorkPaperNamedExpression = SerializedHeadlessNamedExpression;
-export type WorkPaperFunctionArgumentType = HeadlessFunctionArgumentType;
-export type WorkPaperFunctionArgument = HeadlessFunctionArgument;
-export type WorkPaperFunctionMetadata = HeadlessFunctionMetadata;
-export type WorkPaperFunctionPlugin = HeadlessFunctionPlugin;
-export type WorkPaperFunctionPluginDefinition = HeadlessFunctionPluginDefinition;
-export type WorkPaperFunctionTranslationsPackage = HeadlessFunctionTranslationsPackage;
-export type WorkPaperLanguagePackage = HeadlessLanguagePackage;
-export type WorkPaperLicenseKeyValidityState = HeadlessLicenseKeyValidityState;
-export type WorkPaperEventMap = HeadlessWorkbookEventMap;
-export type WorkPaperDetailedEventMap = HeadlessWorkbookDetailedEventMap;
-export type WorkPaperEventName = HeadlessWorkbookEventName;
-export type WorkPaperListener<EventName extends WorkPaperEventName> = HeadlessWorkbookListener<EventName>;
-export type WorkPaperDetailedListener<EventName extends WorkPaperEventName> = HeadlessWorkbookDetailedListener<EventName>;
-export type WorkPaperCellType = HeadlessCellType;
-export type WorkPaperCellValueType = HeadlessCellValueType;
-export type WorkPaperCellValueDetailedType = HeadlessCellValueDetailedType;
-export type WorkPaperDependencyRef = HeadlessDependencyRef;
-export type WorkPaperDateTime = HeadlessDateTime;
-export type WorkPaperStats = HeadlessStats;
-export type WorkPaperGraphAdapter = HeadlessGraphAdapter;
-export type WorkPaperRangeMappingAdapter = HeadlessRangeMappingAdapter;
-export type WorkPaperArrayMappingAdapter = HeadlessArrayMappingAdapter;
-export type WorkPaperSheetMappingAdapter = HeadlessSheetMappingAdapter;
-export type WorkPaperDependencyGraphAdapter = HeadlessDependencyGraphAdapter;
-export type WorkPaperEvaluatorAdapter = HeadlessEvaluatorAdapter;
-export type WorkPaperColumnSearchAdapter = HeadlessColumnSearchAdapter;
-export type WorkPaperLazilyTransformingAstServiceAdapter = HeadlessLazilyTransformingAstServiceAdapter;
-export type WorkPaperInternals = HeadlessWorkbookInternals;
-export type WorkPaperSheetDimensions = HeadlessSheetDimensions;
-export type WorkPaperRawCellContent = RawCellContent;
+export { WorkPaper } from "./work-paper-runtime.js";
+export * from "./work-paper-errors.js";
+export * from "./work-paper-types.js";

package/dist/work-paper.js

@@ -1,3 +1,4 @@
-import { HeadlessWorkbook } from "./headless-workbook.js";
-export const WorkPaper = HeadlessWorkbook;
+export { WorkPaper } from "./work-paper-runtime.js";
+export * from "./work-paper-errors.js";
+export * from "./work-paper-types.js";
 //# sourceMappingURL=work-paper.js.map

package/dist/work-paper.js.map

@@ -1 +1 @@
-{"version":3,"file":"work-paper.js","sourceRoot":"","sources":["../src/work-paper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAgD1D,MAAM,CAAC,MAAM,SAAS,GAAG,gBAAgB,CAAC"}
+{"version":3,"file":"work-paper.js","sourceRoot":"","sources":["../src/work-paper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bilig/headless",
-  "version": "0.1.28",
-  "description": "Headless spreadsheet workbook facade for bilig with HyperFormula-style workflows.",
+  "version": "0.1.29",
+  "description": "WorkPaper spreadsheet workbook facade for bilig with HyperFormula-style workflows.",
   "keywords": [
     "bilig",
     "formula",
@@ -38,12 +38,12 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json"
+    "build": "rm -rf dist tsconfig.tsbuildinfo && tsc -p tsconfig.json"
   },
   "dependencies": {
-    "@bilig/core": "0.1.28",
-    "@bilig/formula": "0.1.28",
-    "@bilig/protocol": "0.1.28"
+    "@bilig/core": "0.1.29",
+    "@bilig/formula": "0.1.29",
+    "@bilig/protocol": "0.1.29"
   },
   "engines": {
     "node": ">=24.0.0"

package/dist/errors.d.ts

@@ -1,112 +0,0 @@
-import type { HeadlessCellAddress } from "./types.js";
-declare class BaseHeadlessError extends Error {
-    constructor(name: string, message: string);
-}
-export declare class ConfigValueTooBigError extends BaseHeadlessError {
-    constructor(paramName: string, maximum: number);
-}
-export declare class ConfigValueTooSmallError extends BaseHeadlessError {
-    constructor(paramName: string, minimum: number);
-}
-export declare class EvaluationSuspendedError extends BaseHeadlessError {
-    constructor(message?: string);
-}
-export declare class ExpectedOneOfValuesError extends BaseHeadlessError {
-    constructor(values: string, paramName: string);
-}
-export declare class ExpectedValueOfTypeError extends BaseHeadlessError {
-    constructor(expectedType: string, paramName: string);
-}
-export declare class FunctionPluginValidationError extends BaseHeadlessError {
-    constructor(message: string);
-    static functionNotDeclaredInPlugin(functionId: string, pluginName: string): FunctionPluginValidationError;
-    static functionMethodNotFound(functionName: string, pluginName: string): FunctionPluginValidationError;
-}
-export declare class InvalidAddressError extends BaseHeadlessError {
-    constructor(address: HeadlessCellAddress);
-}
-export declare class InvalidArgumentsError extends BaseHeadlessError {
-    constructor(expectedArguments: string);
-}
-export declare class LanguageAlreadyRegisteredError extends BaseHeadlessError {
-    constructor(languageCode?: string);
-}
-export declare class LanguageNotRegisteredError extends BaseHeadlessError {
-    constructor(languageCode?: string);
-}
-export declare class MissingTranslationError extends BaseHeadlessError {
-    constructor(key: string);
-}
-export declare class NamedExpressionDoesNotExistError extends BaseHeadlessError {
-    constructor(expressionName: string);
-}
-export declare class NamedExpressionNameIsAlreadyTakenError extends BaseHeadlessError {
-    constructor(expressionName: string);
-}
-export declare class NamedExpressionNameIsInvalidError extends BaseHeadlessError {
-    constructor(expressionName: string);
-}
-export declare class NoOperationToRedoError extends BaseHeadlessError {
-    constructor();
-}
-export declare class NoOperationToUndoError extends BaseHeadlessError {
-    constructor();
-}
-export declare class NoRelativeAddressesAllowedError extends BaseHeadlessError {
-    constructor();
-}
-export declare class NoSheetWithIdError extends BaseHeadlessError {
-    constructor(sheetId: number);
-}
-export declare class NoSheetWithNameError extends BaseHeadlessError {
-    constructor(sheetName: string);
-}
-export declare class NotAFormulaError extends BaseHeadlessError {
-    constructor();
-}
-export declare class NothingToPasteError extends BaseHeadlessError {
-    constructor();
-}
-export declare class ProtectedFunctionTranslationError extends BaseHeadlessError {
-    constructor(functionId: string);
-}
-export declare class SheetNameAlreadyTakenError extends BaseHeadlessError {
-    constructor(sheetName: string);
-}
-export declare class SheetSizeLimitExceededError extends BaseHeadlessError {
-    constructor();
-}
-export declare class SourceLocationHasArrayError extends BaseHeadlessError {
-    constructor();
-}
-export declare class TargetLocationHasArrayError extends BaseHeadlessError {
-    constructor();
-}
-export declare class UnableToParseError extends BaseHeadlessError {
-    constructor(value: unknown);
-}
-export declare class HeadlessArgumentError extends InvalidArgumentsError {
-    constructor(expectedArguments: string);
-}
-export declare class HeadlessConfigError extends BaseHeadlessError {
-    constructor(message: string);
-}
-export declare class HeadlessSheetError extends BaseHeadlessError {
-    constructor(message: string);
-}
-export declare class HeadlessNamedExpressionError extends BaseHeadlessError {
-    constructor(message: string);
-}
-export declare class HeadlessClipboardError extends BaseHeadlessError {
-    constructor(message: string);
-}
-export declare class HeadlessEvaluationSuspendedError extends EvaluationSuspendedError {
-    constructor(message?: string);
-}
-export declare class HeadlessParseError extends BaseHeadlessError {
-    constructor(message: string);
-}
-export declare class HeadlessOperationError extends BaseHeadlessError {
-    constructor(message: string);
-}
-export {};

package/dist/errors.js

@@ -1,206 +0,0 @@
-class BaseHeadlessError extends Error {
-    constructor(name, message) {
-        super(message);
-        this.name = name;
-    }
-}
-export class ConfigValueTooBigError extends BaseHeadlessError {
-    constructor(paramName, maximum) {
-        super("ConfigValueTooBigError", `Config parameter ${paramName} should be at most ${maximum}`);
-    }
-}
-export class ConfigValueTooSmallError extends BaseHeadlessError {
-    constructor(paramName, minimum) {
-        super("ConfigValueTooSmallError", `Config parameter ${paramName} should be at least ${minimum}`);
-    }
-}
-export class EvaluationSuspendedError extends BaseHeadlessError {
-    constructor(message = "Computations are suspended") {
-        super("EvaluationSuspendedError", message);
-    }
-}
-export class ExpectedOneOfValuesError extends BaseHeadlessError {
-    constructor(values, paramName) {
-        super("ExpectedOneOfValuesError", `Expected one of ${values} for config parameter: ${paramName}`);
-    }
-}
-export class ExpectedValueOfTypeError extends BaseHeadlessError {
-    constructor(expectedType, paramName) {
-        super("ExpectedValueOfTypeError", `Expected value of type: ${expectedType} for config parameter: ${paramName}`);
-    }
-}
-export class FunctionPluginValidationError extends BaseHeadlessError {
-    constructor(message) {
-        super("FunctionPluginValidationError", message);
-    }
-    static functionNotDeclaredInPlugin(functionId, pluginName) {
-        return new FunctionPluginValidationError(`Function with id ${functionId} not declared in plugin ${pluginName}`);
-    }
-    static functionMethodNotFound(functionName, pluginName) {
-        return new FunctionPluginValidationError(`Function method ${functionName} not found in plugin ${pluginName}`);
-    }
-}
-export class InvalidAddressError extends BaseHeadlessError {
-    constructor(address) {
-        super("InvalidAddressError", `Address (row = ${address.row}, col = ${address.col}) is invalid`);
-    }
-}
-export class InvalidArgumentsError extends BaseHeadlessError {
-    constructor(expectedArguments) {
-        super("InvalidArgumentsError", `Invalid arguments, expected ${expectedArguments}`);
-    }
-}
-export class LanguageAlreadyRegisteredError extends BaseHeadlessError {
-    constructor(languageCode) {
-        super("LanguageAlreadyRegisteredError", languageCode
-            ? `Language '${languageCode}' is already registered`
-            : "Language already registered.");
-    }
-}
-export class LanguageNotRegisteredError extends BaseHeadlessError {
-    constructor(languageCode) {
-        super("LanguageNotRegisteredError", languageCode ? `Language '${languageCode}' is not registered` : "Language not registered.");
-    }
-}
-export class MissingTranslationError extends BaseHeadlessError {
-    constructor(key) {
-        super("MissingTranslationError", `Translation for ${key} is missing in the translation package you're using.`);
-    }
-}
-export class NamedExpressionDoesNotExistError extends BaseHeadlessError {
-    constructor(expressionName) {
-        super("NamedExpressionDoesNotExistError", `Named Expression '${expressionName}' does not exist`);
-    }
-}
-export class NamedExpressionNameIsAlreadyTakenError extends BaseHeadlessError {
-    constructor(expressionName) {
-        super("NamedExpressionNameIsAlreadyTakenError", `Name of Named Expression '${expressionName}' is already present`);
-    }
-}
-export class NamedExpressionNameIsInvalidError extends BaseHeadlessError {
-    constructor(expressionName) {
-        super("NamedExpressionNameIsInvalidError", `Name of Named Expression '${expressionName}' is invalid`);
-    }
-}
-export class NoOperationToRedoError extends BaseHeadlessError {
-    constructor() {
-        super("NoOperationToRedoError", "There is no operation to redo");
-    }
-}
-export class NoOperationToUndoError extends BaseHeadlessError {
-    constructor() {
-        super("NoOperationToUndoError", "There is no operation to undo");
-    }
-}
-export class NoRelativeAddressesAllowedError extends BaseHeadlessError {
-    constructor() {
-        super("NoRelativeAddressesAllowedError", "Relative addresses not allowed in named expressions.");
-    }
-}
-export class NoSheetWithIdError extends BaseHeadlessError {
-    constructor(sheetId) {
-        super("NoSheetWithIdError", `There's no sheet with id = ${sheetId}`);
-    }
-}
-export class NoSheetWithNameError extends BaseHeadlessError {
-    constructor(sheetName) {
-        super("NoSheetWithNameError", `There's no sheet with name '${sheetName}'`);
-    }
-}
-export class NotAFormulaError extends BaseHeadlessError {
-    constructor() {
-        super("NotAFormulaError", "This is not a formula");
-    }
-}
-export class NothingToPasteError extends BaseHeadlessError {
-    constructor() {
-        super("NothingToPasteError", "There is nothing to paste");
-    }
-}
-export class ProtectedFunctionTranslationError extends BaseHeadlessError {
-    constructor(functionId) {
-        super("ProtectedFunctionTranslationError", `Cannot register translation for function with id: ${functionId}`);
-    }
-}
-export class SheetNameAlreadyTakenError extends BaseHeadlessError {
-    constructor(sheetName) {
-        super("SheetNameAlreadyTakenError", `Sheet with name ${sheetName} already exists`);
-    }
-}
-export class SheetSizeLimitExceededError extends BaseHeadlessError {
-    constructor() {
-        super("SheetSizeLimitExceededError", "Sheet size limit exceeded");
-    }
-}
-export class SourceLocationHasArrayError extends BaseHeadlessError {
-    constructor() {
-        super("SourceLocationHasArrayError", "Cannot perform this operation, source location has an array inside.");
-    }
-}
-export class TargetLocationHasArrayError extends BaseHeadlessError {
-    constructor() {
-        super("TargetLocationHasArrayError", "Cannot perform this operation, target location has an array inside.");
-    }
-}
-function serializeParseValue(value) {
-    return JSON.stringify(value, (_key, current) => {
-        if (typeof current === "function" || typeof current === "symbol") {
-            return String(current);
-        }
-        if (typeof current === "bigint") {
-            return `BigInt(${current.toString()})`;
-        }
-        if (current instanceof RegExp) {
-            return `RegExp(${current.toString()})`;
-        }
-        return current;
-    }, 4);
-}
-export class UnableToParseError extends BaseHeadlessError {
-    constructor(value) {
-        super("UnableToParseError", `Unable to parse value: ${serializeParseValue(value)}`);
-    }
-}
-export class HeadlessArgumentError extends InvalidArgumentsError {
-    constructor(expectedArguments) {
-        super(expectedArguments);
-        this.name = "HeadlessArgumentError";
-    }
-}
-export class HeadlessConfigError extends BaseHeadlessError {
-    constructor(message) {
-        super("HeadlessConfigError", message);
-    }
-}
-export class HeadlessSheetError extends BaseHeadlessError {
-    constructor(message) {
-        super("HeadlessSheetError", message);
-    }
-}
-export class HeadlessNamedExpressionError extends BaseHeadlessError {
-    constructor(message) {
-        super("HeadlessNamedExpressionError", message);
-    }
-}
-export class HeadlessClipboardError extends BaseHeadlessError {
-    constructor(message) {
-        super("HeadlessClipboardError", message);
-    }
-}
-export class HeadlessEvaluationSuspendedError extends EvaluationSuspendedError {
-    constructor(message = "Computations are suspended") {
-        super(message);
-        this.name = "HeadlessEvaluationSuspendedError";
-    }
-}
-export class HeadlessParseError extends BaseHeadlessError {
-    constructor(message) {
-        super("HeadlessParseError", message);
-    }
-}
-export class HeadlessOperationError extends BaseHeadlessError {
-    constructor(message) {
-        super("HeadlessOperationError", message);
-    }
-}
-//# sourceMappingURL=errors.js.map