astro 3.0.12 → 3.1.0

package/dist/assets/vendor/image-size/types/jp2.js

@@ -1,56 +0,0 @@
-const BoxTypes = {
-  ftyp: "66747970",
-  ihdr: "69686472",
-  jp2h: "6a703268",
-  jp__: "6a502020",
-  rreq: "72726571",
-  xml_: "786d6c20"
-};
-const calculateRREQLength = (box) => {
-  const unit = box.readUInt8(0);
-  let offset = 1 + 2 * unit;
-  const numStdFlags = box.readUInt16BE(offset);
-  const flagsLength = numStdFlags * (2 + unit);
-  offset = offset + 2 + flagsLength;
-  const numVendorFeatures = box.readUInt16BE(offset);
-  const featuresLength = numVendorFeatures * (16 + unit);
-  return offset + 2 + featuresLength;
-};
-const parseIHDR = (box) => {
-  return {
-    height: box.readUInt32BE(4),
-    width: box.readUInt32BE(8)
-  };
-};
-const JP2 = {
-  validate(buffer) {
-    const signature = buffer.toString("hex", 4, 8);
-    const signatureLength = buffer.readUInt32BE(0);
-    if (signature !== BoxTypes.jp__ || signatureLength < 1) {
-      return false;
-    }
-    const ftypeBoxStart = signatureLength + 4;
-    const ftypBoxLength = buffer.readUInt32BE(signatureLength);
-    const ftypBox = buffer.slice(ftypeBoxStart, ftypeBoxStart + ftypBoxLength);
-    return ftypBox.toString("hex", 0, 4) === BoxTypes.ftyp;
-  },
-  calculate(buffer) {
-    const signatureLength = buffer.readUInt32BE(0);
-    const ftypBoxLength = buffer.readUInt16BE(signatureLength + 2);
-    let offset = signatureLength + 4 + ftypBoxLength;
-    const nextBoxType = buffer.toString("hex", offset, offset + 4);
-    switch (nextBoxType) {
-      case BoxTypes.rreq:
-        const MAGIC = 4;
-        offset = offset + 4 + MAGIC + calculateRREQLength(buffer.slice(offset + 4));
-        return parseIHDR(buffer.slice(offset + 8, offset + 24));
-      case BoxTypes.jp2h:
-        return parseIHDR(buffer.slice(offset + 8, offset + 24));
-      default:
-        throw new TypeError("Unsupported header found: " + buffer.toString("ascii", offset, offset + 4));
-    }
-  }
-};
-export {
-  JP2
-};

package/dist/assets/vendor/image-size/types/jpg.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const JPG: IImage;

package/dist/assets/vendor/image-size/types/jpg.js

@@ -1,95 +0,0 @@
-import { readUInt } from "../readUInt.js";
-const EXIF_MARKER = "45786966";
-const APP1_DATA_SIZE_BYTES = 2;
-const EXIF_HEADER_BYTES = 6;
-const TIFF_BYTE_ALIGN_BYTES = 2;
-const BIG_ENDIAN_BYTE_ALIGN = "4d4d";
-const LITTLE_ENDIAN_BYTE_ALIGN = "4949";
-const IDF_ENTRY_BYTES = 12;
-const NUM_DIRECTORY_ENTRIES_BYTES = 2;
-function isEXIF(buffer) {
-  return buffer.toString("hex", 2, 6) === EXIF_MARKER;
-}
-function extractSize(buffer, index) {
-  return {
-    height: buffer.readUInt16BE(index),
-    width: buffer.readUInt16BE(index + 2)
-  };
-}
-function extractOrientation(exifBlock, isBigEndian) {
-  const idfOffset = 8;
-  const offset = EXIF_HEADER_BYTES + idfOffset;
-  const idfDirectoryEntries = readUInt(exifBlock, 16, offset, isBigEndian);
-  for (let directoryEntryNumber = 0; directoryEntryNumber < idfDirectoryEntries; directoryEntryNumber++) {
-    const start = offset + NUM_DIRECTORY_ENTRIES_BYTES + directoryEntryNumber * IDF_ENTRY_BYTES;
-    const end = start + IDF_ENTRY_BYTES;
-    if (start > exifBlock.length) {
-      return;
-    }
-    const block = exifBlock.slice(start, end);
-    const tagNumber = readUInt(block, 16, 0, isBigEndian);
-    if (tagNumber === 274) {
-      const dataFormat = readUInt(block, 16, 2, isBigEndian);
-      if (dataFormat !== 3) {
-        return;
-      }
-      const numberOfComponents = readUInt(block, 32, 4, isBigEndian);
-      if (numberOfComponents !== 1) {
-        return;
-      }
-      return readUInt(block, 16, 8, isBigEndian);
-    }
-  }
-}
-function validateExifBlock(buffer, index) {
-  const exifBlock = buffer.slice(APP1_DATA_SIZE_BYTES, index);
-  const byteAlign = exifBlock.toString("hex", EXIF_HEADER_BYTES, EXIF_HEADER_BYTES + TIFF_BYTE_ALIGN_BYTES);
-  const isBigEndian = byteAlign === BIG_ENDIAN_BYTE_ALIGN;
-  const isLittleEndian = byteAlign === LITTLE_ENDIAN_BYTE_ALIGN;
-  if (isBigEndian || isLittleEndian) {
-    return extractOrientation(exifBlock, isBigEndian);
-  }
-}
-function validateBuffer(buffer, index) {
-  if (index > buffer.length) {
-    throw new TypeError("Corrupt JPG, exceeded buffer limits");
-  }
-  if (buffer[index] !== 255) {
-    throw new TypeError("Invalid JPG, marker table corrupted");
-  }
-}
-const JPG = {
-  validate(buffer) {
-    const SOIMarker = buffer.toString("hex", 0, 2);
-    return "ffd8" === SOIMarker;
-  },
-  calculate(buffer) {
-    buffer = buffer.slice(4);
-    let orientation;
-    let next;
-    while (buffer.length) {
-      const i = buffer.readUInt16BE(0);
-      if (isEXIF(buffer)) {
-        orientation = validateExifBlock(buffer, i);
-      }
-      validateBuffer(buffer, i);
-      next = buffer[i + 1];
-      if (next === 192 || next === 193 || next === 194) {
-        const size = extractSize(buffer, i + 5);
-        if (!orientation) {
-          return size;
-        }
-        return {
-          height: size.height,
-          orientation,
-          width: size.width
-        };
-      }
-      buffer = buffer.slice(i + 2);
-    }
-    throw new TypeError("Invalid JPG, no size found");
-  }
-};
-export {
-  JPG
-};

package/dist/assets/vendor/image-size/types/ktx.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const KTX: IImage;

package/dist/assets/vendor/image-size/types/ktx.js

@@ -1,15 +0,0 @@
-const SIGNATURE = "KTX 11";
-const KTX = {
-  validate(buffer) {
-    return SIGNATURE === buffer.toString("ascii", 1, 7);
-  },
-  calculate(buffer) {
-    return {
-      height: buffer.readUInt32LE(40),
-      width: buffer.readUInt32LE(36)
-    };
-  }
-};
-export {
-  KTX
-};

package/dist/assets/vendor/image-size/types/png.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const PNG: IImage;

package/dist/assets/vendor/image-size/types/png.js

@@ -1,33 +0,0 @@
-const pngSignature = "PNG\r\n\n";
-const pngImageHeaderChunkName = "IHDR";
-const pngFriedChunkName = "CgBI";
-const PNG = {
-  validate(buffer) {
-    if (pngSignature === buffer.toString("ascii", 1, 8)) {
-      let chunkName = buffer.toString("ascii", 12, 16);
-      if (chunkName === pngFriedChunkName) {
-        chunkName = buffer.toString("ascii", 28, 32);
-      }
-      if (chunkName !== pngImageHeaderChunkName) {
-        throw new TypeError("Invalid PNG");
-      }
-      return true;
-    }
-    return false;
-  },
-  calculate(buffer) {
-    if (buffer.toString("ascii", 12, 16) === pngFriedChunkName) {
-      return {
-        height: buffer.readUInt32BE(36),
-        width: buffer.readUInt32BE(32)
-      };
-    }
-    return {
-      height: buffer.readUInt32BE(20),
-      width: buffer.readUInt32BE(16)
-    };
-  }
-};
-export {
-  PNG
-};

package/dist/assets/vendor/image-size/types/pnm.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const PNM: IImage;

package/dist/assets/vendor/image-size/types/pnm.js

@@ -1,72 +0,0 @@
-const PNMTypes = {
-  P1: "pbm/ascii",
-  P2: "pgm/ascii",
-  P3: "ppm/ascii",
-  P4: "pbm",
-  P5: "pgm",
-  P6: "ppm",
-  P7: "pam",
-  PF: "pfm"
-};
-const Signatures = Object.keys(PNMTypes);
-const handlers = {
-  default: (lines) => {
-    let dimensions = [];
-    while (lines.length > 0) {
-      const line = lines.shift();
-      if (line[0] === "#") {
-        continue;
-      }
-      dimensions = line.split(" ");
-      break;
-    }
-    if (dimensions.length === 2) {
-      return {
-        height: parseInt(dimensions[1], 10),
-        width: parseInt(dimensions[0], 10)
-      };
-    } else {
-      throw new TypeError("Invalid PNM");
-    }
-  },
-  pam: (lines) => {
-    const size = {};
-    while (lines.length > 0) {
-      const line = lines.shift();
-      if (line.length > 16 || line.charCodeAt(0) > 128) {
-        continue;
-      }
-      const [key, value] = line.split(" ");
-      if (key && value) {
-        size[key.toLowerCase()] = parseInt(value, 10);
-      }
-      if (size.height && size.width) {
-        break;
-      }
-    }
-    if (size.height && size.width) {
-      return {
-        height: size.height,
-        width: size.width
-      };
-    } else {
-      throw new TypeError("Invalid PAM");
-    }
-  }
-};
-const PNM = {
-  validate(buffer) {
-    const signature = buffer.toString("ascii", 0, 2);
-    return Signatures.includes(signature);
-  },
-  calculate(buffer) {
-    const signature = buffer.toString("ascii", 0, 2);
-    const type = PNMTypes[signature];
-    const lines = buffer.toString("ascii", 3).split(/[\r\n]+/);
-    const handler = handlers[type] || handlers.default;
-    return handler(lines);
-  }
-};
-export {
-  PNM
-};

package/dist/assets/vendor/image-size/types/psd.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const PSD: IImage;

package/dist/assets/vendor/image-size/types/psd.js

@@ -1,14 +0,0 @@
-const PSD = {
-  validate(buffer) {
-    return "8BPS" === buffer.toString("ascii", 0, 4);
-  },
-  calculate(buffer) {
-    return {
-      height: buffer.readUInt32BE(14),
-      width: buffer.readUInt32BE(18)
-    };
-  }
-};
-export {
-  PSD
-};

package/dist/assets/vendor/image-size/types/svg.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const SVG: IImage;

package/dist/assets/vendor/image-size/types/svg.js

@@ -1,91 +0,0 @@
-const svgReg = /<svg\s([^>"']|"[^"]*"|'[^']*')*>/;
-const extractorRegExps = {
-  height: /\sheight=(['"])([^%]+?)\1/,
-  root: svgReg,
-  viewbox: /\sviewBox=(['"])(.+?)\1/i,
-  width: /\swidth=(['"])([^%]+?)\1/
-};
-const INCH_CM = 2.54;
-const units = {
-  in: 96,
-  cm: 96 / INCH_CM,
-  em: 16,
-  ex: 8,
-  m: 96 / INCH_CM * 100,
-  mm: 96 / INCH_CM / 10,
-  pc: 96 / 72 / 12,
-  pt: 96 / 72,
-  px: 1
-};
-const unitsReg = new RegExp(`^([0-9.]+(?:e\\d+)?)(${Object.keys(units).join("|")})?$`);
-function parseLength(len) {
-  const m = unitsReg.exec(len);
-  if (!m) {
-    return void 0;
-  }
-  return Math.round(Number(m[1]) * (units[m[2]] || 1));
-}
-function parseViewbox(viewbox) {
-  const bounds = viewbox.split(" ");
-  return {
-    height: parseLength(bounds[3]),
-    width: parseLength(bounds[2])
-  };
-}
-function parseAttributes(root) {
-  const width = root.match(extractorRegExps.width);
-  const height = root.match(extractorRegExps.height);
-  const viewbox = root.match(extractorRegExps.viewbox);
-  return {
-    height: height && parseLength(height[2]),
-    viewbox: viewbox && parseViewbox(viewbox[2]),
-    width: width && parseLength(width[2])
-  };
-}
-function calculateByDimensions(attrs) {
-  return {
-    height: attrs.height,
-    width: attrs.width
-  };
-}
-function calculateByViewbox(attrs, viewbox) {
-  const ratio = viewbox.width / viewbox.height;
-  if (attrs.width) {
-    return {
-      height: Math.floor(attrs.width / ratio),
-      width: attrs.width
-    };
-  }
-  if (attrs.height) {
-    return {
-      height: attrs.height,
-      width: Math.floor(attrs.height * ratio)
-    };
-  }
-  return {
-    height: viewbox.height,
-    width: viewbox.width
-  };
-}
-const SVG = {
-  validate(buffer) {
-    const str = String(buffer);
-    return svgReg.test(str);
-  },
-  calculate(buffer) {
-    const root = buffer.toString("utf8").match(extractorRegExps.root);
-    if (root) {
-      const attrs = parseAttributes(root[0]);
-      if (attrs.width && attrs.height) {
-        return calculateByDimensions(attrs);
-      }
-      if (attrs.viewbox) {
-        return calculateByViewbox(attrs, attrs.viewbox);
-      }
-    }
-    throw new TypeError("Invalid SVG");
-  }
-};
-export {
-  SVG
-};

package/dist/assets/vendor/image-size/types/tiff.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const TIFF: IImage;

package/dist/assets/vendor/image-size/types/tiff.js

@@ -1,81 +0,0 @@
-import * as fs from "node:fs";
-import { readUInt } from "../readUInt.js";
-function readIFD(buffer, filepath, isBigEndian) {
-  const ifdOffset = readUInt(buffer, 32, 4, isBigEndian);
-  let bufferSize = 1024;
-  const fileSize = fs.statSync(filepath).size;
-  if (ifdOffset + bufferSize > fileSize) {
-    bufferSize = fileSize - ifdOffset - 10;
-  }
-  const endBuffer = Buffer.alloc(bufferSize);
-  const descriptor = fs.openSync(filepath, "r");
-  fs.readSync(descriptor, endBuffer, 0, bufferSize, ifdOffset);
-  fs.closeSync(descriptor);
-  return endBuffer.slice(2);
-}
-function readValue(buffer, isBigEndian) {
-  const low = readUInt(buffer, 16, 8, isBigEndian);
-  const high = readUInt(buffer, 16, 10, isBigEndian);
-  return (high << 16) + low;
-}
-function nextTag(buffer) {
-  if (buffer.length > 24) {
-    return buffer.slice(12);
-  }
-}
-function extractTags(buffer, isBigEndian) {
-  const tags = {};
-  let temp = buffer;
-  while (temp?.length) {
-    const code = readUInt(temp, 16, 0, isBigEndian);
-    const type = readUInt(temp, 16, 2, isBigEndian);
-    const length = readUInt(temp, 32, 4, isBigEndian);
-    if (code === 0) {
-      break;
-    } else {
-      if (length === 1 && (type === 3 || type === 4)) {
-        tags[code] = readValue(temp, isBigEndian);
-      }
-      temp = nextTag(temp);
-    }
-  }
-  return tags;
-}
-function determineEndianness(buffer) {
-  const signature = buffer.toString("ascii", 0, 2);
-  if ("II" === signature) {
-    return "LE";
-  } else if ("MM" === signature) {
-    return "BE";
-  }
-}
-const signatures = [
-  // '492049', // currently not supported
-  "49492a00",
-  // Little endian
-  "4d4d002a"
-  // Big Endian
-  // '4d4d002a', // BigTIFF > 4GB. currently not supported
-];
-const TIFF = {
-  validate(buffer) {
-    return signatures.includes(buffer.toString("hex", 0, 4));
-  },
-  calculate(buffer, filepath) {
-    if (!filepath) {
-      throw new TypeError("Tiff doesn't support buffer");
-    }
-    const isBigEndian = determineEndianness(buffer) === "BE";
-    const ifdBuffer = readIFD(buffer, filepath, isBigEndian);
-    const tags = extractTags(ifdBuffer, isBigEndian);
-    const width = tags[256];
-    const height = tags[257];
-    if (!width || !height) {
-      throw new TypeError("Invalid Tiff. Missing tags");
-    }
-    return { height, width };
-  }
-};
-export {
-  TIFF
-};

package/dist/assets/vendor/image-size/types/webp.d.ts

@@ -1,2 +0,0 @@
-import type { IImage } from './interface';
-export declare const WEBP: IImage;

package/dist/assets/vendor/image-size/types/webp.js

@@ -1,51 +0,0 @@
-function calculateExtended(buffer) {
-  return {
-    height: 1 + buffer.readUIntLE(7, 3),
-    width: 1 + buffer.readUIntLE(4, 3)
-  };
-}
-function calculateLossless(buffer) {
-  return {
-    height: 1 + ((buffer[4] & 15) << 10 | buffer[3] << 2 | (buffer[2] & 192) >> 6),
-    width: 1 + ((buffer[2] & 63) << 8 | buffer[1])
-  };
-}
-function calculateLossy(buffer) {
-  return {
-    height: buffer.readInt16LE(8) & 16383,
-    width: buffer.readInt16LE(6) & 16383
-  };
-}
-const WEBP = {
-  validate(buffer) {
-    const riffHeader = "RIFF" === buffer.toString("ascii", 0, 4);
-    const webpHeader = "WEBP" === buffer.toString("ascii", 8, 12);
-    const vp8Header = "VP8" === buffer.toString("ascii", 12, 15);
-    return riffHeader && webpHeader && vp8Header;
-  },
-  calculate(buffer) {
-    const chunkHeader = buffer.toString("ascii", 12, 16);
-    buffer = buffer.slice(20, 30);
-    if (chunkHeader === "VP8X") {
-      const extendedHeader = buffer[0];
-      const validStart = (extendedHeader & 192) === 0;
-      const validEnd = (extendedHeader & 1) === 0;
-      if (validStart && validEnd) {
-        return calculateExtended(buffer);
-      } else {
-        throw new TypeError("Invalid WebP");
-      }
-    }
-    if (chunkHeader === "VP8 " && buffer[0] !== 47) {
-      return calculateLossy(buffer);
-    }
-    const signature = buffer.toString("hex", 3, 6);
-    if (chunkHeader === "VP8L" && signature !== "9d012a") {
-      return calculateLossless(buffer);
-    }
-    throw new TypeError("Invalid WebP");
-  }
-};
-export {
-  WEBP
-};

package/dist/assets/vendor/image-size/types.d.ts

@@ -1,19 +0,0 @@
-export declare const typeHandlers: {
-    bmp: import("./types/interface.js").IImage;
-    cur: import("./types/interface.js").IImage;
-    dds: import("./types/interface.js").IImage;
-    gif: import("./types/interface.js").IImage;
-    icns: import("./types/interface.js").IImage;
-    ico: import("./types/interface.js").IImage;
-    j2c: import("./types/interface.js").IImage;
-    jp2: import("./types/interface.js").IImage;
-    jpg: import("./types/interface.js").IImage;
-    ktx: import("./types/interface.js").IImage;
-    png: import("./types/interface.js").IImage;
-    pnm: import("./types/interface.js").IImage;
-    psd: import("./types/interface.js").IImage;
-    svg: import("./types/interface.js").IImage;
-    tiff: import("./types/interface.js").IImage;
-    webp: import("./types/interface.js").IImage;
-};
-export type imageType = keyof typeof typeHandlers;

package/dist/assets/vendor/image-size/types.js

@@ -1,37 +0,0 @@
-import { BMP } from "./types/bmp.js";
-import { CUR } from "./types/cur.js";
-import { DDS } from "./types/dds.js";
-import { GIF } from "./types/gif.js";
-import { ICNS } from "./types/icns.js";
-import { ICO } from "./types/ico.js";
-import { J2C } from "./types/j2c.js";
-import { JP2 } from "./types/jp2.js";
-import { JPG } from "./types/jpg.js";
-import { KTX } from "./types/ktx.js";
-import { PNG } from "./types/png.js";
-import { PNM } from "./types/pnm.js";
-import { PSD } from "./types/psd.js";
-import { SVG } from "./types/svg.js";
-import { TIFF } from "./types/tiff.js";
-import { WEBP } from "./types/webp.js";
-const typeHandlers = {
-  bmp: BMP,
-  cur: CUR,
-  dds: DDS,
-  gif: GIF,
-  icns: ICNS,
-  ico: ICO,
-  j2c: J2C,
-  jp2: JP2,
-  jpg: JPG,
-  ktx: KTX,
-  png: PNG,
-  pnm: PNM,
-  psd: PSD,
-  svg: SVG,
-  tiff: TIFF,
-  webp: WEBP
-};
-export {
-  typeHandlers
-};

package/dist/assets/vendor/queue/queue.d.ts

@@ -1,39 +0,0 @@
-/**
- * Since CustomEvent is only supported in nodejs since version 19,
- * you have to create your own class instead of using CustomEvent
- * @see https://github.com/nodejs/node/issues/40678
- * */
-export class QueueEvent extends Event {
-    constructor(name: any, detail: any);
-    detail: any;
-}
-export default class Queue extends EventTarget {
-    constructor(options?: {});
-    concurrency: any;
-    timeout: any;
-    autostart: any;
-    results: any;
-    pending: number;
-    session: number;
-    running: boolean;
-    jobs: any[];
-    timers: any[];
-    _errorHandler(evt: any): void;
-    pop(): any;
-    shift(): any;
-    indexOf(searchElement: any, fromIndex: any): number;
-    lastIndexOf(searchElement: any, fromIndex: any): number;
-    slice(start: any, end: any): this;
-    reverse(): this;
-    push(...workers: any[]): number;
-    unshift(...workers: any[]): number;
-    splice(start: any, deleteCount: any, ...workers: any[]): this;
-    get length(): number;
-    start(callback: any): any;
-    stop(): void;
-    end(error: any): void;
-    clearTimers(): void;
-    _addCallbackToEndEvent(cb: any): void;
-    _createPromiseToEndEvent(): Promise<any>;
-    done(error: any): void;
-}