@atlaspack/utils 2.17.3 → 2.17.4-typescript-17c3d1dec.0

package/lib/index.js

@@ -3,6 +3,84 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  resolveConfig: true,
+  resolveConfigSync: true,
+  loadConfig: true,
+  readConfig: true,
+  makeDeferredWithPromise: true,
+  generateBuildMetrics: true,
+  createHTTPServer: true,
+  normalizePath: true,
+  normalizeSeparators: true,
+  relativePath: true,
+  prettyDiagnostic: true,
+  validateSchema: true,
+  fuzzySearch: true,
+  countLines: true,
+  generateCertificate: true,
+  getCertificate: true,
+  getModuleParts: true,
+  getRootDir: true,
+  isDirectoryInside: true,
+  isURL: true,
+  objectHash: true,
+  prettifyTime: true,
+  PromiseQueue: true,
+  TapStream: true,
+  urlJoin: true,
+  relativeUrl: true,
+  createDependencyLocation: true,
+  debounce: true,
+  throttle: true,
+  openInBrowser: true,
+  findAlternativeNodeModules: true,
+  findAlternativeFiles: true,
+  blobToBuffer: true,
+  blobToString: true,
+  unique: true,
+  objectSortedEntries: true,
+  objectSortedEntriesDeep: true,
+  setDifference: true,
+  setSymmetricDifference: true,
+  setEqual: true,
+  setIntersect: true,
+  setIntersectStatic: true,
+  setUnion: true,
+  debugTools: true,
+  DefaultMap: true,
+  DefaultWeakMap: true,
+  getProgressMessage: true,
+  getPackageProgressMessage: true,
+  isGlob: true,
+  isGlobMatch: true,
+  globMatch: true,
+  globSync: true,
+  glob: true,
+  globToRegex: true,
+  hashStream: true,
+  hashObject: true,
+  hashFile: true,
+  SharedBuffer: true,
+  replaceURLReferences: true,
+  replaceInlineReferences: true,
+  measureStreamLength: true,
+  readableFromStringOrBuffer: true,
+  bufferStream: true,
+  blobToStream: true,
+  streamFromPromise: true,
+  fallbackStream: true,
+  relativeBundlePath: true,
+  ansiHtml: true,
+  escapeHTML: true,
+  SOURCEMAP_RE: true,
+  SOURCEMAP_EXTENSIONS: true,
+  matchSourceMappingURL: true,
+  loadSourceMapUrl: true,
+  loadSourceMap: true,
+  remapSourceLocation: true,
+  stripAnsi: true
+};
 Object.defineProperty(exports, "DefaultMap", {
   enumerable: true,
   get: function () {
@@ -459,8 +537,91 @@ Object.defineProperty(exports, "validateSchema", {
     return _schema.default;
   }
 });
+var _config = require("./config");
+Object.keys(_config).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _config[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _config[key];
+    }
+  });
+});
+var _Deferred = require("./Deferred");
+Object.keys(_Deferred).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Deferred[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Deferred[key];
+    }
+  });
+});
+var _generateBuildMetrics = _interopRequireWildcard(require("./generateBuildMetrics"));
+Object.keys(_generateBuildMetrics).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _generateBuildMetrics[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _generateBuildMetrics[key];
+    }
+  });
+});
+var _httpServer = require("./http-server");
+Object.keys(_httpServer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _httpServer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _httpServer[key];
+    }
+  });
+});
+var _path = require("./path");
+Object.keys(_path).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _path[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _path[key];
+    }
+  });
+});
+var _prettyDiagnostic = _interopRequireWildcard(require("./prettyDiagnostic"));
+Object.keys(_prettyDiagnostic).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _prettyDiagnostic[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _prettyDiagnostic[key];
+    }
+  });
+});
+var _schema = _interopRequireWildcard(require("./schema"));
+Object.keys(_schema).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _schema[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _schema[key];
+    }
+  });
+});
 var _countLines = _interopRequireDefault(require("./countLines"));
-var _generateBuildMetrics = _interopRequireDefault(require("./generateBuildMetrics"));
 var _generateCertificate = _interopRequireDefault(require("./generateCertificate"));
 var _getCertificate = _interopRequireDefault(require("./getCertificate"));
 var _getModuleParts = _interopRequireDefault(require("./getModuleParts"));
@@ -469,9 +630,7 @@ var _isDirectoryInside = _interopRequireDefault(require("./isDirectoryInside"));
 var _isUrl = _interopRequireDefault(require("./is-url"));
 var _objectHash = _interopRequireDefault(require("./objectHash"));
 var _prettifyTime = _interopRequireDefault(require("./prettifyTime"));
-var _prettyDiagnostic = _interopRequireDefault(require("./prettyDiagnostic"));
 var _PromiseQueue = _interopRequireDefault(require("./PromiseQueue"));
-var _schema = _interopRequireWildcard(require("./schema"));
 var _TapStream = _interopRequireDefault(require("./TapStream"));
 var _urlJoin = _interopRequireDefault(require("./urlJoin"));
 var _relativeUrl = _interopRequireDefault(require("./relativeUrl"));
@@ -482,16 +641,12 @@ var _openInBrowser = _interopRequireDefault(require("./openInBrowser"));
 var _alternatives = require("./alternatives");
 var _blob = require("./blob");
 var _collection = require("./collection");
-var _config = require("./config");
 var _debugTools = require("./debug-tools");
 var _DefaultMap = require("./DefaultMap");
-var _Deferred = require("./Deferred");
 var _progressMessage = require("./progress-message");
 var _glob = require("./glob");
 var _hash = require("./hash");
 var _sharedBuffer = require("./shared-buffer");
-var _httpServer = require("./http-server");
-var _path = require("./path");
 var _replaceBundleReferences = require("./replaceBundleReferences");
 var _stream = require("./stream");
 var _relativeBundlePath = require("./relativeBundlePath");
@@ -505,6 +660,6 @@ function _stripAnsi() {
   };
   return data;
 }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

package/lib/is-url.d.ts

@@ -0,0 +1 @@
+export default function isURL(url: string): boolean;

package/lib/is-url.js

@@ -12,6 +12,8 @@ function _isUrl() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS7016
+
 // Matches anchor (ie: #raptors)
 const ANCHOR_REGEXP = /^#/;
 

package/lib/isDirectoryInside.d.ts

@@ -0,0 +1,2 @@
+import type { FilePath } from '@atlaspack/types';
+export default function isDirectoryInside(child: FilePath, parent: FilePath): boolean;

package/lib/objectHash.d.ts

@@ -0,0 +1,3 @@
+type Hashable = any;
+export default function objectHash(object: Hashable): string;
+export {};

package/lib/objectHash.js

@@ -12,7 +12,6 @@ function _crypto() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// $FlowFixMe
 function objectHash(object) {
   let hash = _crypto().default.createHash('md5');
   for (let key of Object.keys(object).sort()) {

package/lib/openInBrowser.d.ts

@@ -0,0 +1 @@
+export default function openInBrowser(url: string, browser: string): Promise<void>;

package/lib/parseCSSImport.d.ts

@@ -0,0 +1 @@
+export default function parseCSSImport(url: string): string;

package/lib/path.d.ts

@@ -0,0 +1,8 @@
+import type { FilePath } from '@atlaspack/types';
+export declare function isAbsolute(filepath: string): boolean;
+export declare function normalizeSeparators(filePath: FilePath): FilePath;
+export type PathOptions = {
+    noLeadingDotSlash?: boolean;
+};
+export declare function normalizePath(filePath: FilePath, leadingDotSlash?: boolean): FilePath;
+export declare function relativePath(from: string, to: string, leadingDotSlash?: boolean): FilePath;

package/lib/prettifyTime.d.ts

@@ -0,0 +1 @@
+export default function prettifyTime(timeInMs: number): string;

package/lib/prettyDiagnostic.d.ts

@@ -0,0 +1,17 @@
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import type { PluginOptions } from '@atlaspack/types';
+export type FormattedCodeFrame = {
+    location: string;
+    code: string;
+};
+export type AnsiDiagnosticResult = {
+    message: string;
+    stack: string;
+    /** A formatted string containing all code frames, including their file locations. */
+    codeframe: string;
+    /** A list of code frames with highlighted code and file locations separately. */
+    frames: Array<FormattedCodeFrame>;
+    hints: Array<string>;
+    documentation: string;
+};
+export default function prettyDiagnostic(diagnostic: Diagnostic, options?: PluginOptions, terminalWidth?: number, format?: 'ansi' | 'html'): Promise<AnsiDiagnosticResult>;

package/lib/prettyDiagnostic.js

@@ -47,10 +47,10 @@ function _snarkdown() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// $FlowFixMe
 /* eslint-disable import/no-extraneous-dependencies */
-// $FlowFixMe
+
 /* eslint-enable import/no-extraneous-dependencies */
+
 async function prettyDiagnostic(diagnostic, options, terminalWidth, format = 'ansi') {
   let {
     origin,
@@ -94,9 +94,7 @@ async function prettyDiagnostic(diagnostic, options, terminalWidth, format = 'an
         formattedCodeFrame = (0, _codeframe().default)(code, highlights, {
           useColor: true,
           syntaxHighlighting: true,
-          language:
-          // $FlowFixMe sketchy null checks do not matter here...
-          codeFrame.language || (filePath != null ? _path().default.extname(filePath).substr(1) : undefined),
+          language: codeFrame.language || (filePath != null ? _path().default.extname(filePath).substr(1) : undefined),
           terminalWidth
         });
       }

package/lib/progress-message.d.ts

@@ -0,0 +1,3 @@
+import type { BuildProgressEvent } from '@atlaspack/types';
+export declare function getProgressMessage(event: BuildProgressEvent): string | null | undefined;
+export declare function getPackageProgressMessage(completeBundles: number, totalBundles: number): string;

package/lib/relativeBundlePath.d.ts

@@ -0,0 +1,4 @@
+import type { FilePath, NamedBundle } from '@atlaspack/types';
+export declare function relativeBundlePath(from: NamedBundle, to: NamedBundle, opts?: {
+    leadingDotSlash: boolean;
+}): FilePath;

package/lib/relativeUrl.d.ts

@@ -0,0 +1 @@
+export default function relativeUrl(from: string, to: string): string;

package/lib/replaceBundleReferences.d.ts

@@ -0,0 +1,39 @@
+import type SourceMap from '@parcel/source-map';
+import type { Async, Blob, Bundle, BundleGraph, Dependency, NamedBundle } from '@atlaspack/types';
+export declare function replaceURLReferences({ bundle, bundleGraph, contents, map, getReplacement, relative, }: {
+    bundle: NamedBundle;
+    bundleGraph: BundleGraph<NamedBundle>;
+    contents: string;
+    relative?: boolean;
+    map?: SourceMap | null | undefined;
+    getReplacement?: (arg1: string) => string;
+}): {
+    readonly contents: string;
+    readonly map: SourceMap | null | undefined;
+};
+export declare function replaceInlineReferences({ bundle, bundleGraph, contents, map, getInlineReplacement, getInlineBundleContents, }: {
+    bundle: Bundle;
+    bundleGraph: BundleGraph<NamedBundle>;
+    contents: string;
+    getInlineReplacement: (arg1: Dependency, arg2: 'string' | null | undefined, arg3: string) => {
+        from: string;
+        to: string;
+    };
+    getInlineBundleContents: (arg1: Bundle, arg2: BundleGraph<NamedBundle>) => Async<{
+        contents: Blob;
+    }>;
+    map?: SourceMap | null | undefined;
+}): Promise<{
+    readonly contents: string;
+    readonly map: SourceMap | null | undefined;
+}>;
+export declare function getURLReplacement({ dependency, fromBundle, toBundle, relative, getReplacement, }: {
+    dependency: Dependency;
+    fromBundle: NamedBundle;
+    toBundle: NamedBundle;
+    relative: boolean;
+    getReplacement?: (arg1: string) => string;
+}): {
+    from: string;
+    to: string;
+};

package/lib/schema.d.ts

@@ -0,0 +1,107 @@
+import type { Mapping } from '@mischnic/json-sourcemap';
+export type SchemaEntity = SchemaObject | SchemaArray | SchemaBoolean | SchemaString | SchemaNumber | SchemaEnum | SchemaOneOf | SchemaAllOf | SchemaNot | SchemaAny;
+export type SchemaArray = {
+    type: 'array';
+    items?: SchemaEntity;
+    __type?: string;
+};
+export type SchemaBoolean = {
+    type: 'boolean';
+    __type?: string;
+};
+export type SchemaOneOf = {
+    oneOf: Array<SchemaEntity>;
+};
+export type SchemaAllOf = {
+    allOf: Array<SchemaEntity>;
+};
+export type SchemaNot = {
+    not: SchemaEntity;
+    __message: string;
+};
+export type SchemaString = {
+    type: 'string';
+    enum?: Array<string>;
+    __validate?: (val: string) => string | null | undefined;
+    __type?: string;
+};
+export type SchemaNumber = {
+    type: 'number';
+    enum?: Array<number>;
+    __type?: string;
+};
+export type SchemaEnum = {
+    enum: Array<unknown>;
+};
+export type SchemaObject = {
+    type: 'object';
+    properties: {
+        [key: string]: SchemaEntity;
+    };
+    additionalProperties?: boolean | SchemaEntity;
+    required?: Array<string>;
+    __forbiddenProperties?: Array<string>;
+    __type?: string;
+};
+export type SchemaAny = Record<any, any>;
+export type SchemaError = {
+    type: 'type';
+    expectedTypes: Array<string>;
+    dataType: 'key' | null | undefined | 'value';
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'enum';
+    expectedValues: Array<unknown>;
+    dataType: 'key' | 'value';
+    actualValue: unknown;
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'forbidden-prop';
+    prop: string;
+    expectedProps: Array<string>;
+    actualProps: Array<string>;
+    dataType: 'key';
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'missing-prop';
+    prop: string;
+    expectedProps: Array<string>;
+    actualProps: Array<string>;
+    dataType: 'key' | 'value';
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+    prettyType?: string;
+} | {
+    type: 'other';
+    actualValue: unknown;
+    dataType: 'key' | null | undefined | 'value';
+    message?: string;
+    dataPath: string;
+    ancestors: Array<SchemaEntity>;
+};
+declare function validateSchema(schema: SchemaEntity, data: unknown): Array<SchemaError>;
+declare namespace validateSchema {
+    var diagnostic: (schema: SchemaEntity, data: ({
+        source?: string | null | undefined;
+        data?: unknown;
+    } | {
+        source: string;
+        map: {
+            data: unknown;
+            pointers: {
+                [key: string]: Mapping;
+            };
+        };
+    }) & {
+        filePath?: string | null | undefined;
+        prependKey?: string | null | undefined;
+    }, origin: string, message: string) => undefined;
+}
+export default validateSchema;
+export declare function fuzzySearch(expectedValues: Array<string>, actualValue: string): Array<string>;

package/lib/schema.js

@@ -30,7 +30,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function validateSchema(schema, data) {
-  function walk(schemaAncestors, dataNode, dataPath) {
+  function walk(
+  // @ts-expect-error TS7006
+  schemaAncestors, dataNode, dataPath) {
     let [schemaNode] = schemaAncestors;
     if (schemaNode.type) {
       let type = Array.isArray(dataNode) ? 'array' : typeof dataNode;
@@ -49,10 +51,10 @@ function validateSchema(schema, data) {
             {
               if (schemaNode.items) {
                 let results = [];
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS18046
                 for (let i = 0; i < dataNode.length; i++) {
                   let result = walk([schemaNode.items].concat(schemaAncestors),
-                  // $FlowFixMe type was already checked
+                  // @ts-expect-error TS18046
                   dataNode[i], dataPath + '/' + i);
                   if (result) results.push(result);
                 }
@@ -62,7 +64,7 @@ function validateSchema(schema, data) {
             }
           case 'string':
             {
-              // $FlowFixMe type was already checked
+              // @ts-expect-error TS2322
               let value = dataNode;
               if (schemaNode.enum) {
                 if (!schemaNode.enum.includes(value)) {
@@ -92,7 +94,7 @@ function validateSchema(schema, data) {
             }
           case 'number':
             {
-              // $FlowFixMe type was already checked
+              // @ts-expect-error TS2322
               let value = dataNode;
               if (schemaNode.enum) {
                 if (!schemaNode.enum.includes(value)) {
@@ -113,10 +115,13 @@ function validateSchema(schema, data) {
               let results = [];
               let invalidProps;
               if (schemaNode.__forbiddenProperties) {
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS2769
                 let keys = Object.keys(dataNode);
+                // @ts-expect-error TS7006
                 invalidProps = schemaNode.__forbiddenProperties.filter(val => keys.includes(val));
-                results.push(...invalidProps.map(k => ({
+                results.push(...invalidProps.map(
+                // @ts-expect-error TS7006
+                k => ({
                   type: 'forbidden-prop',
                   dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
                   dataType: 'key',
@@ -127,10 +132,14 @@ function validateSchema(schema, data) {
                 })));
               }
               if (schemaNode.required) {
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS2769
                 let keys = Object.keys(dataNode);
-                let missingKeys = schemaNode.required.filter(val => !keys.includes(val));
-                results.push(...missingKeys.map(k => ({
+                let missingKeys = schemaNode.required.filter(
+                // @ts-expect-error TS7006
+                val => !keys.includes(val));
+                results.push(...missingKeys.map(
+                // @ts-expect-error TS7006
+                k => ({
                   type: 'missing-prop',
                   dataPath,
                   dataType: 'value',
@@ -144,14 +153,14 @@ function validateSchema(schema, data) {
                 let {
                   additionalProperties = true
                 } = schemaNode;
-                // $FlowFixMe type was already checked
+                // @ts-expect-error TS2407
                 for (let k in dataNode) {
                   if (invalidProps && invalidProps.includes(k)) {
                     // Don't check type on forbidden props
                     continue;
                   } else if (k in schemaNode.properties) {
                     let result = walk([schemaNode.properties[k]].concat(schemaAncestors),
-                    // $FlowFixMe type was already checked
+                    // @ts-expect-error TS18046
                     dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
                     if (result) results.push(result);
                   } else {
@@ -161,9 +170,9 @@ function validateSchema(schema, data) {
                           type: 'enum',
                           dataType: 'key',
                           dataPath: dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k),
-                          expectedValues: Object.keys(schemaNode.properties).filter(
-                          // $FlowFixMe type was already checked
-                          p => !(p in dataNode)),
+                          expectedValues: Object.keys(schemaNode.properties
+                          // @ts-expect-error TS18046
+                          ).filter(p => !(p in dataNode)),
                           actualValue: k,
                           ancestors: schemaAncestors,
                           prettyType: schemaNode.__type
@@ -171,7 +180,7 @@ function validateSchema(schema, data) {
                       }
                     } else {
                       let result = walk([additionalProperties].concat(schemaAncestors),
-                      // $FlowFixMe type was already checked
+                      // @ts-expect-error TS18046
                       dataNode[k], dataPath + '/' + (0, _diagnostic().encodeJSONKeyComponent)(k));
                       if (result) results.push(result);
                     }
@@ -213,6 +222,7 @@ function validateSchema(schema, data) {
         }
       } else if (schemaNode.not) {
         let result = walk([schemaNode.not].concat(schemaAncestors), dataNode, dataPath);
+        // @ts-expect-error TS2339
         if (!result || result.length == 0) {
           return {
             type: 'other',
@@ -234,16 +244,22 @@ var _default = exports.default = validateSchema;
 function fuzzySearch(expectedValues, actualValue) {
   let result = expectedValues.map(exp => [exp, levenshtein().distance(exp, actualValue)]).filter(
   // Remove if more than half of the string would need to be changed
+  // @ts-expect-error TS2769
   ([, d]) => d * 2 < actualValue.length);
+  // @ts-expect-error TS2345
   result.sort(([, a], [, b]) => a - b);
+  // @ts-expect-error TS2345
   return result.map(([v]) => v);
 }
 validateSchema.diagnostic = function (schema, data, origin, message) {
   if ('source' in data && 'data' in data && typeof data.source !== 'string' && !data) {
     throw new Error('At least one of data.source and data.data must be defined!');
   }
-  let object = data.map ? data.map.data :
-  // $FlowFixMe we can assume it's a JSON object
+  // @ts-expect-error TS2339
+  let object = data.map ?
+  // @ts-expect-error TS2339
+  data.map.data :
+  // @ts-expect-error TS2339
   data.data ?? JSON.parse(data.source);
   let errors = validateSchema(schema, object);
   if (errors.length) {
@@ -303,11 +319,13 @@ validateSchema.diagnostic = function (schema, data, origin, message) {
       };
     });
     let map, code;
+    // @ts-expect-error TS2339
     if (data.map) {
+      // @ts-expect-error TS2339
       map = data.map;
       code = data.source;
     } else {
-      // $FlowFixMe we can assume that data is valid JSON
+      // @ts-expect-error TS2339
       map = data.source ?? JSON.stringify((0, _nullthrows().default)(data.data), 0, '\t');
       code = map;
     }
@@ -329,6 +347,7 @@ validateSchema.diagnostic = function (schema, data, origin, message) {
       diagnostic: {
         message: message,
         origin,
+        // @ts-expect-error TS2322
         codeFrames
       }
     });

package/lib/shared-buffer.d.ts

@@ -0,0 +1,2 @@
+export type Class<T> = new (...args: any[]) => T;
+export declare let SharedBuffer: Class<ArrayBuffer> | Class<SharedArrayBuffer>;

package/lib/shared-buffer.js

@@ -4,9 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SharedBuffer = void 0;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 let SharedBuffer = exports.SharedBuffer = void 0;
 
-// $FlowFixMe[prop-missing]
+// @ts-expect-error process.browser is a browser-specific property
 if (process.browser) {
   exports.SharedBuffer = SharedBuffer = ArrayBuffer;
   // Safari has removed the constructor