df-script 1.4.0 → 1.6.0

package/dist/datatypes/types.js

@@ -1,286 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Struct = exports.StructType = exports.List = exports.ListType = exports.Duration = exports.DurationType = exports.Time = exports.TimeType = exports.Datetime = exports.DatetimeType = exports.Date = exports.DateType = exports.Object = exports.ObjectType = exports.Null = exports.NullType = exports.Binary = exports.BinaryType = exports.Utf8 = exports.Utf8Type = exports.Boolean = exports.BooleanType = exports.DecimalType = exports.Float64 = exports.Float64Type = exports.Float32 = exports.Float32Type = exports.UInt64 = exports.UInt64Type = exports.UInt32 = exports.UInt32Type = exports.UInt16 = exports.UInt16Type = exports.UInt8 = exports.UInt8Type = exports.Int64 = exports.Int64Type = exports.Int32 = exports.Int32Type = exports.Int16 = exports.Int16Type = exports.Int8 = exports.Int8Type = void 0;
-const DataType_1 = require("./DataType");
-const utils_1 = require("../utils");
-// ============================================================================
-// Numeric Types
-// ============================================================================
-class Int8Type extends DataType_1.SignedIntegerType {
-    name = "Int8";
-    coerce(val) { return (0, utils_1.toValidInt)(val, "Int8"); }
-    equals(other) { return other.name === "Int8"; }
-    allocate(size) { return new Int8Array(size); }
-}
-exports.Int8Type = Int8Type;
-exports.Int8 = new Int8Type();
-class Int16Type extends DataType_1.SignedIntegerType {
-    name = "Int16";
-    coerce(val) { return (0, utils_1.toValidInt)(val, "Int16"); }
-    equals(other) { return other.name === "Int16"; }
-    allocate(size) { return new Int16Array(size); }
-}
-exports.Int16Type = Int16Type;
-exports.Int16 = new Int16Type();
-class Int32Type extends DataType_1.SignedIntegerType {
-    name = "Int32";
-    coerce(val) { return (0, utils_1.toValidInt)(val, "Int32"); }
-    equals(other) { return other.name === "Int32"; }
-    allocate(size) { return new Int32Array(size); }
-}
-exports.Int32Type = Int32Type;
-exports.Int32 = new Int32Type();
-class Int64Type extends DataType_1.SignedIntegerType {
-    name = "Int64";
-    coerce(val) { return (0, utils_1.toValidBigInt)(val); }
-    equals(other) { return other.name === "Int64"; }
-    allocate(size) { return new BigInt64Array(size); }
-}
-exports.Int64Type = Int64Type;
-exports.Int64 = new Int64Type();
-class UInt8Type extends DataType_1.UnsignedIntegerType {
-    name = "UInt8";
-    coerce(val) { return (0, utils_1.toValidInt)(val, "UInt8"); }
-    equals(other) { return other.name === "UInt8"; }
-    allocate(size) { return new Uint8Array(size); }
-}
-exports.UInt8Type = UInt8Type;
-exports.UInt8 = new UInt8Type();
-class UInt16Type extends DataType_1.UnsignedIntegerType {
-    name = "UInt16";
-    coerce(val) { return (0, utils_1.toValidInt)(val, "UInt16"); }
-    equals(other) { return other.name === "UInt16"; }
-    allocate(size) { return new Uint16Array(size); }
-}
-exports.UInt16Type = UInt16Type;
-exports.UInt16 = new UInt16Type();
-class UInt32Type extends DataType_1.UnsignedIntegerType {
-    name = "UInt32";
-    coerce(val) { return (0, utils_1.toValidInt)(val, "UInt32"); }
-    equals(other) { return other.name === "UInt32"; }
-    allocate(size) { return new Uint32Array(size); }
-}
-exports.UInt32Type = UInt32Type;
-exports.UInt32 = new UInt32Type();
-class UInt64Type extends DataType_1.UnsignedIntegerType {
-    name = "UInt64";
-    coerce(val) { return (0, utils_1.toValidBigInt)(val, "UInt64"); }
-    equals(other) { return other.name === "UInt64"; }
-    allocate(size) { return new BigUint64Array(size); }
-}
-exports.UInt64Type = UInt64Type;
-exports.UInt64 = new UInt64Type();
-class Float32Type extends DataType_1.FloatDataType {
-    name = "Float32";
-    coerce(val) { return (0, utils_1.toValidFloat)(val, "Float32"); }
-    equals(other) { return other.name === "Float32"; }
-    allocate(size) { return new Float32Array(size); }
-}
-exports.Float32Type = Float32Type;
-exports.Float32 = new Float32Type();
-class Float64Type extends DataType_1.FloatDataType {
-    name = "Float64";
-    coerce(val) { return (0, utils_1.toValidFloat)(val, "Float64"); }
-    equals(other) { return other.name === "Float64"; }
-    allocate(size) { return new Float64Array(size); }
-}
-exports.Float64Type = Float64Type;
-exports.Float64 = new Float64Type();
-class DecimalType extends DataType_1.NumericDataType {
-    precision;
-    scale;
-    name;
-    constructor(precision, scale) {
-        super();
-        this.precision = precision;
-        this.scale = scale;
-        this.name = precision !== undefined && scale !== undefined
-            ? `Decimal(${precision}, ${scale})`
-            : "Decimal";
-    }
-    coerce(val) {
-        return (0, utils_1.toValidDecimal)(val, { precision: this.precision, scale: this.scale });
-    }
-    equals(other) {
-        return other instanceof DecimalType &&
-            this.precision === other.precision &&
-            this.scale === other.scale;
-    }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.DecimalType = DecimalType;
-// ============================================================================
-// Standard Types
-// ============================================================================
-class BooleanType extends DataType_1.DataType {
-    name = "Boolean";
-    get isBoolean() { return true; }
-    coerce(val) {
-        if (val == null)
-            return null;
-        return !!val;
-    }
-    equals(other) { return other.name === "Boolean"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.BooleanType = BooleanType;
-exports.Boolean = new BooleanType();
-class Utf8Type extends DataType_1.DataType {
-    name = "Utf8";
-    get isString() { return true; }
-    get isUtf8() { return true; }
-    coerce(val) {
-        if (val == null)
-            return null;
-        return String(val);
-    }
-    equals(other) { return other.name === "Utf8"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.Utf8Type = Utf8Type;
-exports.Utf8 = new Utf8Type();
-class BinaryType extends DataType_1.DataType {
-    name = "Binary";
-    get isBinary() { return true; }
-    coerce(val) { return (0, utils_1.toValidBinary)(val); }
-    equals(other) { return other.name === "Binary"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.BinaryType = BinaryType;
-exports.Binary = new BinaryType();
-class NullType extends DataType_1.DataType {
-    name = "Null";
-    get isNull() { return true; }
-    coerce(_val) { return null; }
-    equals(other) { return other.name === "Null"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.NullType = NullType;
-exports.Null = new NullType();
-class ObjectType extends DataType_1.DataType {
-    name = "Object";
-    get isObject() { return true; }
-    coerce(val) { return val === undefined ? null : val; }
-    equals(other) { return other.name === "Object"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.ObjectType = ObjectType;
-exports.Object = new ObjectType();
-// ============================================================================
-// Temporal Types
-// ============================================================================
-class DateType extends DataType_1.TemporalDataType {
-    name = "Date";
-    coerce(val) {
-        const d = (0, utils_1.toValidDate)(val);
-        if (!d)
-            return null;
-        d.setUTCHours(0, 0, 0, 0);
-        return d;
-    }
-    equals(other) { return other.name === "Date"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.DateType = DateType;
-exports.Date = new DateType();
-class DatetimeType extends DataType_1.TemporalDataType {
-    name = "Datetime";
-    coerce(val) { return (0, utils_1.toValidDate)(val); }
-    equals(other) { return other.name === "Datetime"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.DatetimeType = DatetimeType;
-exports.Datetime = new DatetimeType();
-class TimeType extends DataType_1.TemporalDataType {
-    name = "Time";
-    coerce(val) {
-        if (val == null)
-            return null;
-        if (typeof val === "string") {
-            const trimmed = val.trim();
-            if (utils_1.TIME_PREFIX_REGEX.test(trimmed)) {
-                const d = new globalThis.Date(`1970-01-01T${trimmed}${utils_1.ZONE_OFFSET_REGEX.test(trimmed) ? "" : "Z"}`);
-                if ((0, utils_1.isValidDateObj)(d)) {
-                    return d.toISOString().split("T")[1].slice(0, 12);
-                }
-            }
-        }
-        const d = (0, utils_1.toValidDate)(val);
-        return d ? d.toISOString().split("T")[1].slice(0, 12) : null;
-    }
-    equals(other) { return other.name === "Time"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.TimeType = TimeType;
-exports.Time = new TimeType();
-class DurationType extends DataType_1.TemporalDataType {
-    name = "Duration";
-    coerce(val) { return (0, utils_1.toValidNumber)(val); }
-    equals(other) { return other.name === "Duration"; }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.DurationType = DurationType;
-exports.Duration = new DurationType();
-// ============================================================================
-// Nested Types
-// ============================================================================
-class ListType extends DataType_1.NestedDataType {
-    innerType;
-    name = "List";
-    constructor(innerType) {
-        super();
-        this.innerType = innerType;
-    }
-    coerce(val) {
-        if (val == null)
-            return null;
-        const arr = (0, utils_1.isArrayOrTypedArray)(val) ? Array.from(val) : [val];
-        const len = arr.length;
-        const res = new Array(len);
-        for (let i = 0; i < len; i++) {
-            res[i] = this.innerType.coerce(arr[i]);
-        }
-        return res;
-    }
-    equals(other) {
-        return other instanceof ListType && this.innerType.equals(other.innerType);
-    }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.ListType = ListType;
-const List = (inner) => new ListType(inner);
-exports.List = List;
-class StructType extends DataType_1.NestedDataType {
-    fields;
-    name = "Struct";
-    constructor(fields) {
-        super();
-        this.fields = fields;
-    }
-    coerce(val) {
-        if (!(0, utils_1.isObj)(val))
-            return null;
-        const res = {};
-        for (const [k, type] of globalThis.Object.entries(this.fields)) {
-            res[k] = type.coerce(val[k]);
-        }
-        return res;
-    }
-    equals(other) {
-        if (!(other instanceof StructType))
-            return false;
-        const keysThis = globalThis.Object.keys(this.fields);
-        const keysOther = globalThis.Object.keys(other.fields);
-        if (keysThis.length !== keysOther.length)
-            return false;
-        for (const k of keysThis) {
-            if (!other.fields[k] || !this.fields[k].equals(other.fields[k]))
-                return false;
-        }
-        return true;
-    }
-    allocate(size) { return new Array(size).fill(null); }
-}
-exports.StructType = StructType;
-const Struct = (fields) => new StructType(fields);
-exports.Struct = Struct;

package/dist/exceptions/index.js

@@ -1,43 +0,0 @@
-"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 __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.ComputeError = exports.SchemaError = exports.ColumnNotFoundError = exports.DataFrameError = exports.DFScriptError = void 0;
-class DFScriptError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, this.constructor);
-        }
-    }
-}
-exports.DFScriptError = DFScriptError;
-class DataFrameError extends DFScriptError {
-}
-exports.DataFrameError = DataFrameError;
-class ColumnNotFoundError extends DataFrameError {
-    constructor(columnName, message) {
-        super(message || `Column "${columnName}" does not exist in the DataFrame.`);
-    }
-}
-exports.ColumnNotFoundError = ColumnNotFoundError;
-class SchemaError extends DFScriptError {
-}
-exports.SchemaError = SchemaError;
-class ComputeError extends DFScriptError {
-}
-exports.ComputeError = ComputeError;
-__exportStar(require("./utils"), exports);

package/dist/exceptions/utils.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertColumnExists = assertColumnExists;
-const index_1 = require("./index");
-function assertColumnExists(columnName, columns, context, suffix = "") {
-    if (!(columnName in columns)) {
-        throw new index_1.ColumnNotFoundError(columnName, `${context} "${columnName}" does not exist${suffix}`);
-    }
-}

package/dist/functions/concat.js

@@ -1,248 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeToDataFrames = normalizeToDataFrames;
-exports.concat = concat;
-const dataframe_1 = require("../dataframe/dataframe");
-const datatypes_1 = require("../datatypes");
-const utils_1 = require("../utils");
-const exceptions_1 = require("../exceptions");
-function normalizeToDataFrames(item, context, index) {
-    if (item == null) {
-        throw new exceptions_1.DataFrameError(`Invalid input to ${context} at index ${index}: item cannot be null or undefined.`);
-    }
-    if (item instanceof dataframe_1.DataFrame) {
-        return [item];
-    }
-    if ((0, utils_1.isPlainObj)(item)) {
-        return [new dataframe_1.DataFrame(item)];
-    }
-    if ((0, utils_1.isArrayOrTypedArray)(item)) {
-        if ((0, utils_1.isArrayOfType)(item, dataframe_1.DataFrame, { mode: "every" })) {
-            return item;
-        }
-        if ((0, utils_1.isArrayOfType)(item, "plainObject", { mode: "every" })) {
-            return [new dataframe_1.DataFrame(item)];
-        }
-        const anyDF = (0, utils_1.isArrayOfType)(item, dataframe_1.DataFrame, { mode: "some" });
-        for (let j = 0; j < item.length; j++) {
-            if (anyDF ? !(item[j] instanceof dataframe_1.DataFrame) : !(0, utils_1.isPlainObj)(item[j])) {
-                throw new exceptions_1.DataFrameError(anyDF
-                    ? `Invalid input to ${context} at index ${index}, sub-index ${j}: nested array must contain only DataFrame instances.`
-                    : `Invalid input to ${context} at index ${index}, row ${j}: rows must be plain objects.`);
-            }
-        }
-    }
-    throw new exceptions_1.DataFrameError(`Invalid input to ${context} at index ${index}: expected DataFrame, row array, or column dictionary.`);
-}
-function concat(rawItems, options = {}) {
-    if (rawItems == null) {
-        throw new exceptions_1.DataFrameError("Invalid input to concat: rawItems cannot be null or undefined.");
-    }
-    const itemsArray = Array.isArray(rawItems) ? rawItems : [rawItems];
-    const items = [];
-    for (let i = 0; i < itemsArray.length; i++) {
-        items.push(...normalizeToDataFrames(itemsArray[i], "concat", i));
-    }
-    const { how = 'vertical' } = options;
-    const strict = options.horizontal?.strict ?? true;
-    if (items.length === 0)
-        return new dataframe_1.DataFrame({}, {}, 0);
-    if (items.length === 1 && how !== 'horizontal')
-        return items[0];
-    switch (how) {
-        case 'vertical': {
-            const validItems = [];
-            for (let i = 0; i < items.length; i++) {
-                if (items[i].height > 0) {
-                    validItems.push(items[i]);
-                }
-            }
-            if (validItems.length === 0)
-                return new dataframe_1.DataFrame({}, {}, 0);
-            const firstDF = validItems[0];
-            const firstKeys = Object.keys(firstDF._columns);
-            for (let i = 0; i < items.length; i++) {
-                const currentDF = items[i];
-                if (currentDF.height === 0)
-                    continue;
-                const currentKeys = Object.keys(currentDF._columns);
-                if (firstKeys.length !== currentKeys.length) {
-                    throw new exceptions_1.DataFrameError(`[Strict Vertical] Column count mismatch at index ${i}.`);
-                }
-                for (let j = 0; j < firstKeys.length; j++) {
-                    if (firstKeys[j] !== currentKeys[j]) {
-                        throw new exceptions_1.DataFrameError(`[Strict Vertical] Schema mismatch at position ${j} in DF ${i}. ` +
-                            `Expected column "${firstKeys[j]}", but found "${currentKeys[j]}".`);
-                    }
-                    const typeA = firstDF.schema[firstKeys[j]];
-                    const typeB = currentDF.schema[firstKeys[j]];
-                    if (typeA && typeB && !typeA.equals(typeB)) {
-                        throw new exceptions_1.SchemaError(`[Strict Type Check] Schema type mismatch for column "${firstKeys[j]}": expected ${typeA.name}, found ${typeB.name}.`);
-                    }
-                }
-            }
-            let newHeight = 0;
-            for (const item of items) {
-                newHeight += item.height;
-            }
-            const outSchema = items.find(df => df.height > 0)?.schema || items[0]?.schema || {};
-            const newColumns = {};
-            for (const key of firstKeys) {
-                const type = outSchema[key];
-                let hasNulls = false;
-                for (const item of items) {
-                    const colArr = item._columns[key];
-                    if (!colArr) {
-                        hasNulls = true;
-                        break;
-                    }
-                    if (!(0, utils_1.isTypedArray)(colArr)) {
-                        for (let i = 0; i < colArr.length; i++) {
-                            if (colArr[i] == null) {
-                                hasNulls = true;
-                                break;
-                            }
-                        }
-                    }
-                    if (hasNulls)
-                        break;
-                }
-                let dest = type && type.allocate ? type.allocate(newHeight) : new Array(newHeight).fill(null);
-                if (hasNulls && (0, utils_1.isTypedArray)(dest)) {
-                    dest = new Array(newHeight).fill(null);
-                }
-                newColumns[key] = dest;
-            }
-            let offset = 0;
-            for (const item of items) {
-                const h = item.height;
-                if (h === 0)
-                    continue;
-                for (const key of firstKeys) {
-                    const colArr = item._columns[key] || new Array(h).fill(null);
-                    const dest = newColumns[key];
-                    if ((0, utils_1.isTypedArray)(dest) && (0, utils_1.isTypedArray)(colArr)) {
-                        dest.set(colArr, offset);
-                    }
-                    else {
-                        const destArr = dest;
-                        for (let i = 0; i < h; i++) {
-                            destArr[offset + i] = colArr[i];
-                        }
-                    }
-                }
-                offset += h;
-            }
-            return new dataframe_1.DataFrame(newColumns, outSchema, newHeight);
-        }
-        case 'horizontal': {
-            let maxHeight = items[0].height;
-            for (let i = 1; i < items.length; i++) {
-                if (items[i].height > maxHeight) {
-                    maxHeight = items[i].height;
-                }
-            }
-            const allColNames = new Set();
-            for (let idx = 0; idx < items.length; idx++) {
-                const df = items[idx];
-                if (strict && df.height !== maxHeight) {
-                    throw new exceptions_1.DataFrameError(`[Horizontal] Row count mismatch at index ${idx}. Expected ${maxHeight}, got ${df.height}. Set strict=false to allow padding.`);
-                }
-                for (const key of Object.keys(df._columns)) {
-                    if (allColNames.has(key)) {
-                        throw new exceptions_1.DataFrameError(`[Horizontal] Duplicate column name "${key}" detected. Horizontal concat requires unique names.`);
-                    }
-                    allColNames.add(key);
-                }
-            }
-            const newColumns = {};
-            const outSchema = {};
-            for (const df of items) {
-                const h = df.height;
-                Object.assign(outSchema, df.schema);
-                for (const [key, col] of Object.entries(df._columns)) {
-                    if (h === maxHeight) {
-                        newColumns[key] = (0, utils_1.isTypedArray)(col) ? Array.from(col) : col;
-                    }
-                    else {
-                        const padded = new Array(maxHeight);
-                        for (let i = 0; i < h; i++) {
-                            padded[i] = col[i];
-                        }
-                        for (let i = h; i < maxHeight; i++) {
-                            padded[i] = null;
-                        }
-                        newColumns[key] = padded;
-                    }
-                }
-            }
-            return new dataframe_1.DataFrame(newColumns, outSchema, maxHeight);
-        }
-        case 'diagonal': {
-            const allColumnsSet = new Set();
-            for (const df of items) {
-                for (const key of Object.keys(df._columns)) {
-                    allColumnsSet.add(key);
-                }
-            }
-            const allColumns = Array.from(allColumnsSet);
-            let newHeight = 0;
-            for (let i = 0; i < items.length; i++) {
-                newHeight += items[i].height;
-            }
-            const outSchema = {};
-            for (const key of allColumns) {
-                let colType = null;
-                for (const item of items) {
-                    const itemType = item.schema[key];
-                    if (itemType) {
-                        if (colType === null) {
-                            colType = itemType;
-                        }
-                        else {
-                            if (!colType.equals(itemType)) {
-                                throw new exceptions_1.SchemaError(`[Strict Type Check] Schema type mismatch for column "${key}": expected ${colType.name}, found ${itemType.name}.`);
-                            }
-                        }
-                    }
-                }
-                outSchema[key] = colType || datatypes_1.DataTypeRegistry.Utf8;
-            }
-            const newColumns = {};
-            for (let j = 0; j < allColumns.length; j++) {
-                newColumns[allColumns[j]] = new Array(newHeight).fill(null);
-            }
-            let offset = 0;
-            for (let i = 0; i < items.length; i++) {
-                const df = items[i];
-                const h = df.height;
-                if (h === 0)
-                    continue;
-                for (let j = 0; j < allColumns.length; j++) {
-                    const col = allColumns[j];
-                    const dest = newColumns[col];
-                    const src = df._columns[col];
-                    if (src !== undefined) {
-                        if ((0, utils_1.isTypedArray)(src) && (0, utils_1.isTypedArray)(dest)) {
-                            dest.set(src, offset);
-                        }
-                        else {
-                            const destArr = dest;
-                            for (let k = 0; k < h; k++) {
-                                destArr[offset + k] = src[k];
-                            }
-                        }
-                    }
-                    else {
-                        const destArr = dest;
-                        for (let k = 0; k < h; k++) {
-                            destArr[offset + k] = null;
-                        }
-                    }
-                }
-                offset += h;
-            }
-            return new dataframe_1.DataFrame(newColumns, outSchema, newHeight);
-        }
-    }
-}

package/dist/functions/index.js

@@ -1,17 +0,0 @@
-"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 __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 });
-__exportStar(require("./concat"), exports);

package/dist/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/boolean.d.ts

@@ -1 +0,0 @@
-export declare function tryParseBoolean(v: unknown): boolean | undefined;

package/dist/utils/boolean.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryParseBoolean = tryParseBoolean;
-const boolMap = {
-    true: true, "1": true, yes: true, y: true, on: true,
-    false: false, "0": false, no: false, n: false, off: false
-};
-function tryParseBoolean(v) {
-    if (typeof v === "boolean")
-        return v;
-    if (v === 1)
-        return true;
-    if (v === 0)
-        return false;
-    if (typeof v !== "string")
-        return undefined;
-    return boolMap[v.trim().toLowerCase()];
-}