@bilig/workbook 0.67.7 → 0.67.9

package/dist/guards.js

@@ -41,7 +41,25 @@ function isSafePositiveInteger(value) {
     return typeof value === 'number' && Number.isSafeInteger(value) && value > 0;
 }
 function isStringArray(value) {
-    return Array.isArray(value) && value.every((entry) => typeof entry === 'string');
+    return arrayEvery(value, (entry) => typeof entry === 'string');
+}
+function stringSetHas(values, value) {
+    return typeof value === 'string' && values.has(value);
+}
+function arrayEvery(value, predicate) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (descriptor === undefined || !('value' in descriptor) || !predicate(descriptor.value)) {
+            return false;
+        }
+    }
+    return true;
+}
+function nonEmptyArrayEvery(value, predicate) {
+    return Array.isArray(value) && value.length > 0 && arrayEvery(value, predicate);
 }
 function isConditionalFormatArtifacts(value) {
     return isRecord(value) && hasString(value, 'xml');
@@ -89,64 +107,60 @@ function isWorkbookAxisEntry(value) {
     return (isRecord(value) &&
         hasString(value, 'id') &&
         hasSafeNonNegativeInteger(value, 'index') &&
-        isOptionalNullableSafePositiveInteger(value['size']) &&
-        isOptionalNullableBoolean(value['hidden']) &&
-        isOptionalNullableBoolean(value['filterHidden']));
+        isOptionalNullableSafePositiveInteger(ownValue(value, 'size')) &&
+        isOptionalNullableBoolean(ownValue(value, 'hidden')) &&
+        isOptionalNullableBoolean(ownValue(value, 'filterHidden')));
 }
 function isCellBorderSide(value) {
     return (isRecord(value) &&
         hasString(value, 'color') &&
-        typeof value['style'] === 'string' &&
-        BORDER_STYLE_VALUES.has(value['style']) &&
-        typeof value['weight'] === 'string' &&
-        BORDER_WEIGHT_VALUES.has(value['weight']));
+        stringSetHas(BORDER_STYLE_VALUES, ownValue(value, 'style')) &&
+        stringSetHas(BORDER_WEIGHT_VALUES, ownValue(value, 'weight')));
 }
 function isCellStyleRecord(value) {
     if (!isRecord(value) || !hasString(value, 'id')) {
         return false;
     }
-    const fill = value['fill'];
-    if (fill !== undefined && (!isRecord(fill) || typeof fill['backgroundColor'] !== 'string')) {
+    const fill = ownValue(value, 'fill');
+    if (fill !== undefined && (!isRecord(fill) || typeof ownValue(fill, 'backgroundColor') !== 'string')) {
         return false;
     }
-    const font = value['font'];
+    const font = ownValue(value, 'font');
     if (font !== undefined &&
         (!isRecord(font) ||
-            !isOptionalString(font['family']) ||
-            !isOptionalNumber(font['size']) ||
-            !isOptionalBoolean(font['bold']) ||
-            !isOptionalBoolean(font['italic']) ||
-            !isOptionalBoolean(font['underline']) ||
-            !isOptionalString(font['color']))) {
+            !isOptionalString(ownValue(font, 'family')) ||
+            !isOptionalNumber(ownValue(font, 'size')) ||
+            !isOptionalBoolean(ownValue(font, 'bold')) ||
+            !isOptionalBoolean(ownValue(font, 'italic')) ||
+            !isOptionalBoolean(ownValue(font, 'underline')) ||
+            !isOptionalString(ownValue(font, 'color')))) {
         return false;
     }
-    const alignment = value['alignment'];
+    const alignment = ownValue(value, 'alignment');
     if (alignment !== undefined &&
         (!isRecord(alignment) ||
-            !(alignment['horizontal'] === undefined ||
-                (typeof alignment['horizontal'] === 'string' && HORIZONTAL_ALIGNMENT_VALUES.has(alignment['horizontal']))) ||
-            !(alignment['vertical'] === undefined ||
-                (typeof alignment['vertical'] === 'string' && VERTICAL_ALIGNMENT_VALUES.has(alignment['vertical']))) ||
-            !isOptionalBoolean(alignment['wrap']) ||
-            !isOptionalNumber(alignment['indent']) ||
-            !isOptionalBoolean(alignment['shrinkToFit']) ||
-            !isOptionalNumber(alignment['readingOrder']) ||
-            !isOptionalNumber(alignment['textRotation']) ||
-            !isOptionalBoolean(alignment['justifyLastLine']))) {
+            !(ownValue(alignment, 'horizontal') === undefined || stringSetHas(HORIZONTAL_ALIGNMENT_VALUES, ownValue(alignment, 'horizontal'))) ||
+            !(ownValue(alignment, 'vertical') === undefined || stringSetHas(VERTICAL_ALIGNMENT_VALUES, ownValue(alignment, 'vertical'))) ||
+            !isOptionalBoolean(ownValue(alignment, 'wrap')) ||
+            !isOptionalNumber(ownValue(alignment, 'indent')) ||
+            !isOptionalBoolean(ownValue(alignment, 'shrinkToFit')) ||
+            !isOptionalNumber(ownValue(alignment, 'readingOrder')) ||
+            !isOptionalNumber(ownValue(alignment, 'textRotation')) ||
+            !isOptionalBoolean(ownValue(alignment, 'justifyLastLine')))) {
         return false;
     }
-    const borders = value['borders'];
+    const borders = ownValue(value, 'borders');
     if (borders !== undefined &&
         (!isRecord(borders) ||
-            !(borders['top'] === undefined || isCellBorderSide(borders['top'])) ||
-            !(borders['right'] === undefined || isCellBorderSide(borders['right'])) ||
-            !(borders['bottom'] === undefined || isCellBorderSide(borders['bottom'])) ||
-            !(borders['left'] === undefined || isCellBorderSide(borders['left'])))) {
+            !(ownValue(borders, 'top') === undefined || isCellBorderSide(ownValue(borders, 'top'))) ||
+            !(ownValue(borders, 'right') === undefined || isCellBorderSide(ownValue(borders, 'right'))) ||
+            !(ownValue(borders, 'bottom') === undefined || isCellBorderSide(ownValue(borders, 'bottom'))) ||
+            !(ownValue(borders, 'left') === undefined || isCellBorderSide(ownValue(borders, 'left'))))) {
         return false;
     }
-    const protection = value['protection'];
+    const protection = ownValue(value, 'protection');
     if (protection !== undefined &&
-        (!isRecord(protection) || !isOptionalBoolean(protection['locked']) || !isOptionalBoolean(protection['hidden']))) {
+        (!isRecord(protection) || !isOptionalBoolean(ownValue(protection, 'locked')) || !isOptionalBoolean(ownValue(protection, 'hidden')))) {
         return false;
     }
     return true;
@@ -155,29 +169,24 @@ function isCellNumberFormatRecord(value) {
     return (isRecord(value) &&
         hasString(value, 'id') &&
         hasString(value, 'code') &&
-        typeof value['kind'] === 'string' &&
-        NUMBER_FORMAT_KIND_VALUES.has(value['kind']));
+        stringSetHas(NUMBER_FORMAT_KIND_VALUES, ownValue(value, 'kind')));
 }
 function isWorkbookCalculationSettings(value) {
     return (isRecord(value) &&
-        (value['mode'] === 'automatic' || value['mode'] === 'manual') &&
-        (value['compatibilityMode'] === undefined ||
-            (typeof value['compatibilityMode'] === 'string' && COMPATIBILITY_MODE_VALUES.has(value['compatibilityMode']))));
+        (ownValue(value, 'mode') === 'automatic' || ownValue(value, 'mode') === 'manual') &&
+        (ownValue(value, 'compatibilityMode') === undefined || stringSetHas(COMPATIBILITY_MODE_VALUES, ownValue(value, 'compatibilityMode'))));
 }
 function isWorkbookVolatileContext(value) {
     return isRecord(value) && hasFiniteNumber(value, 'recalcEpoch');
 }
 function isWorkbookSortKey(value) {
-    return (isRecord(value) &&
-        hasString(value, 'keyAddress') &&
-        typeof value['direction'] === 'string' &&
-        SORT_DIRECTION_VALUES.has(value['direction']));
+    return isRecord(value) && hasString(value, 'keyAddress') && stringSetHas(SORT_DIRECTION_VALUES, ownValue(value, 'direction'));
 }
 function isWorkbookValidationListSource(value) {
-    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+    if (!isRecord(value) || typeof ownValue(value, 'kind') !== 'string') {
         return false;
     }
-    switch (value['kind']) {
+    switch (ownValue(value, 'kind')) {
         case 'named-range':
             return hasString(value, 'name');
         case 'cell-ref':
@@ -191,17 +200,17 @@ function isWorkbookValidationListSource(value) {
     }
 }
 function isWorkbookDataValidationRule(value) {
-    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+    if (!isRecord(value) || typeof ownValue(value, 'kind') !== 'string') {
         return false;
     }
-    switch (value['kind']) {
+    switch (ownValue(value, 'kind')) {
         case 'list': {
-            const hasValues = Array.isArray(value['values']) && value['values'].every((entry) => isLiteralInput(entry));
-            const hasSource = value['source'] !== undefined && isWorkbookValidationListSource(value['source']);
+            const hasValues = arrayEvery(ownValue(value, 'values'), isLiteralInput);
+            const hasSource = ownValue(value, 'source') !== undefined && isWorkbookValidationListSource(ownValue(value, 'source'));
             return (hasValues ? 1 : 0) + (hasSource ? 1 : 0) === 1;
         }
         case 'checkbox':
-            return isOptionalLiteralInput(value['checkedValue']) && isOptionalLiteralInput(value['uncheckedValue']);
+            return isOptionalLiteralInput(ownValue(value, 'checkedValue')) && isOptionalLiteralInput(ownValue(value, 'uncheckedValue'));
         case 'any':
             return true;
         case 'whole':
@@ -209,88 +218,90 @@ function isWorkbookDataValidationRule(value) {
         case 'date':
         case 'time':
         case 'textLength':
-            return (typeof value['operator'] === 'string' &&
-                VALIDATION_COMPARISON_OPERATOR_VALUES.has(value['operator']) &&
-                Array.isArray(value['values']) &&
-                value['values'].every((entry) => isLiteralInput(entry)) &&
-                (value['operator'] === 'between' || value['operator'] === 'notBetween'
-                    ? value['values'].length === 2
-                    : value['values'].length === 1));
+            const operator = ownValue(value, 'operator');
+            const values = ownValue(value, 'values');
+            return (stringSetHas(VALIDATION_COMPARISON_OPERATOR_VALUES, operator) &&
+                arrayEvery(values, isLiteralInput) &&
+                (operator === 'between' || operator === 'notBetween'
+                    ? Array.isArray(values) && values.length === 2
+                    : Array.isArray(values) && values.length === 1));
         default:
             return false;
     }
 }
 function isWorkbookDataValidation(value) {
     return (isRecord(value) &&
-        isCellRangeRef(value['range']) &&
-        isWorkbookDataValidationRule(value['rule']) &&
-        isOptionalBoolean(value['allowBlank']) &&
-        isOptionalBoolean(value['showDropdown']) &&
-        isOptionalString(value['promptTitle']) &&
-        isOptionalString(value['promptMessage']) &&
-        (value['errorStyle'] === undefined ||
-            (typeof value['errorStyle'] === 'string' && VALIDATION_ERROR_STYLE_VALUES.has(value['errorStyle']))) &&
-        isOptionalString(value['errorTitle']) &&
-        isOptionalString(value['errorMessage']));
+        isCellRangeRef(ownValue(value, 'range')) &&
+        isWorkbookDataValidationRule(ownValue(value, 'rule')) &&
+        isOptionalBoolean(ownValue(value, 'allowBlank')) &&
+        isOptionalBoolean(ownValue(value, 'showDropdown')) &&
+        isOptionalString(ownValue(value, 'promptTitle')) &&
+        isOptionalString(ownValue(value, 'promptMessage')) &&
+        (ownValue(value, 'errorStyle') === undefined || stringSetHas(VALIDATION_ERROR_STYLE_VALUES, ownValue(value, 'errorStyle'))) &&
+        isOptionalString(ownValue(value, 'errorTitle')) &&
+        isOptionalString(ownValue(value, 'errorMessage')));
 }
 function isCellStylePatch(value) {
     if (!isRecord(value)) {
         return false;
     }
-    const fill = value['fill'];
+    const fill = ownValue(value, 'fill');
     if (fill !== undefined &&
         fill !== null &&
-        (!isRecord(fill) || !(fill['backgroundColor'] === undefined || fill['backgroundColor'] === null || hasString(fill, 'backgroundColor')))) {
+        (!isRecord(fill) ||
+            !(ownValue(fill, 'backgroundColor') === undefined ||
+                ownValue(fill, 'backgroundColor') === null ||
+                hasString(fill, 'backgroundColor')))) {
         return false;
     }
-    const font = value['font'];
+    const font = ownValue(value, 'font');
     if (font !== undefined &&
         font !== null &&
         (!isRecord(font) ||
-            !(font['family'] === undefined || font['family'] === null || hasString(font, 'family')) ||
-            !isOptionalNullableNumber(font['size']) ||
-            !isOptionalNullableBoolean(font['bold']) ||
-            !isOptionalNullableBoolean(font['italic']) ||
-            !isOptionalNullableBoolean(font['underline']) ||
-            !(font['color'] === undefined || font['color'] === null || hasString(font, 'color')))) {
+            !(ownValue(font, 'family') === undefined || ownValue(font, 'family') === null || hasString(font, 'family')) ||
+            !isOptionalNullableNumber(ownValue(font, 'size')) ||
+            !isOptionalNullableBoolean(ownValue(font, 'bold')) ||
+            !isOptionalNullableBoolean(ownValue(font, 'italic')) ||
+            !isOptionalNullableBoolean(ownValue(font, 'underline')) ||
+            !(ownValue(font, 'color') === undefined || ownValue(font, 'color') === null || hasString(font, 'color')))) {
         return false;
     }
-    const alignment = value['alignment'];
+    const alignment = ownValue(value, 'alignment');
     if (alignment !== undefined &&
         alignment !== null &&
         (!isRecord(alignment) ||
-            !(alignment['horizontal'] === undefined ||
-                alignment['horizontal'] === null ||
-                (typeof alignment['horizontal'] === 'string' && HORIZONTAL_ALIGNMENT_VALUES.has(alignment['horizontal']))) ||
-            !(alignment['vertical'] === undefined ||
-                alignment['vertical'] === null ||
-                (typeof alignment['vertical'] === 'string' && VERTICAL_ALIGNMENT_VALUES.has(alignment['vertical']))) ||
-            !isOptionalNullableBoolean(alignment['wrap']) ||
-            !isOptionalNullableNumber(alignment['indent']) ||
-            !isOptionalNullableBoolean(alignment['shrinkToFit']) ||
-            !isOptionalNullableNumber(alignment['readingOrder']) ||
-            !isOptionalNullableNumber(alignment['textRotation']) ||
-            !isOptionalNullableBoolean(alignment['justifyLastLine']))) {
+            !(ownValue(alignment, 'horizontal') === undefined ||
+                ownValue(alignment, 'horizontal') === null ||
+                stringSetHas(HORIZONTAL_ALIGNMENT_VALUES, ownValue(alignment, 'horizontal'))) ||
+            !(ownValue(alignment, 'vertical') === undefined ||
+                ownValue(alignment, 'vertical') === null ||
+                stringSetHas(VERTICAL_ALIGNMENT_VALUES, ownValue(alignment, 'vertical'))) ||
+            !isOptionalNullableBoolean(ownValue(alignment, 'wrap')) ||
+            !isOptionalNullableNumber(ownValue(alignment, 'indent')) ||
+            !isOptionalNullableBoolean(ownValue(alignment, 'shrinkToFit')) ||
+            !isOptionalNullableNumber(ownValue(alignment, 'readingOrder')) ||
+            !isOptionalNullableNumber(ownValue(alignment, 'textRotation')) ||
+            !isOptionalNullableBoolean(ownValue(alignment, 'justifyLastLine')))) {
         return false;
     }
-    const borders = value['borders'];
+    const borders = ownValue(value, 'borders');
     if (borders !== undefined && borders !== null) {
         if (!isRecord(borders)) {
             return false;
         }
         for (const side of ['top', 'right', 'bottom', 'left']) {
-            const sideValue = borders[side];
+            const sideValue = ownValue(borders, side);
             if (sideValue === undefined || sideValue === null) {
                 continue;
             }
             if (!isRecord(sideValue) ||
-                !(sideValue['style'] === undefined ||
-                    sideValue['style'] === null ||
-                    (typeof sideValue['style'] === 'string' && BORDER_STYLE_VALUES.has(sideValue['style']))) ||
-                !(sideValue['weight'] === undefined ||
-                    sideValue['weight'] === null ||
-                    (typeof sideValue['weight'] === 'string' && BORDER_WEIGHT_VALUES.has(sideValue['weight']))) ||
-                !(sideValue['color'] === undefined || sideValue['color'] === null || hasString(sideValue, 'color'))) {
+                !(ownValue(sideValue, 'style') === undefined ||
+                    ownValue(sideValue, 'style') === null ||
+                    stringSetHas(BORDER_STYLE_VALUES, ownValue(sideValue, 'style'))) ||
+                !(ownValue(sideValue, 'weight') === undefined ||
+                    ownValue(sideValue, 'weight') === null ||
+                    stringSetHas(BORDER_WEIGHT_VALUES, ownValue(sideValue, 'weight'))) ||
+                !(ownValue(sideValue, 'color') === undefined || ownValue(sideValue, 'color') === null || hasString(sideValue, 'color'))) {
                 return false;
             }
         }
@@ -298,20 +309,20 @@ function isCellStylePatch(value) {
     return true;
 }
 function isWorkbookConditionalFormatRule(value) {
-    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+    if (!isRecord(value) || typeof ownValue(value, 'kind') !== 'string') {
         return false;
     }
-    switch (value['kind']) {
+    switch (ownValue(value, 'kind')) {
         case 'cellIs':
-            return (typeof value['operator'] === 'string' &&
-                VALIDATION_COMPARISON_OPERATOR_VALUES.has(value['operator']) &&
-                Array.isArray(value['values']) &&
-                value['values'].every((entry) => isLiteralInput(entry)) &&
-                (value['operator'] === 'between' || value['operator'] === 'notBetween'
-                    ? value['values'].length === 2
-                    : value['values'].length === 1));
+            const operator = ownValue(value, 'operator');
+            const values = ownValue(value, 'values');
+            return (stringSetHas(VALIDATION_COMPARISON_OPERATOR_VALUES, operator) &&
+                arrayEvery(values, isLiteralInput) &&
+                (operator === 'between' || operator === 'notBetween'
+                    ? Array.isArray(values) && values.length === 2
+                    : Array.isArray(values) && values.length === 1));
         case 'textContains':
-            return hasString(value, 'text') && isOptionalBoolean(value['caseSensitive']);
+            return hasString(value, 'text') && isOptionalBoolean(ownValue(value, 'caseSensitive'));
         case 'formula':
             return hasString(value, 'formula');
         case 'blanks':
@@ -324,37 +335,38 @@ function isWorkbookConditionalFormatRule(value) {
 function isWorkbookConditionalFormat(value) {
     return (isRecord(value) &&
         hasString(value, 'id') &&
-        isCellRangeRef(value['range']) &&
-        isWorkbookConditionalFormatRule(value['rule']) &&
-        isCellStylePatch(value['style']) &&
-        isOptionalBoolean(value['stopIfTrue']) &&
-        isOptionalSafeNonNegativeInteger(value['priority']));
+        isCellRangeRef(ownValue(value, 'range')) &&
+        isWorkbookConditionalFormatRule(ownValue(value, 'rule')) &&
+        isCellStylePatch(ownValue(value, 'style')) &&
+        isOptionalBoolean(ownValue(value, 'stopIfTrue')) &&
+        isOptionalSafeNonNegativeInteger(ownValue(value, 'priority')));
 }
 function isWorkbookSheetProtection(value) {
-    return isRecord(value) && hasString(value, 'sheetName') && isOptionalBoolean(value['hideFormulas']);
+    return isRecord(value) && hasString(value, 'sheetName') && isOptionalBoolean(ownValue(value, 'hideFormulas'));
 }
 function isWorkbookRangeProtection(value) {
-    return isRecord(value) && hasString(value, 'id') && isCellRangeRef(value['range']) && isOptionalBoolean(value['hideFormulas']);
+    return (isRecord(value) &&
+        hasString(value, 'id') &&
+        isCellRangeRef(ownValue(value, 'range')) &&
+        isOptionalBoolean(ownValue(value, 'hideFormulas')));
 }
 function isWorkbookCommentEntry(value) {
     return (isRecord(value) &&
         hasString(value, 'id') &&
         hasString(value, 'body') &&
-        isOptionalString(value['authorUserId']) &&
-        isOptionalString(value['authorDisplayName']) &&
-        isOptionalSafeNonNegativeInteger(value['createdAtUnixMs']));
+        isOptionalString(ownValue(value, 'authorUserId')) &&
+        isOptionalString(ownValue(value, 'authorDisplayName')) &&
+        isOptionalSafeNonNegativeInteger(ownValue(value, 'createdAtUnixMs')));
 }
 function isWorkbookCommentThread(value) {
     return (isRecord(value) &&
         hasString(value, 'threadId') &&
         hasString(value, 'sheetName') &&
         hasString(value, 'address') &&
-        Array.isArray(value['comments']) &&
-        value['comments'].length > 0 &&
-        value['comments'].every((entry) => isWorkbookCommentEntry(entry)) &&
-        isOptionalBoolean(value['resolved']) &&
-        isOptionalString(value['resolvedByUserId']) &&
-        isOptionalSafeNonNegativeInteger(value['resolvedAtUnixMs']));
+        nonEmptyArrayEvery(ownValue(value, 'comments'), isWorkbookCommentEntry) &&
+        isOptionalBoolean(ownValue(value, 'resolved')) &&
+        isOptionalString(ownValue(value, 'resolvedByUserId')) &&
+        isOptionalSafeNonNegativeInteger(ownValue(value, 'resolvedAtUnixMs')));
 }
 function isWorkbookNote(value) {
     return isRecord(value) && hasString(value, 'sheetName') && hasString(value, 'address') && hasString(value, 'text');
@@ -364,19 +376,19 @@ function isWorkbookHyperlink(value) {
         hasString(value, 'sheetName') &&
         hasString(value, 'address') &&
         hasString(value, 'target') &&
-        isOptionalString(value['tooltip']) &&
-        isOptionalString(value['display']));
+        isOptionalString(ownValue(value, 'tooltip')) &&
+        isOptionalString(ownValue(value, 'display')));
 }
 function isWorkbookDefinedNameValue(value) {
     if (isLiteralInput(value)) {
         return true;
     }
-    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+    if (!isRecord(value) || typeof ownValue(value, 'kind') !== 'string') {
         return false;
     }
-    switch (value['kind']) {
+    switch (ownValue(value, 'kind')) {
         case 'scalar':
-            return isLiteralInput(value['value']);
+            return isLiteralInput(ownValue(value, 'value'));
         case 'cell-ref':
             return hasString(value, 'sheetName') && hasString(value, 'address');
         case 'range-ref':
@@ -395,37 +407,35 @@ function isWorkbookTableOp(value) {
         hasString(value, 'sheetName') &&
         hasString(value, 'startAddress') &&
         hasString(value, 'endAddress') &&
-        isStringArray(value['columnNames']) &&
-        typeof value['headerRow'] === 'boolean' &&
-        typeof value['totalsRow'] === 'boolean' &&
-        (value['columns'] === undefined || isWorkbookTableColumns(value['columns'])) &&
-        (value['style'] === undefined || isWorkbookTableStyle(value['style'])) &&
-        (value['autoFilter'] === undefined || isCellRangeRef(value['autoFilter'])) &&
-        isOptionalString(value['sortState']));
+        isStringArray(ownValue(value, 'columnNames')) &&
+        typeof ownValue(value, 'headerRow') === 'boolean' &&
+        typeof ownValue(value, 'totalsRow') === 'boolean' &&
+        (ownValue(value, 'columns') === undefined || isWorkbookTableColumns(ownValue(value, 'columns'))) &&
+        (ownValue(value, 'style') === undefined || isWorkbookTableStyle(ownValue(value, 'style'))) &&
+        (ownValue(value, 'autoFilter') === undefined || isCellRangeRef(ownValue(value, 'autoFilter'))) &&
+        isOptionalString(ownValue(value, 'sortState')));
 }
 function isWorkbookTableColumns(value) {
-    return (Array.isArray(value) &&
-        value.every((entry) => isRecord(entry) &&
-            hasString(entry, 'name') &&
-            isOptionalString(entry['calculatedColumnFormula']) &&
-            isOptionalString(entry['totalsRowLabel']) &&
-            isOptionalString(entry['totalsRowFunction']) &&
-            isOptionalString(entry['totalsRowFormula'])));
+    return arrayEvery(value, (entry) => isRecord(entry) &&
+        hasString(entry, 'name') &&
+        isOptionalString(ownValue(entry, 'calculatedColumnFormula')) &&
+        isOptionalString(ownValue(entry, 'totalsRowLabel')) &&
+        isOptionalString(ownValue(entry, 'totalsRowFunction')) &&
+        isOptionalString(ownValue(entry, 'totalsRowFormula')));
 }
 function isWorkbookTableStyle(value) {
     return (isRecord(value) &&
-        isOptionalString(value['name']) &&
-        isOptionalBoolean(value['showFirstColumn']) &&
-        isOptionalBoolean(value['showLastColumn']) &&
-        isOptionalBoolean(value['showRowStripes']) &&
-        isOptionalBoolean(value['showColumnStripes']));
+        isOptionalString(ownValue(value, 'name')) &&
+        isOptionalBoolean(ownValue(value, 'showFirstColumn')) &&
+        isOptionalBoolean(ownValue(value, 'showLastColumn')) &&
+        isOptionalBoolean(ownValue(value, 'showRowStripes')) &&
+        isOptionalBoolean(ownValue(value, 'showColumnStripes')));
 }
 function isWorkbookPivotValue(value) {
     return (isRecord(value) &&
         hasString(value, 'sourceColumn') &&
-        typeof value['summarizeBy'] === 'string' &&
-        PIVOT_AGGREGATION_VALUES.has(value['summarizeBy']) &&
-        isOptionalString(value['outputLabel']));
+        stringSetHas(PIVOT_AGGREGATION_VALUES, ownValue(value, 'summarizeBy')) &&
+        isOptionalString(ownValue(value, 'outputLabel')));
 }
 const CHART_TYPE_VALUES = new Set(['column', 'bar', 'line', 'area', 'pie', 'scatter']);
 const CHART_SERIES_ORIENTATION_VALUES = new Set(['rows', 'columns']);
@@ -436,8 +446,8 @@ function isDrawingAnchorMarker(value) {
     return (isRecord(value) &&
         hasSafeNonNegativeInteger(value, 'row') &&
         hasSafeNonNegativeInteger(value, 'col') &&
-        isOptionalSafeNonNegativeInteger(value['rowOffset']) &&
-        isOptionalSafeNonNegativeInteger(value['colOffset']));
+        isOptionalSafeNonNegativeInteger(ownValue(value, 'rowOffset')) &&
+        isOptionalSafeNonNegativeInteger(ownValue(value, 'colOffset')));
 }
 function isDrawingAnchorExtent(value) {
     return isRecord(value) && hasSafePositiveInteger(value, 'width') && hasSafePositiveInteger(value, 'height');
@@ -446,18 +456,18 @@ function isDrawingAnchorPosition(value) {
     return isRecord(value) && hasSafeNonNegativeInteger(value, 'x') && hasSafeNonNegativeInteger(value, 'y');
 }
 function isWorkbookChartAnchor(value) {
-    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+    if (!isRecord(value) || typeof ownValue(value, 'kind') !== 'string') {
         return false;
     }
-    switch (value['kind']) {
+    switch (ownValue(value, 'kind')) {
         case 'twoCell':
-            return ((value['editAs'] === undefined || (typeof value['editAs'] === 'string' && DRAWING_ANCHOR_EDIT_AS_VALUES.has(value['editAs']))) &&
-                isDrawingAnchorMarker(value['from']) &&
-                isDrawingAnchorMarker(value['to']));
+            return ((ownValue(value, 'editAs') === undefined || stringSetHas(DRAWING_ANCHOR_EDIT_AS_VALUES, ownValue(value, 'editAs'))) &&
+                isDrawingAnchorMarker(ownValue(value, 'from')) &&
+                isDrawingAnchorMarker(ownValue(value, 'to')));
         case 'oneCell':
-            return isDrawingAnchorMarker(value['from']) && isDrawingAnchorExtent(value['extent']);
+            return isDrawingAnchorMarker(ownValue(value, 'from')) && isDrawingAnchorExtent(ownValue(value, 'extent'));
         case 'absolute':
-            return isDrawingAnchorPosition(value['position']) && isDrawingAnchorExtent(value['extent']);
+            return isDrawingAnchorPosition(ownValue(value, 'position')) && isDrawingAnchorExtent(ownValue(value, 'extent'));
         default:
             return false;
     }
@@ -467,17 +477,15 @@ function isWorkbookChart(value) {
         hasString(value, 'id') &&
         hasString(value, 'sheetName') &&
         hasString(value, 'address') &&
-        isCellRangeRef(value['source']) &&
-        typeof value['chartType'] === 'string' &&
-        CHART_TYPE_VALUES.has(value['chartType']) &&
-        (value['anchor'] === undefined || isWorkbookChartAnchor(value['anchor'])) &&
-        (value['seriesOrientation'] === undefined ||
-            (typeof value['seriesOrientation'] === 'string' && CHART_SERIES_ORIENTATION_VALUES.has(value['seriesOrientation']))) &&
-        isOptionalBoolean(value['firstRowAsHeaders']) &&
-        isOptionalBoolean(value['firstColumnAsLabels']) &&
-        isOptionalString(value['title']) &&
-        (value['legendPosition'] === undefined ||
-            (typeof value['legendPosition'] === 'string' && CHART_LEGEND_POSITION_VALUES.has(value['legendPosition']))) &&
+        isCellRangeRef(ownValue(value, 'source')) &&
+        stringSetHas(CHART_TYPE_VALUES, ownValue(value, 'chartType')) &&
+        (ownValue(value, 'anchor') === undefined || isWorkbookChartAnchor(ownValue(value, 'anchor'))) &&
+        (ownValue(value, 'seriesOrientation') === undefined ||
+            stringSetHas(CHART_SERIES_ORIENTATION_VALUES, ownValue(value, 'seriesOrientation'))) &&
+        isOptionalBoolean(ownValue(value, 'firstRowAsHeaders')) &&
+        isOptionalBoolean(ownValue(value, 'firstColumnAsLabels')) &&
+        isOptionalString(ownValue(value, 'title')) &&
+        (ownValue(value, 'legendPosition') === undefined || stringSetHas(CHART_LEGEND_POSITION_VALUES, ownValue(value, 'legendPosition'))) &&
         hasSafePositiveInteger(value, 'rows') &&
         hasSafePositiveInteger(value, 'cols'));
 }
@@ -489,36 +497,35 @@ function isWorkbookImage(value) {
         hasString(value, 'sourceUrl') &&
         hasSafePositiveInteger(value, 'rows') &&
         hasSafePositiveInteger(value, 'cols') &&
-        isOptionalString(value['altText']));
+        isOptionalString(ownValue(value, 'altText')));
 }
 function isWorkbookShape(value) {
     return (isRecord(value) &&
         hasString(value, 'id') &&
         hasString(value, 'sheetName') &&
         hasString(value, 'address') &&
-        typeof value['shapeType'] === 'string' &&
-        SHAPE_TYPE_VALUES.has(value['shapeType']) &&
+        stringSetHas(SHAPE_TYPE_VALUES, ownValue(value, 'shapeType')) &&
         hasSafePositiveInteger(value, 'rows') &&
         hasSafePositiveInteger(value, 'cols') &&
-        isOptionalString(value['text']) &&
-        isOptionalString(value['fillColor']) &&
-        isOptionalString(value['strokeColor']));
+        isOptionalString(ownValue(value, 'text')) &&
+        isOptionalString(ownValue(value, 'fillColor')) &&
+        isOptionalString(ownValue(value, 'strokeColor')));
 }
 export function isWorkbookOp(value) {
-    if (!isRecord(value) || typeof value['kind'] !== 'string') {
+    if (!isRecord(value) || typeof ownValue(value, 'kind') !== 'string') {
         return false;
     }
-    switch (value['kind']) {
+    switch (ownValue(value, 'kind')) {
         case 'upsertWorkbook':
             return hasString(value, 'name');
         case 'setWorkbookMetadata':
-            return hasString(value, 'key') && isLiteralInput(value['value']);
+            return hasString(value, 'key') && isLiteralInput(ownValue(value, 'value'));
         case 'setCalculationSettings':
-            return isWorkbookCalculationSettings(value['settings']);
+            return isWorkbookCalculationSettings(ownValue(value, 'settings'));
         case 'setVolatileContext':
-            return isWorkbookVolatileContext(value['context']);
+            return isWorkbookVolatileContext(ownValue(value, 'context'));
         case 'upsertSheet':
-            return hasString(value, 'name') && hasSafeNonNegativeInteger(value, 'order') && isOptionalSafePositiveInteger(value['id']);
+            return hasString(value, 'name') && hasSafeNonNegativeInteger(value, 'order') && isOptionalSafePositiveInteger(ownValue(value, 'id'));
         case 'renameSheet':
             return hasString(value, 'oldName') && hasString(value, 'newName');
         case 'deleteSheet':
@@ -528,8 +535,7 @@ export function isWorkbookOp(value) {
             return (hasString(value, 'sheetName') &&
                 hasSafeNonNegativeInteger(value, 'start') &&
                 hasSafePositiveInteger(value, 'count') &&
-                (value['entries'] === undefined ||
-                    (Array.isArray(value['entries']) && value['entries'].every((entry) => isWorkbookAxisEntry(entry)))));
+                (ownValue(value, 'entries') === undefined || arrayEvery(ownValue(value, 'entries'), isWorkbookAxisEntry)));
         case 'deleteRows':
         case 'deleteColumns':
             return hasString(value, 'sheetName') && hasSafeNonNegativeInteger(value, 'start') && hasSafePositiveInteger(value, 'count');
@@ -544,81 +550,80 @@ export function isWorkbookOp(value) {
             return (hasString(value, 'sheetName') &&
                 hasSafeNonNegativeInteger(value, 'start') &&
                 hasSafePositiveInteger(value, 'count') &&
-                isOptionalNullableSafePositiveInteger(value['size']) &&
-                isOptionalNullableBoolean(value['hidden']) &&
-                isOptionalNullableBoolean(value['filterHidden']));
+                isOptionalNullableSafePositiveInteger(ownValue(value, 'size')) &&
+                isOptionalNullableBoolean(ownValue(value, 'hidden')) &&
+                isOptionalNullableBoolean(ownValue(value, 'filterHidden')));
         case 'setFreezePane':
             return hasString(value, 'sheetName') && hasSafeNonNegativeInteger(value, 'rows') && hasSafeNonNegativeInteger(value, 'cols');
         case 'clearFreezePane':
             return hasString(value, 'sheetName');
         case 'mergeCells':
         case 'unmergeCells':
-            return isCellRangeRef(value['range']);
+            return isCellRangeRef(ownValue(value, 'range'));
         case 'setSheetProtection':
-            return isWorkbookSheetProtection(value['protection']);
+            return isWorkbookSheetProtection(ownValue(value, 'protection'));
         case 'clearSheetProtection':
             return hasString(value, 'sheetName');
         case 'setFilter':
         case 'clearFilter':
         case 'clearSort':
-            return hasString(value, 'sheetName') && isCellRangeRef(value['range']);
+            return hasString(value, 'sheetName') && isCellRangeRef(ownValue(value, 'range'));
         case 'setSort':
-            return (hasString(value, 'sheetName') &&
-                isCellRangeRef(value['range']) &&
-                Array.isArray(value['keys']) &&
-                value['keys'].every((entry) => isWorkbookSortKey(entry)));
+            return (hasString(value, 'sheetName') && isCellRangeRef(ownValue(value, 'range')) && arrayEvery(ownValue(value, 'keys'), isWorkbookSortKey));
         case 'setDataValidation':
-            return isWorkbookDataValidation(value['validation']);
+            return isWorkbookDataValidation(ownValue(value, 'validation'));
         case 'clearDataValidation':
-            return hasString(value, 'sheetName') && isCellRangeRef(value['range']);
+            return hasString(value, 'sheetName') && isCellRangeRef(ownValue(value, 'range'));
         case 'upsertConditionalFormat':
-            return isWorkbookConditionalFormat(value['format']);
+            return isWorkbookConditionalFormat(ownValue(value, 'format'));
         case 'deleteConditionalFormat':
             return hasString(value, 'id') && hasString(value, 'sheetName');
         case 'setConditionalFormatArtifacts':
-            return hasString(value, 'sheetName') && isConditionalFormatArtifacts(value['artifacts']);
+            return hasString(value, 'sheetName') && isConditionalFormatArtifacts(ownValue(value, 'artifacts'));
         case 'clearConditionalFormatArtifacts':
             return hasString(value, 'sheetName');
         case 'upsertRangeProtection':
-            return isWorkbookRangeProtection(value['protection']);
+            return isWorkbookRangeProtection(ownValue(value, 'protection'));
         case 'deleteRangeProtection':
             return hasString(value, 'id') && hasString(value, 'sheetName');
         case 'upsertCommentThread':
-            return isWorkbookCommentThread(value['thread']);
+            return isWorkbookCommentThread(ownValue(value, 'thread'));
         case 'deleteCommentThread':
         case 'deleteNote':
         case 'deleteHyperlink':
             return hasString(value, 'sheetName') && hasString(value, 'address');
         case 'upsertNote':
-            return isWorkbookNote(value['note']);
+            return isWorkbookNote(ownValue(value, 'note'));
         case 'upsertHyperlink':
-            return isWorkbookHyperlink(value['hyperlink']);
+            return isWorkbookHyperlink(ownValue(value, 'hyperlink'));
         case 'setCellValue':
             return (hasString(value, 'sheetName') &&
                 hasString(value, 'address') &&
-                isLiteralInput(value['value']) &&
-                (value['authoredBlank'] === undefined || typeof value['authoredBlank'] === 'boolean'));
+                isLiteralInput(ownValue(value, 'value')) &&
+                (ownValue(value, 'authoredBlank') === undefined || typeof ownValue(value, 'authoredBlank') === 'boolean'));
         case 'setCellFormula':
             return hasString(value, 'sheetName') && hasString(value, 'address') && hasString(value, 'formula');
         case 'setCellFormat':
-            return (hasString(value, 'sheetName') && hasString(value, 'address') && (value['format'] === null || typeof value['format'] === 'string'));
+            return (hasString(value, 'sheetName') &&
+                hasString(value, 'address') &&
+                (ownValue(value, 'format') === null || typeof ownValue(value, 'format') === 'string'));
         case 'upsertCellStyle':
-            return isCellStyleRecord(value['style']);
+            return isCellStyleRecord(ownValue(value, 'style'));
         case 'upsertCellNumberFormat':
-            return isCellNumberFormatRecord(value['format']);
+            return isCellNumberFormatRecord(ownValue(value, 'format'));
         case 'setStyleRange':
-            return isCellRangeRef(value['range']) && hasString(value, 'styleId');
+            return isCellRangeRef(ownValue(value, 'range')) && hasString(value, 'styleId');
         case 'setFormatRange':
-            return isCellRangeRef(value['range']) && hasString(value, 'formatId');
+            return isCellRangeRef(ownValue(value, 'range')) && hasString(value, 'formatId');
         case 'clearCell':
             return hasString(value, 'sheetName') && hasString(value, 'address');
         case 'upsertDefinedName':
-            return hasString(value, 'name') && isWorkbookDefinedNameValue(value['value']);
+            return hasString(value, 'name') && isWorkbookDefinedNameValue(ownValue(value, 'value'));
         case 'deleteDefinedName':
         case 'deleteTable':
             return hasString(value, 'name');
         case 'upsertTable':
-            return isWorkbookTableOp(value['table']);
+            return isWorkbookTableOp(ownValue(value, 'table'));
         case 'upsertSpillRange':
             return (hasString(value, 'sheetName') &&
                 hasString(value, 'address') &&
@@ -631,22 +636,21 @@ export function isWorkbookOp(value) {
             return (hasString(value, 'name') &&
                 hasString(value, 'sheetName') &&
                 hasString(value, 'address') &&
-                isCellRangeRef(value['source']) &&
-                isStringArray(value['groupBy']) &&
-                Array.isArray(value['values']) &&
-                value['values'].every((entry) => isWorkbookPivotValue(entry)) &&
+                isCellRangeRef(ownValue(value, 'source')) &&
+                isStringArray(ownValue(value, 'groupBy')) &&
+                arrayEvery(ownValue(value, 'values'), isWorkbookPivotValue) &&
                 hasSafePositiveInteger(value, 'rows') &&
                 hasSafePositiveInteger(value, 'cols'));
         case 'upsertChart':
-            return isWorkbookChart(value['chart']);
+            return isWorkbookChart(ownValue(value, 'chart'));
         case 'deleteChart':
             return hasString(value, 'id');
         case 'upsertImage':
-            return isWorkbookImage(value['image']);
+            return isWorkbookImage(ownValue(value, 'image'));
         case 'deleteImage':
             return hasString(value, 'id');
         case 'upsertShape':
-            return isWorkbookShape(value['shape']);
+            return isWorkbookShape(ownValue(value, 'shape'));
         case 'deleteShape':
             return hasString(value, 'id');
         default:
@@ -657,14 +661,17 @@ export function isEngineOp(value) {
     return isWorkbookOp(value);
 }
 export function isEngineOps(value) {
-    return Array.isArray(value) && value.every((entry) => isEngineOp(entry));
+    return arrayEvery(value, isEngineOp);
 }
 export function isEngineOpBatch(value) {
-    return (isRecord(value) &&
-        hasString(value, 'id') &&
+    if (!isRecord(value)) {
+        return false;
+    }
+    const clock = ownValue(value, 'clock');
+    return (hasString(value, 'id') &&
         hasString(value, 'replicaId') &&
-        isRecord(value['clock']) &&
-        hasSafeNonNegativeInteger(value['clock'], 'counter') &&
-        isEngineOps(value['ops']));
+        isRecord(clock) &&
+        hasSafeNonNegativeInteger(clock, 'counter') &&
+        isEngineOps(ownValue(value, 'ops')));
 }
 //# sourceMappingURL=guards.js.map