@es-joy/jsoe 0.13.7 → 0.14.0

package/src/fundamentalTypes/fileType.js

@@ -132,7 +132,7 @@ function binaryButton (value, editable) {
                 ['textarea', {
                   class: 'view-binary'
                 }, [
-                  /* c8 ignore next */
+                  /* istanbul ignore next */
                   /** @type {string|null} */ (reader.result) ?? ''
                 ]]
               ])]
@@ -140,12 +140,13 @@ function binaryButton (value, editable) {
           });
         });
         // Seems not feasible to accurately simulate
-        /* c8 ignore next 10 */
         reader.addEventListener(
           'error',
-          /* c8 ignore next 6 */
+          /* istanbul ignore next */
           async function () {
+            /* istanbul ignore next */
             console.error(reader.error);
+            /* istanbul ignore next */
             await dialogs.alert(/** @type {string} */ (
               /** @type {DOMException} */ (reader.error).message
             ));
@@ -224,18 +225,19 @@ const fileType = {
               'Text source',
               ['br'],
               ['textarea', {class: 'view-text'}, [
-                /* c8 ignore next */
+                /* istanbul ignore next */
                 /** @type {string|null} */ (reader.result) ?? ''
               ]]
             ]));
           });
           // Seems not feasible to accurately simulate
-          /* c8 ignore next 10 */
           reader.addEventListener(
             'error',
-            /* c8 ignore next 6 */
+            /* istanbul ignore next */
             function () {
+              /* istanbul ignore next */
               console.error(reader.error);
+              /* istanbul ignore next */
               div.append(
                 /** @type {DOMException} */ (reader.error).message
               );
@@ -548,7 +550,7 @@ const fileType = {
                * @this {HTMLInputElement}
                */
               change () {
-                /* c8 ignore next 3 -- TS */
+                /* istanbul ignore if -- TS */
                 if (!this.files) {
                   return;
                 }
@@ -696,7 +698,7 @@ const fileType = {
 
                   if (constraints) {
                     const mediaStream = await getUserMedia(constraints);
-                    /* c8 ignore next 4 */
+                    /* istanbul ignore if */
                     if (!mediaStream) {
                       await dialogs.alert('Error getting user media');
                       return;
@@ -744,7 +746,7 @@ const fileType = {
                     const mediaStream = await startScreenCapture(
                       screenShareConstraints
                     );
-                    /* c8 ignore next 4 */
+                    /* istanbul ignore if */
                     if (!mediaStream) {
                       await dialogs.alert('Error getting user media');
                       return;
@@ -829,7 +831,7 @@ const fileType = {
                     'video.previewMedia'
                   ));
 
-                /* c8 ignore next 4 */
+                /* istanbul ignore if */
                 if (!previewMedia.srcObject) {
                   dialogs.alert('No stream found to record');
                   return;
@@ -862,7 +864,7 @@ const fileType = {
 
                 try {
                   mediaRecorder.start();
-                /* c8 ignore next 4 */
+                /* istanbul ignore if */
                 } catch (err) {
                   dialogs.alert('Error starting media recorder');
                   return;
@@ -1002,7 +1004,7 @@ const fileType = {
                   ($e(videoContainer, 'img.photo'));
 
                 canvas.toBlob((blob) => {
-                  /* c8 ignore next 4 */
+                  /* istanbul ignore if */
                   if (!blob) {
                     dialogs.alert('Error converting canvas to Blob');
                     return;

package/src/fundamentalTypes/filelistType.js

@@ -12,7 +12,9 @@ const filelistType = {
   stringRegexEnd: /^\)/u,
 
   toValue (...args) {
-    return arrayType.toValue.apply(this, args);
+    return /** @type {import('../types.js').ToValue} */ (
+      arrayType.toValue
+    ).apply(this, args);
   },
   getValue (...args) {
     return arrayType.getValue.apply(this, args);

package/src/fundamentalTypes/mapType.js

@@ -11,7 +11,9 @@ const mapType = {
   stringRegexBegin: /^Map\(/u,
   stringRegexEnd: /^\)/u,
   toValue (...args) {
-    return arrayType.toValue.apply(this, args);
+    return /** @type {import('../types.js').ToValue} */ (
+      arrayType.toValue
+    ).apply(this, args);
   },
   getValue (...args) {
     return arrayType.getValue.apply(this, args);

package/src/fundamentalTypes/noneditableType.js

@@ -0,0 +1,87 @@
+import {toStringTag} from '../vendor-imports.js';
+import {$e} from '../utils/templateUtils.js';
+
+/**
+ * @type {import('../types.js').TypeObject}
+ */
+const noneditableType = {
+  // Ideally, we would remove the option,
+  //   but edit forms currently need a pull-down option
+  option: ['Non-editable'],
+  getInput ({root}) {
+    return /** @type {HTMLButtonElement} */ ($e(root, 'button'));
+  },
+  setValue ({root, value}) {
+    /** @type {HTMLButtonElement & {$value: any}} */ (
+      this.getInput({root})
+    ).$value = value;
+    /** @type {HTMLSpanElement} */ (
+      $e(root, '.stringTag')
+    ).textContent = value === undefined
+      ? '(None)'
+      : toStringTag(value);
+  },
+  getValue ({root}) {
+    return /** @type {HTMLButtonElement & {$value: any}} */ (
+      this.getInput({root})
+    ).$value;
+  },
+  validate ({root}) {
+    const val = /** @type {HTMLButtonElement & {$value: any}} */ (
+      this.getInput({root})
+    ).$value;
+    return {
+      message: 'The non-editable type is only for passing on ' +
+        'pre-existing content that is unknown or currently unsupported',
+      valid: val !== undefined
+    };
+  },
+  viewUI ({value}) {
+    return ['div', {dataset: {type: 'resurrectable'}}, [
+      ['b', {class: 'emphasis'}, ['Non-editable']],
+      ['span', {
+        title: 'There is no current support for editing this element\'s ' +
+          'type, but its contents will be passed on transparently.'
+      }, ['?']],
+      ['b', ['String tag: ']],
+      toStringTag(value)
+    ]];
+  },
+  editUI ({typeNamespace, value}) {
+    return ['div', {dataset: {type: 'resurrectable'}}, [
+      ['a', {
+        // eslint-disable-next-line no-script-url -- Safe
+        href: 'javascript:void(0)',
+        $on: {
+          click (e) {
+            e.preventDefault();
+          }
+        },
+        title: 'There is no current support for editing this element\'s ' +
+          'type, but its contents will be passed on transparently.'
+      }, ['?']],
+      ' ',
+      ['button', {
+        $on: {
+          click (e) {
+            e.preventDefault();
+            console.log(/** @type {HTMLButtonElement & {$value: any}} */ (
+              this
+            ).$value);
+          }
+        },
+        name: `${typeNamespace}-resurrectable`,
+        $custom: {
+          $value: value
+        }
+      }, [
+        'Non-editable'
+      ]],
+      ['br'],
+      ['b', ['String tag: ']],
+      ['span', {class: 'stringTag'}, [value ? toStringTag(value) : '(None)']]
+    ]];
+  }
+};
+
+export default noneditableType;

package/src/fundamentalTypes/objectReferenceType.js

@@ -8,7 +8,9 @@ const objectReferenceType = {
   type: 'object',
   stringRegex: /^objectRef\((?:|\/[^)]*)\)$/u,
   toValue (...args) {
-    return arrayReferenceType.toValue.apply(this, args);
+    return /** @type {import('../types.js').ToValue} */ (
+      arrayReferenceType.toValue
+    ).apply(this, args);
   },
   resolveReference (...args) {
     return arrayReferenceType.resolveReference?.apply(

package/src/fundamentalTypes/objectType.js

@@ -9,7 +9,9 @@ const objectType = {
   stringRegexBegin: /^\{/u,
   stringRegexEnd: /^\}/u,
   toValue (...args) {
-    return arrayType.toValue.apply(this, args);
+    return /** @type {import('../types.js').ToValue} */ (
+      arrayType.toValue
+    ).apply(this, args);
   },
   getValue (...args) {
     return arrayType.getValue.apply(this, args);

package/src/fundamentalTypes/setType.js

@@ -11,7 +11,9 @@ const setType = {
   stringRegexBegin: /^Set\(/u,
   stringRegexEnd: /^\)/u,
   toValue (...args) {
-    return arrayType.toValue.apply(this, args);
+    return /** @type {import('../types.js').ToValue} */ (
+      arrayType.toValue
+    ).apply(this, args);
   },
   getValue (...args) {
     return arrayType.getValue.apply(this, args);

package/src/fundamentalTypes/sparseUndefinedType.js

@@ -18,7 +18,9 @@ const sparseUndefinedType = {
     return {value: undefined};
   },
   getValue () {
-    return this.toValue('').value;
+    return /** @type {import('../types.js').ToValue} */ (
+      this.toValue
+    )('').value;
   },
   /* istanbul ignore next -- Catching instead of this placeholder */
   viewUI (/* {value} */) {

package/src/fundamentalTypes/undefinedType.js

@@ -10,7 +10,9 @@ const undefinedType = {
     return {value: undefined};
   },
   getValue () {
-    return this.toValue('').value;
+    return /** @type {import('../types.js').ToValue} */ (
+      this.toValue
+    )('').value;
   },
   viewUI (/* {value} */) {
     return ['i', {dataset: {type: 'undef'}}, ['undefined']];

package/src/subTypes/blobHTMLType.js

@@ -58,7 +58,7 @@ const blobHTMLType = {
     );
   },
   getValue ({root}) {
-    return this.toValue(
+    return /** @type {import('../types.js').ToValue} */ (this.toValue)(
       'data:text/html,' + /** @type {SCEditorTextarea} */ (
         this.getInput({root})
       ).sceditorInstance.val()

package/src/superTypes/SpecialNumberType.js

@@ -1,13 +1,7 @@
 import {$e} from '../utils/templateUtils.js';
 
 /**
- * @typedef {import('../types.js').TypeObject & {
- *   childTypes: string[]
- * }} SuperTypeObject
- */
-
-/**
- * @type {SuperTypeObject}
+ * @type {import('../types.js').SuperTypeObject}
  */
 const SpecialNumberSuperType = {
   option: ['Special Number', {title: '`NaN`, `Infinity`, `-Infinity`, `-0`'}],
@@ -32,7 +26,7 @@ const SpecialNumberSuperType = {
     return /** @type {HTMLSelectElement} */ ($e(root, 'select'));
   },
   getValue ({root}) {
-    return this.toValue(
+    return /** @type {import('../types.js').ToValue} */ (this.toValue)(
       /** @type {Required<import('../types.js').TypeObject>} */ (
         this
       ).getSelect({root}).value

package/src/superTypes/SpecialRealNumberType.js

@@ -1,7 +1,7 @@
 import {$e} from '../utils/templateUtils.js';
 
 /**
- * @type {import('./SpecialNumberType.js').SuperTypeObject}
+ * @type {import('../types.js').SuperTypeObject}
  */
 const SpecialRealNumberSuperType = {
   option: ['Special Real Number', {title: '`Infinity`, `-Infinity`, `-0`'}],
@@ -20,7 +20,7 @@ const SpecialRealNumberSuperType = {
     return /** @type {HTMLSelectElement} */ ($e(root, 'select'));
   },
   getValue ({root}) {
-    return this.toValue(
+    return /** @type {import('../types.js').ToValue} */ (this.toValue)(
       /** @type {Required<import('../types.js').TypeObject>} */ (
         this
       ).getSelect({root}).value

package/src/{fundamentalTypes → superTypes}/dommatrixType.js

@@ -1,19 +1,31 @@
 import {$e} from '../utils/templateUtils.js';
+import {toStringTag} from '../vendor-imports.js';
 
 let idx = 0;
 
 /**
- * @type {import('../types.js').TypeObject}
+ * @type {import('../types.js').SuperTypeObject}
  */
 const dommatrixType = {
   option: ['DOMMatrix'],
-  stringRegex: /^DOMMatrix\((.*)\)$/u,
-  toValue (s) {
+  childTypes: ['dommatrixreadonly'],
+  stringRegex: /^(?<domMatrixClass>DOMMatrix|DOMMatrixReadOnly)\((?<innerContent>.*)\)$/u,
+  toValue (s, rootInfo) {
+    const {groups: {
+      domMatrixClass
+    /* istanbul ignore next -- Should always be found */
+    } = {}} = /** @type {RegExpMatchArray} */ (
+      /** @type {import('../types.js').RootInfo} */ (rootInfo).match
+    );
     const o = JSON.parse(s);
 
+    const DOMMatrixClass = domMatrixClass === 'DOMMatrix'
+      ? DOMMatrix
+      : DOMMatrixReadOnly;
+
     const dommatrix = Object.hasOwn(o, 'a')
-      ? new DOMMatrix([o.a, o.b, o.c, o.d, o.e, o.f])
-      : new DOMMatrix([
+      ? new DOMMatrixClass([o.a, o.b, o.c, o.d, o.e, o.f])
+      : new DOMMatrixClass([
         o.m11, o.m12, o.m13, o.m14,
         o.m21, o.m22, o.m23, o.m24,
         o.m31, o.m32, o.m33, o.m34,
@@ -23,7 +35,7 @@ const dommatrixType = {
     return {value: dommatrix};
   },
   getInput ({root}) {
-    return /** @type {HTMLInputElement} */ ($e(root, 'input'));
+    return /** @type {HTMLInputElement} */ ($e(root, 'input:not([type])'));
   },
   setValue ({root, value: o}) {
     const {is2D} = o;
@@ -109,8 +121,23 @@ const dommatrixType = {
         $e(root, '.m44')
       ).value = o.m44;
     }
+
+    if (toStringTag(o) === 'DOMMatrix') {
+      /** @type {HTMLInputElement} */ (
+        $e(root, '.dommatrix-readonly-readwrite')
+      ).checked = true;
+    } else {
+      /** @type {HTMLInputElement} */ (
+        $e(root, '.dommatrix-readonly-readonly')
+      ).checked = true;
+    }
   },
   getValue ({root}) {
+    const isReadWrite = /** @type {HTMLInputElement} */ (
+      $e(root, '.dommatrix-readonly-readwrite')
+    ).checked;
+    const DOMMatrixClass = isReadWrite ? DOMMatrix : DOMMatrixReadOnly;
+
     const aType = /** @type {HTMLInputElement} */ (
       $e(root, '.a')
     ).value;
@@ -132,7 +159,7 @@ const dommatrixType = {
       const f = Number(/** @type {HTMLInputElement} */ (
         $e(root, '.f')
       ).value);
-      return new DOMMatrix([a, b, c, d, e, f]);
+      return new DOMMatrixClass([a, b, c, d, e, f]);
     }
 
     const m11 = Number(/** @type {HTMLInputElement} */ (
@@ -187,7 +214,7 @@ const dommatrixType = {
       $e(root, '.m44')
     ).value);
 
-    return new DOMMatrix([
+    return new DOMMatrixClass([
       m11, m12, m13, m14,
       m21, m22, m23, m24,
       m31, m32, m33, m34,
@@ -195,8 +222,11 @@ const dommatrixType = {
     ]);
   },
   viewUI ({value}) {
+    const isReadWrite = toStringTag(value) === 'DOMMatrix';
     return ['div', {dataset: {type: 'dommatrix'}}, [
-      ['b', {class: 'emphasis'}, ['DOMMatrix']],
+      ['b', {class: 'emphasis'}, [
+        isReadWrite ? 'DOMMatrix' : 'DOMMatrixReadOnly'
+      ]],
       value.is2D
         ? ['div', [
           ['b', ['a ']],
@@ -276,11 +306,34 @@ const dommatrixType = {
     const {is2D} = value;
     // eslint-disable-next-line @stylistic/max-len -- Long
     return ['div', {dataset: {type: 'dommatrix'}}, /** @type {import('jamilih').JamilihChildren} */ ([
+      ['div', [
+        ['label', [
+          ['input', {
+            type: 'radio',
+            class: 'dommatrix-readonly-readwrite',
+            name: `${typeNamespace}-dommatrix-readonly-${idx}`,
+            value: 'readwrite',
+            checked: toStringTag(value) !== 'DOMMatrixReadOnly'
+          }],
+          'Readwrite'
+        ]],
+        ' ',
+        ['label', [
+          ['input', {
+            type: 'radio',
+            class: 'dommatrix-readonly-readonly',
+            name: `${typeNamespace}-dommatrix-readonly-${idx}`,
+            value: 'readonly',
+            checked: toStringTag(value) === 'DOMMatrixReadOnly'
+          }],
+          'Read-only'
+        ]]
+      ]],
       ['div', {
         $on: {
           click (e) {
             const {target} = e;
-            /* c8 ignore next 3 */
+            /* istanbul ignore if */
             if (/** @type {HTMLInputElement} */ (target).type !== 'radio') {
               return;
             }

package/src/{fundamentalTypes → superTypes}/dompointType.js

@@ -1,17 +1,29 @@
 import {$e} from '../utils/templateUtils.js';
+import {toStringTag} from '../vendor-imports.js';
+
+let idx = 0;
 
 /**
- * @type {import('../types.js').TypeObject}
+ * @type {import('../types.js').SuperTypeObject}
  */
 const dompointType = {
   option: ['DOMPoint'],
-  stringRegex: /^DOMPoint\((.*)\)$/u,
-  toValue (s) {
+  childTypes: ['dompointreadonly'],
+  stringRegex: /^(?<domPointClass>DOMPoint|DOMPointReadOnly)\((?<innerContent>.*)\)$/u,
+  toValue (s, rootInfo) {
+    const {groups: {
+      domPointClass
+    /* istanbul ignore next -- Should always be found */
+    } = {}} = /** @type {RegExpMatchArray} */ (
+      /** @type {import('../types.js').RootInfo} */ (rootInfo).match
+    );
     const {x, y, z, w} = JSON.parse(s);
-    return {value: new DOMPoint(x, y, z, w)};
+    return {value: new (
+      domPointClass === 'DOMPoint' ? DOMPoint : DOMPointReadOnly
+    )(x, y, z, w)};
   },
   getInput ({root}) {
-    return /** @type {HTMLInputElement} */ ($e(root, 'input'));
+    return /** @type {HTMLInputElement} */ ($e(root, 'input:not([type])'));
   },
   setValue ({root, value}) {
     /** @type {HTMLInputElement} */ (
@@ -26,6 +38,16 @@ const dompointType = {
     /** @type {HTMLInputElement} */ (
       $e(root, '.w')
     ).value = String(value.w);
+
+    if (toStringTag(value) === 'DOMPoint') {
+      /** @type {HTMLInputElement} */ (
+        $e(root, '.dompoint-readonly-readwrite')
+      ).checked = true;
+    } else {
+      /** @type {HTMLInputElement} */ (
+        $e(root, '.dompoint-readonly-readonly')
+      ).checked = true;
+    }
   },
   getValue ({root}) {
     const x = Number(/** @type {HTMLInputElement} */ (
@@ -40,11 +62,18 @@ const dompointType = {
     const w = Number(/** @type {HTMLInputElement} */ (
       $e(root, '.w')
     ).value);
-    return new DOMPoint(x, y, z, w);
+
+    const isReadWrite = /** @type {HTMLInputElement} */ (
+      $e(root, '.dompoint-readonly-readwrite')
+    ).checked;
+    return new (isReadWrite ? DOMPoint : DOMPointReadOnly)(x, y, z, w);
   },
   viewUI ({value}) {
+    const isReadWrite = toStringTag(value) === 'DOMPoint';
     return ['div', {dataset: {type: 'dompoint'}}, [
-      ['b', {class: 'emphasis'}, ['DOMPoint']],
+      ['b', {class: 'emphasis'}, [
+        isReadWrite ? 'DOMPoint' : 'DOMPointReadOnly'
+      ]],
       ['br'],
       ['b', ['x ']],
       value.x,
@@ -65,8 +94,32 @@ const dompointType = {
     z: '',
     w: ''
   }}) {
+    idx++;
     // eslint-disable-next-line @stylistic/max-len -- Long
     return ['div', {dataset: {type: 'dompoint'}}, /** @type {import('jamilih').JamilihChildren} */ ([
+      ['div', [
+        ['label', [
+          ['input', {
+            type: 'radio',
+            class: 'dompoint-readonly-readwrite',
+            name: `${typeNamespace}-dompoint-readonly-${idx}`,
+            value: 'readwrite',
+            checked: toStringTag(value) !== 'DOMPointReadOnly'
+          }],
+          'Readwrite'
+        ]],
+        ' ',
+        ['label', [
+          ['input', {
+            type: 'radio',
+            class: 'dompoint-readonly-readonly',
+            name: `${typeNamespace}-dompoint-readonly-${idx}`,
+            value: 'readonly',
+            checked: toStringTag(value) === 'DOMPointReadOnly'
+          }],
+          'Read-only'
+        ]]
+      ]],
       ['label', [
         'x: ',
         ['input', {

package/src/{fundamentalTypes → superTypes}/domrectType.js

@@ -1,17 +1,30 @@
 import {$e} from '../utils/templateUtils.js';
+import {toStringTag} from '../vendor-imports.js';
+
+let idx = 0;
 
 /**
- * @type {import('../types.js').TypeObject}
+ * @type {import('../types.js').SuperTypeObject}
  */
 const domrectType = {
   option: ['DOMRect'],
-  stringRegex: /^DOMRect\((.*)\)$/u,
-  toValue (s) {
+  childTypes: ['domrectreadonly'],
+  stringRegex: /^(?<domRectClass>DOMRect|DOMRectReadOnly)\((?<innerContent>.*)\)$/u,
+  toValue (s, rootInfo) {
+    const {groups: {
+      domRectClass
+    /* istanbul ignore next -- Should always be found */
+    } = {}} = /** @type {RegExpMatchArray} */ (
+      /** @type {import('../types.js').RootInfo} */ (rootInfo).match
+    );
     const {x, y, width, height} = JSON.parse(s);
-    return {value: new DOMRect(x, y, width, height)};
+    return {
+      value: new (
+        domRectClass === 'DOMRect' ? DOMRect : DOMRectReadOnly
+      )(x, y, width, height)};
   },
   getInput ({root}) {
-    return /** @type {HTMLInputElement} */ ($e(root, 'input'));
+    return /** @type {HTMLInputElement} */ ($e(root, 'input:not([type])'));
   },
   setValue ({root, value}) {
     /** @type {HTMLInputElement} */ (
@@ -26,6 +39,16 @@ const domrectType = {
     /** @type {HTMLInputElement} */ (
       $e(root, '.height')
     ).value = String(value.height);
+
+    if (toStringTag(value) === 'DOMRect') {
+      /** @type {HTMLInputElement} */ (
+        $e(root, '.domrect-readonly-readwrite')
+      ).checked = true;
+    } else {
+      /** @type {HTMLInputElement} */ (
+        $e(root, '.domrect-readonly-readonly')
+      ).checked = true;
+    }
   },
   getValue ({root}) {
     const x = Number(/** @type {HTMLInputElement} */ (
@@ -40,11 +63,16 @@ const domrectType = {
     const height = Number(/** @type {HTMLInputElement} */ (
       $e(root, '.height')
     ).value);
-    return new DOMRect(x, y, width, height);
+
+    const isReadWrite = /** @type {HTMLInputElement} */ (
+      $e(root, '.domrect-readonly-readwrite')
+    ).checked;
+    return new (isReadWrite ? DOMRect : DOMRectReadOnly)(x, y, width, height);
   },
   viewUI ({value}) {
+    const isReadWrite = toStringTag(value) === 'DOMRect';
     return ['div', {dataset: {type: 'domrect'}}, [
-      ['b', {class: 'emphasis'}, ['DOMRect']],
+      ['b', {class: 'emphasis'}, [isReadWrite ? 'DOMRect' : 'DOMRectReadOnly']],
       ['br'],
       ['b', ['x ']],
       value.x,
@@ -65,8 +93,32 @@ const domrectType = {
     width: '',
     height: ''
   }}) {
+    idx++;
     // eslint-disable-next-line @stylistic/max-len -- Long
     return ['div', {dataset: {type: 'domrect'}}, /** @type {import('jamilih').JamilihChildren} */ ([
+      ['div', [
+        ['label', [
+          ['input', {
+            type: 'radio',
+            class: 'domrect-readonly-readwrite',
+            name: `${typeNamespace}-domrect-readonly-${idx}`,
+            value: 'readwrite',
+            checked: toStringTag(value) !== 'DOMRectReadOnly'
+          }],
+          'Readwrite'
+        ]],
+        ' ',
+        ['label', [
+          ['input', {
+            type: 'radio',
+            class: 'domrect-readonly-readonly',
+            name: `${typeNamespace}-domrect-readonly-${idx}`,
+            value: 'readonly',
+            checked: toStringTag(value) === 'DOMRectReadOnly'
+          }],
+          'Read-only'
+        ]]
+      ]],
       ['label', [
         'x: ',
         ['input', {

package/src/superTypes/errorsSpecialType.js

@@ -44,7 +44,7 @@ if (typeof InternalError !== 'undefined') {
 const specialErrors = [...specialErrorsMap.keys()];
 
 /**
- * @type {import('./SpecialNumberType.js').SuperTypeObject}
+ * @type {import('../types.js').SuperTypeObject}
  */
 const errorsSpecialType = {
   option: ['Special errors'],