@loaders.gl/geotiff 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/esm/lib/ome/omexml.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/ome/omexml.ts"],"names":["parser","ensureArray","intToRgba","PARSER_OPTIONS","attributeNamePrefix","attrNodeName","parseNodeValue","parseAttributeValue","ignoreAttributes","parse","str","fromString","res","OME","Error","Image","map","img","Channels","Pixels","Channel","c","attr","Color","AquisitionDate","Description","image","format","sizes","name","size","unit","join","SizeX","SizeY","Type","SizeZ","SizeT","SizeC"],"mappings":"AAAA,OAAOA,MAAP,MAAmB,iBAAnB;AACA,SAAQC,WAAR,EAAqBC,SAArB,QAAqC,qBAArC;AAGA,MAAMC,cAAc,GAAG;AAErBC,EAAAA,mBAAmB,EAAE,EAFA;AAGrBC,EAAAA,YAAY,EAAE,MAHO;AAMrBC,EAAAA,cAAc,EAAE,IANK;AAOrBC,EAAAA,mBAAmB,EAAE,IAPA;AAUrBC,EAAAA,gBAAgB,EAAE;AAVG,CAAvB;;AAaA,MAAMC,KAAK,GAAIC,GAAD,IAAuBV,MAAM,CAACS,KAAP,CAAaC,GAAb,EAAkBP,cAAlB,CAArC;;AAEA,OAAO,SAASQ,UAAT,CAAoBD,GAApB,EAAiC;AACtC,QAAME,GAAG,GAAGH,KAAK,CAACC,GAAD,CAAjB;;AACA,MAAI,CAACE,GAAG,CAACC,GAAT,EAAc;AACZ,UAAMC,KAAK,CAAC,mCAAD,CAAX;AACD;;AACD,SAAOb,WAAW,CAACW,GAAG,CAACC,GAAJ,CAAQE,KAAT,CAAX,CAA2BC,GAA3B,CAAgCC,GAAD,IAAS;AAC7C,UAAMC,QAAQ,GAAGjB,WAAW,CAACgB,GAAG,CAACE,MAAJ,CAAWC,OAAZ,CAAX,CAAgCJ,GAAhC,CAAqCK,CAAD,IAAO;AAC1D,UAAI,WAAWA,CAAC,CAACC,IAAjB,EAAuB;AACrB,eAAO,EAAC,GAAGD,CAAC,CAACC,IAAN;AAAYC,UAAAA,KAAK,EAAErB,SAAS,CAACmB,CAAC,CAACC,IAAF,CAAOC,KAAR;AAA5B,SAAP;AACD;;AACD,aAAO,EAAC,GAAGF,CAAC,CAACC;AAAN,OAAP;AACD,KALgB,CAAjB;AAMA,UAAM;AAACE,MAAAA,cAAc,GAAG,EAAlB;AAAsBC,MAAAA,WAAW,GAAG;AAApC,QAA0CR,GAAhD;AACA,UAAMS,KAAK,GAAG,EACZ,GAAGT,GAAG,CAACK,IADK;AAEZE,MAAAA,cAFY;AAGZC,MAAAA,WAHY;AAIZN,MAAAA,MAAM,EAAE,EACN,GAAGF,GAAG,CAACE,MAAJ,CAAWG,IADR;AAENJ,QAAAA;AAFM;AAJI,KAAd;AASA,WAAO,EACL,GAAGQ,KADE;;AAELC,MAAAA,MAAM,GAAG;AACP,cAAM;AAACR,UAAAA;AAAD,YAAWO,KAAjB;AAEA,cAAME,KAAK,GAAI,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAAD,CACXZ,GADW,CACNa,IAAD,IAAU;AACb,gBAAMC,IAAI,GAAGX,MAAM,CAAE,eAAcU,IAAK,EAArB,CAAnB;AACA,gBAAME,IAAI,GAAGZ,MAAM,CAAE,eAAcU,IAAK,MAArB,CAAnB;AACA,iBAAOC,IAAI,IAAIC,IAAR,GAAgB,GAAED,IAAK,IAAGC,IAAK,EAA/B,GAAmC,GAA1C;AACD,SALW,EAMXC,IANW,CAMN,KANM,CAAd;AAQA,eAAO;AACL,8BAAoBN,KAAK,CAACF,cADrB;AAEL,6BAAoB,GAAEL,MAAM,CAACc,KAAM,MAAKd,MAAM,CAACe,KAAM,EAFhD;AAGL,yBAAef,MAAM,CAACgB,IAHjB;AAIL,+BAAqBP,KAJhB;AAKL,mCAA0B,GAAET,MAAM,CAACiB,KAAM,MAAKjB,MAAM,CAACkB,KAAM,EALtD;AAMLnB,UAAAA,QAAQ,EAAEC,MAAM,CAACmB;AANZ,SAAP;AAQD;;AArBI,KAAP;AAuBD,GAxCM,CAAP;AAyCD","sourcesContent":["import parser from 'fast-xml-parser';\nimport {ensureArray, intToRgba} from '../utils/tiff-utils';\n\n// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.\nconst PARSER_OPTIONS = {\n  // Nests attributes withtout prefix under 'attr' key for each node\n  attributeNamePrefix: '',\n  attrNodeName: 'attr',\n\n  // Parses numbers for both attributes and nodes\n  parseNodeValue: true,\n  parseAttributeValue: true,\n\n  // Forces attributes to be parsed\n  ignoreAttributes: false\n};\n\nconst parse = (str: string): Root => parser.parse(str, PARSER_OPTIONS);\n\nexport function fromString(str: string) {\n  const res = parse(str);\n  if (!res.OME) {\n    throw Error('Failed to parse OME-XML metadata.');\n  }\n  return ensureArray(res.OME.Image).map((img) => {\n    const Channels = ensureArray(img.Pixels.Channel).map((c) => {\n      if ('Color' in c.attr) {\n        return {...c.attr, Color: intToRgba(c.attr.Color)};\n      }\n      return {...c.attr};\n    });\n    const {AquisitionDate = '', Description = ''} = img;\n    const image = {\n      ...img.attr,\n      AquisitionDate,\n      Description,\n      Pixels: {\n        ...img.Pixels.attr,\n        Channels\n      }\n    };\n    return {\n      ...image,\n      format() {\n        const {Pixels} = image;\n\n        const sizes = (['X', 'Y', 'Z'] as const)\n          .map((name) => {\n            const size = Pixels[`PhysicalSize${name}` as const];\n            const unit = Pixels[`PhysicalSize${name}Unit` as const];\n            return size && unit ? `${size} ${unit}` : '-';\n          })\n          .join(' x ');\n\n        return {\n          'Acquisition Date': image.AquisitionDate,\n          'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,\n          'Pixels Type': Pixels.Type,\n          'Pixels Size (XYZ)': sizes,\n          'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,\n          Channels: Pixels.SizeC\n        };\n      }\n    };\n  });\n}\n\nexport type OMEXML = ReturnType<typeof fromString>;\nexport type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';\n\n// Structure of node is determined by the PARSER_OPTIONS.\ntype Node<T, A> = T & {attr: A};\ntype Attrs<Fields extends string, T = string> = {[K in Fields]: T};\n\ntype OMEAttrs = Attrs<'xmlns' | 'xmlns:xsi' | 'xsi:schemaLocation'>;\ntype OME = Node<{Insturment: Insturment; Image: Image | Image[]}, OMEAttrs>;\n\ntype Insturment = Node<\n  {Objective: Node<{}, Attrs<'ID' | 'Model' | 'NominalMagnification'>>},\n  Attrs<'ID'>\n>;\n\ninterface ImageNodes {\n  AquisitionDate?: string;\n  Description?: string;\n  Pixels: Pixels;\n  InstrumentRef: Node<{}, {ID: string}>;\n  ObjectiveSettings: Node<{}, {ID: string}>;\n}\ntype Image = Node<ImageNodes, Attrs<'ID' | 'Name'>>;\n\ntype PixelType =\n  | 'int8'\n  | 'int16'\n  | 'int32'\n  | 'uint8'\n  | 'uint16'\n  | 'uint32'\n  | 'float'\n  | 'bit'\n  | 'double'\n  | 'complex'\n  | 'double-complex';\n\nexport type UnitsLength =\n  | 'Ym'\n  | 'Zm'\n  | 'Em'\n  | 'Pm'\n  | 'Tm'\n  | 'Gm'\n  | 'Mm'\n  | 'km'\n  | 'hm'\n  | 'dam'\n  | 'm'\n  | 'dm'\n  | 'cm'\n  | 'mm'\n  | 'µm'\n  | 'nm'\n  | 'pm'\n  | 'fm'\n  | 'am'\n  | 'zm'\n  | 'ym'\n  | 'Å'\n  | 'thou'\n  | 'li'\n  | 'in'\n  | 'ft'\n  | 'yd'\n  | 'mi'\n  | 'ua'\n  | 'ly'\n  | 'pc'\n  | 'pt'\n  | 'pixel'\n  | 'reference frame';\n\ntype PhysicalSize<Name extends string> = `PhysicalSize${Name}`;\ntype PhysicalSizeUnit<Name extends string> = `PhysicalSize${Name}Unit`;\ntype Size<Names extends string> = `Size${Names}`;\n\ntype PixelAttrs = Attrs<\n  PhysicalSize<'X' | 'Y' | 'Z'> | 'SignificantBits' | Size<'T' | 'C' | 'Z' | 'Y' | 'X'>,\n  number\n> &\n  Attrs<PhysicalSizeUnit<'X' | 'Y' | 'Z'>, UnitsLength> &\n  Attrs<'BigEndian' | 'Interleaved', boolean> & {\n    ID: string;\n    DimensionOrder: DimensionOrder;\n    Type: PixelType;\n  };\n\ntype Pixels = Node<\n  {\n    Channel: Channel | Channel[];\n    TiffData: Node<{}, Attrs<'IFD' | 'PlaneCount'>>;\n  },\n  PixelAttrs\n>;\n\ntype ChannelAttrs =\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n    }\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n      Color: number;\n    };\n\ntype Channel = Node<{}, ChannelAttrs>;\n\ntype Root = {OME: OME};\n"],"file":"omexml.js"}
+{"version":3,"sources":["../../../../src/lib/ome/omexml.ts"],"names":["parser","ensureArray","intToRgba","PARSER_OPTIONS","attributeNamePrefix","attrNodeName","parseNodeValue","parseAttributeValue","ignoreAttributes","parse","str","fromString","res","OME","Error","Image","map","img","Channels","Pixels","Channel","c","attr","Color","AquisitionDate","Description","image","format","sizes","name","size","unit","join","SizeX","SizeY","Type","SizeZ","SizeT","SizeC"],"mappings":"AAAA,OAAOA,MAAP,MAAmB,iBAAnB;AACA,SAAQC,WAAR,EAAqBC,SAArB,QAAqC,qBAArC;AAGA,MAAMC,cAAc,GAAG;AAErBC,EAAAA,mBAAmB,EAAE,EAFA;AAGrBC,EAAAA,YAAY,EAAE,MAHO;AAMrBC,EAAAA,cAAc,EAAE,IANK;AAOrBC,EAAAA,mBAAmB,EAAE,IAPA;AAUrBC,EAAAA,gBAAgB,EAAE;AAVG,CAAvB;;AAaA,MAAMC,KAAK,GAAIC,GAAD,IAAuBV,MAAM,CAACS,KAAP,CAAaC,GAAb,EAAkBP,cAAlB,CAArC;;AAEA,OAAO,SAASQ,UAAT,CAAoBD,GAApB,EAAiC;AACtC,QAAME,GAAG,GAAGH,KAAK,CAACC,GAAD,CAAjB;;AACA,MAAI,CAACE,GAAG,CAACC,GAAT,EAAc;AACZ,UAAMC,KAAK,CAAC,mCAAD,CAAX;AACD;;AACD,SAAOb,WAAW,CAACW,GAAG,CAACC,GAAJ,CAAQE,KAAT,CAAX,CAA2BC,GAA3B,CAAgCC,GAAD,IAAS;AAC7C,UAAMC,QAAQ,GAAGjB,WAAW,CAACgB,GAAG,CAACE,MAAJ,CAAWC,OAAZ,CAAX,CAAgCJ,GAAhC,CAAqCK,CAAD,IAAO;AAC1D,UAAI,WAAWA,CAAC,CAACC,IAAjB,EAAuB;AACrB,eAAO,EAAC,GAAGD,CAAC,CAACC,IAAN;AAAYC,UAAAA,KAAK,EAAErB,SAAS,CAACmB,CAAC,CAACC,IAAF,CAAOC,KAAR;AAA5B,SAAP;AACD;;AACD,aAAO,EAAC,GAAGF,CAAC,CAACC;AAAN,OAAP;AACD,KALgB,CAAjB;AAMA,UAAM;AAACE,MAAAA,cAAc,GAAG,EAAlB;AAAsBC,MAAAA,WAAW,GAAG;AAApC,QAA0CR,GAAhD;AACA,UAAMS,KAAK,GAAG,EACZ,GAAGT,GAAG,CAACK,IADK;AAEZE,MAAAA,cAFY;AAGZC,MAAAA,WAHY;AAIZN,MAAAA,MAAM,EAAE,EACN,GAAGF,GAAG,CAACE,MAAJ,CAAWG,IADR;AAENJ,QAAAA;AAFM;AAJI,KAAd;AASA,WAAO,EACL,GAAGQ,KADE;;AAELC,MAAAA,MAAM,GAAG;AACP,cAAM;AAACR,UAAAA;AAAD,YAAWO,KAAjB;AAEA,cAAME,KAAK,GAAI,CAAC,GAAD,EAAM,GAAN,EAAW,GAAX,CAAD,CACXZ,GADW,CACNa,IAAD,IAAU;AACb,gBAAMC,IAAI,GAAGX,MAAM,uBAAgBU,IAAhB,EAAnB;AACA,gBAAME,IAAI,GAAGZ,MAAM,uBAAgBU,IAAhB,UAAnB;AACA,iBAAOC,IAAI,IAAIC,IAAR,aAAkBD,IAAlB,cAA0BC,IAA1B,IAAmC,GAA1C;AACD,SALW,EAMXC,IANW,CAMN,KANM,CAAd;AAQA,eAAO;AACL,8BAAoBN,KAAK,CAACF,cADrB;AAEL,uCAAsBL,MAAM,CAACc,KAA7B,gBAAwCd,MAAM,CAACe,KAA/C,CAFK;AAGL,yBAAef,MAAM,CAACgB,IAHjB;AAIL,+BAAqBP,KAJhB;AAKL,6CAA4BT,MAAM,CAACiB,KAAnC,gBAA8CjB,MAAM,CAACkB,KAArD,CALK;AAMLnB,UAAAA,QAAQ,EAAEC,MAAM,CAACmB;AANZ,SAAP;AAQD;;AArBI,KAAP;AAuBD,GAxCM,CAAP;AAyCD","sourcesContent":["import parser from 'fast-xml-parser';\nimport {ensureArray, intToRgba} from '../utils/tiff-utils';\n\n// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.\nconst PARSER_OPTIONS = {\n  // Nests attributes withtout prefix under 'attr' key for each node\n  attributeNamePrefix: '',\n  attrNodeName: 'attr',\n\n  // Parses numbers for both attributes and nodes\n  parseNodeValue: true,\n  parseAttributeValue: true,\n\n  // Forces attributes to be parsed\n  ignoreAttributes: false\n};\n\nconst parse = (str: string): Root => parser.parse(str, PARSER_OPTIONS);\n\nexport function fromString(str: string) {\n  const res = parse(str);\n  if (!res.OME) {\n    throw Error('Failed to parse OME-XML metadata.');\n  }\n  return ensureArray(res.OME.Image).map((img) => {\n    const Channels = ensureArray(img.Pixels.Channel).map((c) => {\n      if ('Color' in c.attr) {\n        return {...c.attr, Color: intToRgba(c.attr.Color)};\n      }\n      return {...c.attr};\n    });\n    const {AquisitionDate = '', Description = ''} = img;\n    const image = {\n      ...img.attr,\n      AquisitionDate,\n      Description,\n      Pixels: {\n        ...img.Pixels.attr,\n        Channels\n      }\n    };\n    return {\n      ...image,\n      format() {\n        const {Pixels} = image;\n\n        const sizes = (['X', 'Y', 'Z'] as const)\n          .map((name) => {\n            const size = Pixels[`PhysicalSize${name}` as const];\n            const unit = Pixels[`PhysicalSize${name}Unit` as const];\n            return size && unit ? `${size} ${unit}` : '-';\n          })\n          .join(' x ');\n\n        return {\n          'Acquisition Date': image.AquisitionDate,\n          'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,\n          'Pixels Type': Pixels.Type,\n          'Pixels Size (XYZ)': sizes,\n          'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,\n          Channels: Pixels.SizeC\n        };\n      }\n    };\n  });\n}\n\nexport type OMEXML = ReturnType<typeof fromString>;\nexport type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';\n\n// Structure of node is determined by the PARSER_OPTIONS.\ntype Node<T, A> = T & {attr: A};\ntype Attrs<Fields extends string, T = string> = {[K in Fields]: T};\n\ntype OMEAttrs = Attrs<'xmlns' | 'xmlns:xsi' | 'xsi:schemaLocation'>;\ntype OME = Node<{Insturment: Insturment; Image: Image | Image[]}, OMEAttrs>;\n\ntype Insturment = Node<\n  {Objective: Node<{}, Attrs<'ID' | 'Model' | 'NominalMagnification'>>},\n  Attrs<'ID'>\n>;\n\ninterface ImageNodes {\n  AquisitionDate?: string;\n  Description?: string;\n  Pixels: Pixels;\n  InstrumentRef: Node<{}, {ID: string}>;\n  ObjectiveSettings: Node<{}, {ID: string}>;\n}\ntype Image = Node<ImageNodes, Attrs<'ID' | 'Name'>>;\n\ntype PixelType =\n  | 'int8'\n  | 'int16'\n  | 'int32'\n  | 'uint8'\n  | 'uint16'\n  | 'uint32'\n  | 'float'\n  | 'bit'\n  | 'double'\n  | 'complex'\n  | 'double-complex';\n\nexport type UnitsLength =\n  | 'Ym'\n  | 'Zm'\n  | 'Em'\n  | 'Pm'\n  | 'Tm'\n  | 'Gm'\n  | 'Mm'\n  | 'km'\n  | 'hm'\n  | 'dam'\n  | 'm'\n  | 'dm'\n  | 'cm'\n  | 'mm'\n  | 'µm'\n  | 'nm'\n  | 'pm'\n  | 'fm'\n  | 'am'\n  | 'zm'\n  | 'ym'\n  | 'Å'\n  | 'thou'\n  | 'li'\n  | 'in'\n  | 'ft'\n  | 'yd'\n  | 'mi'\n  | 'ua'\n  | 'ly'\n  | 'pc'\n  | 'pt'\n  | 'pixel'\n  | 'reference frame';\n\ntype PhysicalSize<Name extends string> = `PhysicalSize${Name}`;\ntype PhysicalSizeUnit<Name extends string> = `PhysicalSize${Name}Unit`;\ntype Size<Names extends string> = `Size${Names}`;\n\ntype PixelAttrs = Attrs<\n  PhysicalSize<'X' | 'Y' | 'Z'> | 'SignificantBits' | Size<'T' | 'C' | 'Z' | 'Y' | 'X'>,\n  number\n> &\n  Attrs<PhysicalSizeUnit<'X' | 'Y' | 'Z'>, UnitsLength> &\n  Attrs<'BigEndian' | 'Interleaved', boolean> & {\n    ID: string;\n    DimensionOrder: DimensionOrder;\n    Type: PixelType;\n  };\n\ntype Pixels = Node<\n  {\n    Channel: Channel | Channel[];\n    TiffData: Node<{}, Attrs<'IFD' | 'PlaneCount'>>;\n  },\n  PixelAttrs\n>;\n\ntype ChannelAttrs =\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n    }\n  | {\n      ID: string;\n      SamplesPerPixel: number;\n      Name?: string;\n      Color: number;\n    };\n\ntype Channel = Node<{}, ChannelAttrs>;\n\ntype Root = {OME: OME};\n"],"file":"omexml.js"}

package/dist/esm/lib/utils/proxies.js

@@ -1,6 +1,6 @@
 const VIV_PROXY_KEY = '__viv';
-const OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets`;
-const POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool`;
+const OFFSETS_PROXY_KEY = "".concat(VIV_PROXY_KEY, "-offsets");
+const POOL_PROXY_KEY = "".concat(VIV_PROXY_KEY, "-decoder-pool");
 export function checkProxies(tiff) {
   if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {
     console.warn('GeoTIFF source is missing offsets proxy.');

package/dist/esm/lib/utils/proxies.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/utils/proxies.ts"],"names":["VIV_PROXY_KEY","OFFSETS_PROXY_KEY","POOL_PROXY_KEY","checkProxies","tiff","isProxy","console","warn","proxyFlag","createOffsetsProxy","offsets","get","target","key","index","ifdRequests","offset","parseFileDirectoryAt","getImage","Reflect","Proxy","createPoolProxy","pool","options","readRasters"],"mappings":"AAGA,MAAMA,aAAa,GAAG,OAAtB;AACA,MAAMC,iBAAiB,GAAI,GAAED,aAAc,UAA3C;AACA,MAAME,cAAc,GAAI,GAAEF,aAAc,eAAxC;AAMA,OAAO,SAASG,YAAT,CAAsBC,IAAtB,EAAqC;AAC1C,MAAI,CAACC,OAAO,CAACD,IAAD,EAAOH,iBAAP,CAAZ,EAAuC;AACrCK,IAAAA,OAAO,CAACC,IAAR,CAAa,0CAAb;AACD;;AAED,MAAI,CAACF,OAAO,CAACD,IAAD,EAAOF,cAAP,CAAZ,EAAoC;AAClCI,IAAAA,OAAO,CAACC,IAAR,CAAa,+CAAb;AACD;AACF;;AAOD,SAASF,OAAT,CAAiBD,IAAjB,EAAgCI,SAAhC,EAAmD;AACjD,SAAQJ,IAAD,CAAcI,SAAd,CAAP;AACD;;AAYD,OAAO,SAASC,kBAAT,CAA4BL,IAA5B,EAA2CM,OAA3C,EAA8D;AACnE,QAAMC,GAAG,GAAG,CAACC,MAAD,EAAkBC,GAAlB,KAA+B;AAEzC,QAAIA,GAAG,KAAK,UAAZ,EAAwB;AACtB,aAAQC,KAAD,IAAmB;AAExB,YAAI,EAAEA,KAAK,IAAIF,MAAM,CAACG,WAAlB,KAAkCD,KAAK,IAAIJ,OAA/C,EAAwD;AACtD,gBAAMM,MAAM,GAAGN,OAAO,CAACI,KAAD,CAAtB;AACAF,UAAAA,MAAM,CAACG,WAAP,CAAmBD,KAAnB,IAA4BF,MAAM,CAACK,oBAAP,CAA4BD,MAA5B,CAA5B;AACD;;AACD,eAAOJ,MAAM,CAACM,QAAP,CAAgBJ,KAAhB,CAAP;AACD,OAPD;AAQD;;AAGD,QAAID,GAAG,KAAKZ,iBAAZ,EAA+B;AAC7B,aAAO,IAAP;AACD;;AAED,WAAOkB,OAAO,CAACR,GAAR,CAAYC,MAAZ,EAAoBC,GAApB,CAAP;AACD,GAnBD;;AAoBA,SAAO,IAAIO,KAAJ,CAAUhB,IAAV,EAAgB;AAACO,IAAAA;AAAD,GAAhB,CAAP;AACD;AAUD,OAAO,SAASU,eAAT,CAAyBjB,IAAzB,EAAwCkB,IAAxC,EAAoD;AACzD,QAAMX,GAAG,GAAG,CAACC,MAAD,EAAkBC,GAAlB,KAA+B;AAEzC,QAAIA,GAAG,KAAK,aAAZ,EAA2B;AACzB,aAAQU,OAAD,IAAoD;AAGzD,eAAOX,MAAM,CAACY,WAAP,CAAmB,EAAC,GAAGD,OAAJ;AAAaD,UAAAA;AAAb,SAAnB,CAAP;AACD,OAJD;AAKD;;AAGD,QAAIT,GAAG,KAAKX,cAAZ,EAA4B;AAC1B,aAAO,IAAP;AACD;;AAED,WAAOiB,OAAO,CAACR,GAAR,CAAYC,MAAZ,EAAoBC,GAApB,CAAP;AACD,GAhBD;;AAiBA,SAAO,IAAIO,KAAJ,CAAUhB,IAAV,EAAgB;AAACO,IAAAA;AAAD,GAAhB,CAAP;AACD","sourcesContent":["import type {GeoTIFF} from 'geotiff';\nimport type Pool from './Pool';\n\nconst VIV_PROXY_KEY = '__viv';\nconst OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets` as const;\nconst POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool` as const;\n\n/*\n * Inspect if the GeoTIFF source is wrapped in our proxies,\n * and warn if missing.\n */\nexport function checkProxies(tiff: GeoTIFF) {\n  if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {\n    console.warn('GeoTIFF source is missing offsets proxy.'); // eslint-disable-line no-console\n  }\n\n  if (!isProxy(tiff, POOL_PROXY_KEY)) {\n    console.warn('GeoTIFF source is missing decoder-pool proxy.'); // eslint-disable-line no-console\n  }\n}\n\n/*\n * > isProxy(tiff, POOL_PROXY_KEY) === true; // false\n * > tiff = createPoolProxy(tiff, new Pool());\n * > isProxy(tiff, POOL_PROXY_KEY) === true; // true\n */\nfunction isProxy(tiff: GeoTIFF, proxyFlag: string) {\n  return (tiff as any)[proxyFlag] as boolean;\n}\n\n/*\n * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy\n * handler intercepts calls to `tiff.getImage` and uses our custom\n * pre-computed offsets to pre-fetch the correct file directory.\n *\n * This is a bit of a hack. Internally GeoTIFF inspects `this.ifdRequests`\n * to see which fileDirectories need to be traversed. By adding the\n * ifdRequest for an 'index' manually, GeoTIFF will await that request\n * rather than traversing the file system remotely.\n */\nexport function createOffsetsProxy(tiff: GeoTIFF, offsets: number[]) {\n  const get = (target: GeoTIFF, key: any) => {\n    // Intercept `tiff.getImage`\n    if (key === 'getImage') {\n      return (index: number) => {\n        // Manually add ifdRequest to tiff if missing and we have an offset.\n        if (!(index in target.ifdRequests) && index in offsets) {\n          const offset = offsets[index];\n          target.ifdRequests[index] = target.parseFileDirectoryAt(offset);\n        }\n        return target.getImage(index);\n      };\n    }\n\n    // tiff['__viv-offsets'] === true\n    if (key === OFFSETS_PROXY_KEY) {\n      return true;\n    }\n\n    return Reflect.get(target, key);\n  };\n  return new Proxy(tiff, {get});\n}\n\n/*\n * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy\n * handler intercepts calls to `tiff.readRasters` and injects\n * a pool argument to every call. This means our TiffPixelSource\n * doesn't need to be aware of whether a decoder pool is in use.\n *\n * > tiff.readRasters({ window }) -> tiff.readRasters({ window, pool });\n */\nexport function createPoolProxy(tiff: GeoTIFF, pool: Pool) {\n  const get = (target: GeoTIFF, key: any) => {\n    // Intercept calls to `image.readRasters`\n    if (key === 'readRasters') {\n      return (options: Parameters<typeof target.readRasters>) => {\n        // Inject `pool` argument with other raster options.\n        // @ts-ignore\n        return target.readRasters({...options, pool});\n      };\n    }\n\n    // tiff['__viv-decoder-pool'] === true\n    if (key === POOL_PROXY_KEY) {\n      return true;\n    }\n\n    return Reflect.get(target, key);\n  };\n  return new Proxy(tiff, {get});\n}\n"],"file":"proxies.js"}
+{"version":3,"sources":["../../../../src/lib/utils/proxies.ts"],"names":["VIV_PROXY_KEY","OFFSETS_PROXY_KEY","POOL_PROXY_KEY","checkProxies","tiff","isProxy","console","warn","proxyFlag","createOffsetsProxy","offsets","get","target","key","index","ifdRequests","offset","parseFileDirectoryAt","getImage","Reflect","Proxy","createPoolProxy","pool","options","readRasters"],"mappings":"AAGA,MAAMA,aAAa,GAAG,OAAtB;AACA,MAAMC,iBAAiB,aAAMD,aAAN,aAAvB;AACA,MAAME,cAAc,aAAMF,aAAN,kBAApB;AAMA,OAAO,SAASG,YAAT,CAAsBC,IAAtB,EAAqC;AAC1C,MAAI,CAACC,OAAO,CAACD,IAAD,EAAOH,iBAAP,CAAZ,EAAuC;AACrCK,IAAAA,OAAO,CAACC,IAAR,CAAa,0CAAb;AACD;;AAED,MAAI,CAACF,OAAO,CAACD,IAAD,EAAOF,cAAP,CAAZ,EAAoC;AAClCI,IAAAA,OAAO,CAACC,IAAR,CAAa,+CAAb;AACD;AACF;;AAOD,SAASF,OAAT,CAAiBD,IAAjB,EAAgCI,SAAhC,EAAmD;AACjD,SAAQJ,IAAD,CAAcI,SAAd,CAAP;AACD;;AAYD,OAAO,SAASC,kBAAT,CAA4BL,IAA5B,EAA2CM,OAA3C,EAA8D;AACnE,QAAMC,GAAG,GAAG,CAACC,MAAD,EAAkBC,GAAlB,KAA+B;AAEzC,QAAIA,GAAG,KAAK,UAAZ,EAAwB;AACtB,aAAQC,KAAD,IAAmB;AAExB,YAAI,EAAEA,KAAK,IAAIF,MAAM,CAACG,WAAlB,KAAkCD,KAAK,IAAIJ,OAA/C,EAAwD;AACtD,gBAAMM,MAAM,GAAGN,OAAO,CAACI,KAAD,CAAtB;AACAF,UAAAA,MAAM,CAACG,WAAP,CAAmBD,KAAnB,IAA4BF,MAAM,CAACK,oBAAP,CAA4BD,MAA5B,CAA5B;AACD;;AACD,eAAOJ,MAAM,CAACM,QAAP,CAAgBJ,KAAhB,CAAP;AACD,OAPD;AAQD;;AAGD,QAAID,GAAG,KAAKZ,iBAAZ,EAA+B;AAC7B,aAAO,IAAP;AACD;;AAED,WAAOkB,OAAO,CAACR,GAAR,CAAYC,MAAZ,EAAoBC,GAApB,CAAP;AACD,GAnBD;;AAoBA,SAAO,IAAIO,KAAJ,CAAUhB,IAAV,EAAgB;AAACO,IAAAA;AAAD,GAAhB,CAAP;AACD;AAUD,OAAO,SAASU,eAAT,CAAyBjB,IAAzB,EAAwCkB,IAAxC,EAAoD;AACzD,QAAMX,GAAG,GAAG,CAACC,MAAD,EAAkBC,GAAlB,KAA+B;AAEzC,QAAIA,GAAG,KAAK,aAAZ,EAA2B;AACzB,aAAQU,OAAD,IAAoD;AAGzD,eAAOX,MAAM,CAACY,WAAP,CAAmB,EAAC,GAAGD,OAAJ;AAAaD,UAAAA;AAAb,SAAnB,CAAP;AACD,OAJD;AAKD;;AAGD,QAAIT,GAAG,KAAKX,cAAZ,EAA4B;AAC1B,aAAO,IAAP;AACD;;AAED,WAAOiB,OAAO,CAACR,GAAR,CAAYC,MAAZ,EAAoBC,GAApB,CAAP;AACD,GAhBD;;AAiBA,SAAO,IAAIO,KAAJ,CAAUhB,IAAV,EAAgB;AAACO,IAAAA;AAAD,GAAhB,CAAP;AACD","sourcesContent":["import type {GeoTIFF} from 'geotiff';\nimport type Pool from './Pool';\n\nconst VIV_PROXY_KEY = '__viv';\nconst OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets` as const;\nconst POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool` as const;\n\n/*\n * Inspect if the GeoTIFF source is wrapped in our proxies,\n * and warn if missing.\n */\nexport function checkProxies(tiff: GeoTIFF) {\n  if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {\n    console.warn('GeoTIFF source is missing offsets proxy.'); // eslint-disable-line no-console\n  }\n\n  if (!isProxy(tiff, POOL_PROXY_KEY)) {\n    console.warn('GeoTIFF source is missing decoder-pool proxy.'); // eslint-disable-line no-console\n  }\n}\n\n/*\n * > isProxy(tiff, POOL_PROXY_KEY) === true; // false\n * > tiff = createPoolProxy(tiff, new Pool());\n * > isProxy(tiff, POOL_PROXY_KEY) === true; // true\n */\nfunction isProxy(tiff: GeoTIFF, proxyFlag: string) {\n  return (tiff as any)[proxyFlag] as boolean;\n}\n\n/*\n * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy\n * handler intercepts calls to `tiff.getImage` and uses our custom\n * pre-computed offsets to pre-fetch the correct file directory.\n *\n * This is a bit of a hack. Internally GeoTIFF inspects `this.ifdRequests`\n * to see which fileDirectories need to be traversed. By adding the\n * ifdRequest for an 'index' manually, GeoTIFF will await that request\n * rather than traversing the file system remotely.\n */\nexport function createOffsetsProxy(tiff: GeoTIFF, offsets: number[]) {\n  const get = (target: GeoTIFF, key: any) => {\n    // Intercept `tiff.getImage`\n    if (key === 'getImage') {\n      return (index: number) => {\n        // Manually add ifdRequest to tiff if missing and we have an offset.\n        if (!(index in target.ifdRequests) && index in offsets) {\n          const offset = offsets[index];\n          target.ifdRequests[index] = target.parseFileDirectoryAt(offset);\n        }\n        return target.getImage(index);\n      };\n    }\n\n    // tiff['__viv-offsets'] === true\n    if (key === OFFSETS_PROXY_KEY) {\n      return true;\n    }\n\n    return Reflect.get(target, key);\n  };\n  return new Proxy(tiff, {get});\n}\n\n/*\n * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy\n * handler intercepts calls to `tiff.readRasters` and injects\n * a pool argument to every call. This means our TiffPixelSource\n * doesn't need to be aware of whether a decoder pool is in use.\n *\n * > tiff.readRasters({ window }) -> tiff.readRasters({ window, pool });\n */\nexport function createPoolProxy(tiff: GeoTIFF, pool: Pool) {\n  const get = (target: GeoTIFF, key: any) => {\n    // Intercept calls to `image.readRasters`\n    if (key === 'readRasters') {\n      return (options: Parameters<typeof target.readRasters>) => {\n        // Inject `pool` argument with other raster options.\n        // @ts-ignore\n        return target.readRasters({...options, pool});\n      };\n    }\n\n    // tiff['__viv-decoder-pool'] === true\n    if (key === POOL_PROXY_KEY) {\n      return true;\n    }\n\n    return Reflect.get(target, key);\n  };\n  return new Proxy(tiff, {get});\n}\n"],"file":"proxies.js"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { loadGeoTiff } from './lib/load-geotiff';
+export { default as TiffPixelSource } from './lib/tiff-pixel-source';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiffPixelSource = exports.loadGeoTiff = void 0;
+var load_geotiff_1 = require("./lib/load-geotiff");
+Object.defineProperty(exports, "loadGeoTiff", { enumerable: true, get: function () { return load_geotiff_1.loadGeoTiff; } });
+var tiff_pixel_source_1 = require("./lib/tiff-pixel-source");
+Object.defineProperty(exports, "TiffPixelSource", { enumerable: true, get: function () { return __importDefault(tiff_pixel_source_1).default; } });

package/dist/lib/load-geotiff.d.ts

@@ -0,0 +1,28 @@
+import { GeoTIFF } from 'geotiff';
+import type TiffPixelSource from './tiff-pixel-source';
+/** Options for initializing a tiff pixel source. */
+interface GeoTIFFOptions {
+    /** Headers passed to each underlying request. */
+    headers?: Record<string, unknown>;
+    /** Performance enhancment to index the remote tiff source using pre-computed byte-offsets. Generated via https://github.com/ilan-gold/generate-tiff-offsets */
+    offsets?: number[];
+    /** Indicates whether a multi-threaded pool of image decoders should be used to decode tiles. */
+    pool?: boolean;
+}
+interface GeoTIFFData {
+    data: TiffPixelSource<string[]>[];
+    metadata: Record<string, unknown>;
+}
+/**
+ * Opens an OME-TIFF via URL and returns data source and associated metadata for first image.
+ *
+ * @param source url string, File/Blob object, or GeoTIFF object
+ * @param opts options for initializing a tiff pixel source.
+ *  - `opts.headers` are passed to each underlying fetch request.
+ *  - `opts.offsets` are a performance enhancment to index the remote tiff source using pre-computed byte-offsets.
+ *  - `opts.pool` indicates whether a multi-threaded pool of image decoders should be used to decode tiles (default = true).
+ * @return data source and associated OME-Zarr metadata.
+ */
+export declare function loadGeoTiff(source: string | Blob | GeoTIFF, opts?: GeoTIFFOptions): Promise<GeoTIFFData>;
+export {};
+//# sourceMappingURL=load-geotiff.d.ts.map

package/dist/lib/load-geotiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-geotiff.d.ts","sourceRoot":"","sources":["../../src/lib/load-geotiff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,OAAO,EAAC,MAAM,SAAS,CAAC;AAUnD,OAAO,KAAK,eAAe,MAAM,qBAAqB,CAAC;AAEvD,oDAAoD;AACpD,UAAU,cAAc;IACtB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,+JAA+J;IAC/J,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gGAAgG;IAChG,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,EAC/B,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,WAAW,CAAC,CA2CtB"}

package/dist/lib/load-geotiff.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGeoTiff = void 0;
+const geotiff_1 = require("geotiff");
+const proxies_1 = require("./utils/proxies");
+// import Pool from './lib/Pool';
+const load_ome_tiff_1 = require("./ome/load-ome-tiff");
+/**
+ * Opens an OME-TIFF via URL and returns data source and associated metadata for first image.
+ *
+ * @param source url string, File/Blob object, or GeoTIFF object
+ * @param opts options for initializing a tiff pixel source.
+ *  - `opts.headers` are passed to each underlying fetch request.
+ *  - `opts.offsets` are a performance enhancment to index the remote tiff source using pre-computed byte-offsets.
+ *  - `opts.pool` indicates whether a multi-threaded pool of image decoders should be used to decode tiles (default = true).
+ * @return data source and associated OME-Zarr metadata.
+ */
+async function loadGeoTiff(source, opts = {}) {
+    const { headers, offsets } = opts;
+    // Create tiff source
+    let tiff;
+    if (source instanceof geotiff_1.GeoTIFF) {
+        tiff = source;
+    }
+    else if (typeof source === 'string') {
+        tiff = await (0, geotiff_1.fromUrl)(source, headers);
+    }
+    else {
+        tiff = await (0, geotiff_1.fromBlob)(source);
+    }
+    // if (pool) {
+    /*
+     * Creates a worker pool to decode tiff tiles. Wraps tiff
+     * in a Proxy that injects 'pool' into `tiff.readRasters`.
+     */
+    // tiff = createPoolProxy(tiff, new Pool());
+    // }
+    if (offsets) {
+        /*
+         * Performance enhancement. If offsets are provided, we
+         * create a proxy that intercepts calls to `tiff.getImage`
+         * and injects the pre-computed offsets.
+         */
+        tiff = (0, proxies_1.createOffsetsProxy)(tiff, offsets);
+    }
+    /*
+     * Inspect tiff source for our performance enhancing proxies.
+     * Prints warnings to console if `offsets` or `pool` are missing.
+     */
+    (0, proxies_1.checkProxies)(tiff);
+    const firstImage = await tiff.getImage(0);
+    if ((0, load_ome_tiff_1.isOmeTiff)(firstImage)) {
+        return (0, load_ome_tiff_1.loadOmeTiff)(tiff, firstImage);
+    }
+    throw new Error('GeoTIFF not recognized.');
+}
+exports.loadGeoTiff = loadGeoTiff;

package/dist/lib/ome/load-ome-tiff.d.ts

@@ -0,0 +1,50 @@
+import type { GeoTIFF, GeoTIFFImage } from 'geotiff';
+import TiffPixelSource from '../tiff-pixel-source';
+export declare const isOmeTiff: (img: GeoTIFFImage) => boolean;
+export declare function loadOmeTiff(tiff: GeoTIFF, firstImage: GeoTIFFImage): Promise<{
+    data: TiffPixelSource<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>[];
+    metadata: {
+        format(): {
+            'Acquisition Date': string;
+            'Dimensions (XY)': string;
+            'Pixels Type': "uint8" | "uint16" | "uint32" | "float" | "double" | "int8" | "int16" | "int32" | "bit" | "complex" | "double-complex";
+            'Pixels Size (XYZ)': string;
+            'Z-sections/Timepoints': string;
+            Channels: number;
+        };
+        AquisitionDate: string;
+        Description: string;
+        Pixels: {
+            Channels: ({
+                Color: [number, number, number, number];
+                ID: string;
+                SamplesPerPixel: number;
+                Name?: string | undefined;
+            } | {
+                ID: string;
+                SamplesPerPixel: number;
+                Name?: string | undefined;
+            })[];
+            PhysicalSizeX: number;
+            PhysicalSizeY: number;
+            PhysicalSizeZ: number;
+            SignificantBits: number;
+            SizeX: number;
+            SizeY: number;
+            SizeZ: number;
+            SizeT: number;
+            SizeC: number;
+            PhysicalSizeXUnit: import("./omexml").UnitsLength;
+            PhysicalSizeYUnit: import("./omexml").UnitsLength;
+            PhysicalSizeZUnit: import("./omexml").UnitsLength;
+            BigEndian: boolean;
+            Interleaved: boolean;
+            ID: string;
+            DimensionOrder: import("./omexml").DimensionOrder;
+            Type: "uint8" | "uint16" | "uint32" | "float" | "double" | "int8" | "int16" | "int32" | "bit" | "complex" | "double-complex";
+        };
+        ID: string;
+        Name: string;
+    };
+}>;
+//# sourceMappingURL=load-ome-tiff.d.ts.map

package/dist/lib/ome/load-ome-tiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-ome-tiff.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/load-ome-tiff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAEnD,OAAO,eAAe,MAAM,sBAAsB,CAAC;AAMnD,eAAO,MAAM,SAAS,QAAS,YAAY,YAAwD,CAAC;AAEpG,wBAAsB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCxE"}

package/dist/lib/ome/load-ome-tiff.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadOmeTiff = exports.isOmeTiff = void 0;
+const tiff_pixel_source_1 = __importDefault(require("../tiff-pixel-source"));
+const ome_indexers_1 = require("./ome-indexers");
+const ome_utils_1 = require("./ome-utils");
+const omexml_1 = require("./omexml");
+const isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes('<OME');
+exports.isOmeTiff = isOmeTiff;
+async function loadOmeTiff(tiff, firstImage) {
+    // Get first image from tiff and inspect OME-XML metadata
+    const { ImageDescription, SubIFDs, PhotometricInterpretation: photometricInterpretation } = firstImage.fileDirectory;
+    const omexml = (0, omexml_1.fromString)(ImageDescription);
+    /*
+     * Image pyramids are stored differently between versions of Bioformats.
+     * Thus we need a different indexer depending on which format we have.
+     */
+    let levels;
+    let pyramidIndexer;
+    if (SubIFDs) {
+        // Image is >= Bioformats 6.0 and resolutions are stored using SubIFDs.
+        levels = SubIFDs.length + 1;
+        pyramidIndexer = (0, ome_indexers_1.getOmeSubIFDIndexer)(tiff, omexml);
+    }
+    else {
+        // Image is legacy format; resolutions are stored as separate images.
+        levels = omexml.length;
+        pyramidIndexer = (0, ome_indexers_1.getOmeLegacyIndexer)(tiff, omexml);
+    }
+    // TODO: The OmeTIFF loader only works for the _first_ image in the metadata.
+    const imgMeta = omexml[0];
+    const { labels, getShape, physicalSizes, dtype } = (0, ome_utils_1.getOmePixelSourceMeta)(imgMeta);
+    const tileSize = firstImage.getTileWidth();
+    const meta = { photometricInterpretation, physicalSizes };
+    const data = Array.from({ length: levels }).map((_, resolution) => {
+        const shape = getShape(resolution);
+        const indexer = (sel) => pyramidIndexer(sel, resolution);
+        const source = new tiff_pixel_source_1.default(indexer, dtype, tileSize, shape, labels, meta);
+        return source;
+    });
+    return { data, metadata: imgMeta };
+}
+exports.loadOmeTiff = loadOmeTiff;

package/dist/lib/ome/ome-indexers.d.ts

@@ -0,0 +1,11 @@
+import type { GeoTIFFImage, GeoTIFF } from 'geotiff';
+import type { OMEXML } from '../ome/omexml';
+export declare type OmeTiffSelection = {
+    t: number;
+    c: number;
+    z: number;
+};
+export declare type OmeTiffIndexer = (sel: OmeTiffSelection, z: number) => Promise<GeoTIFFImage>;
+export declare function getOmeLegacyIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffIndexer;
+export declare function getOmeSubIFDIndexer(tiff: GeoTIFF, rootMeta: OMEXML): OmeTiffIndexer;
+//# sourceMappingURL=ome-indexers.d.ts.map

package/dist/lib/ome/ome-indexers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ome-indexers.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-indexers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAE,OAAO,EAAqB,MAAM,SAAS,CAAC;AACvE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,oBAAY,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AACjE,oBAAY,cAAc,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAqBzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAanF;AAgBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAuCnF"}

package/dist/lib/ome/ome-indexers.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOmeSubIFDIndexer = exports.getOmeLegacyIndexer = void 0;
+/*
+ * An "indexer" for a GeoTIFF-based source is a function that takes a
+ * "selection" (e.g. { z, t, c }) and returns a Promise for the GeoTIFFImage
+ * object corresponding to that selection.
+ *
+ * For OME-TIFF images, the "selection" object is the same regardless of
+ * the format version. However, modern version of Bioformats have a different
+ * memory layout for pyramidal resolutions. Thus, we have two different "indexers"
+ * depending on which format version is detected.
+ *
+ * TODO: We currently only support indexing the first image in the OME-TIFF with
+ * our indexers. There can be multiple images in an OME-TIFF, so supporting these
+ * images will require extending these indexers or creating new methods.
+ */
+/*
+ * Returns an indexer for legacy Bioformats images. This assumes that
+ * downsampled resolutions are stored sequentially in the OME-TIFF.
+ */
+function getOmeLegacyIndexer(tiff, rootMeta) {
+    const imgMeta = rootMeta[0];
+    const { SizeT, SizeC, SizeZ } = imgMeta.Pixels;
+    const ifdIndexer = getOmeIFDIndexer(imgMeta);
+    return (sel, pyramidLevel) => {
+        // Get IFD index at base pyramid level
+        const index = ifdIndexer(sel);
+        // Get index of first image at pyramidal level
+        const pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;
+        // Return image at IFD index for pyramidal level
+        return tiff.getImage(index + pyramidIndex);
+    };
+}
+exports.getOmeLegacyIndexer = getOmeLegacyIndexer;
+/*
+ * Returns an indexer for modern Bioforamts images that store multiscale
+ * resolutions using SubIFDs.
+ *
+ * The ifdIndexer returns the 'index' to the base resolution for a
+ * particular 'selection'. The SubIFDs to the downsampled resolutions
+ * of the 'selection' are stored within the `baseImage.fileDirectory`.
+ * We use the SubIFDs to get the IFD for the corresponding sub-resolution.
+ *
+ * NOTE: This function create a custom IFD cache rather than mutating
+ * `GeoTIFF.ifdRequests` with a random offset. The IFDs are cached in
+ * an ES6 Map that maps a string key that identifies the selection uniquely
+ * to the corresponding IFD.
+ */
+function getOmeSubIFDIndexer(tiff, rootMeta) {
+    const imgMeta = rootMeta[0];
+    const ifdIndexer = getOmeIFDIndexer(imgMeta);
+    const ifdCache = new Map();
+    return async (sel, pyramidLevel) => {
+        const index = ifdIndexer(sel);
+        const baseImage = await tiff.getImage(index);
+        // It's the highest resolution, no need to look up SubIFDs.
+        if (pyramidLevel === 0) {
+            return baseImage;
+        }
+        const { SubIFDs } = baseImage.fileDirectory;
+        if (!SubIFDs) {
+            throw Error('Indexing Error: OME-TIFF is missing SubIFDs.');
+        }
+        // Get IFD for the selection at the pyramidal level
+        const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;
+        if (!ifdCache.has(key)) {
+            // Only create a new request if we don't have the key.
+            const subIfdOffset = SubIFDs[pyramidLevel - 1];
+            ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));
+        }
+        const ifd = (await ifdCache.get(key));
+        // Create a new image object manually from IFD
+        // https://github.com/geotiffjs/geotiff.js/blob/8ef472f41b51d18074aece2300b6a8ad91a21ae1/src/geotiff.js#L447-L453
+        return new baseImage.constructor(ifd.fileDirectory, ifd.geoKeyDirectory, tiff.dataView, tiff.littleEndian, tiff.cache, tiff.source);
+    };
+}
+exports.getOmeSubIFDIndexer = getOmeSubIFDIndexer;
+/*
+ * Returns a function that computes the image index based on the dimension
+ * order and dimension sizes.
+ */
+function getOmeIFDIndexer(imgMeta) {
+    const { SizeC, SizeZ, SizeT, DimensionOrder } = imgMeta.Pixels;
+    switch (DimensionOrder) {
+        case 'XYZCT': {
+            return ({ t, c, z }) => t * SizeZ * SizeC + c * SizeZ + z;
+        }
+        case 'XYZTC': {
+            return ({ t, c, z }) => c * SizeZ * SizeT + t * SizeZ + z;
+        }
+        case 'XYCTZ': {
+            return ({ t, c, z }) => z * SizeC * SizeT + t * SizeC + c;
+        }
+        case 'XYCZT': {
+            return ({ t, c, z }) => t * SizeC * SizeZ + z * SizeC + c;
+        }
+        case 'XYTCZ': {
+            return ({ t, c, z }) => z * SizeT * SizeC + c * SizeT + t;
+        }
+        case 'XYTZC': {
+            return ({ t, c, z }) => c * SizeT * SizeZ + z * SizeT + t;
+        }
+        default: {
+            throw new Error(`Invalid OME-XML DimensionOrder, got ${DimensionOrder}.`);
+        }
+    }
+}

package/dist/lib/ome/ome-utils.d.ts

@@ -0,0 +1,28 @@
+import type { OMEXML, UnitsLength } from './omexml';
+export declare const DTYPE_LOOKUP: {
+    readonly uint8: "Uint8";
+    readonly uint16: "Uint16";
+    readonly uint32: "Uint32";
+    readonly float: "Float32";
+    readonly double: "Float64";
+    readonly int8: "Int8";
+    readonly int16: "Int16";
+    readonly int32: "Int32";
+};
+export declare function getOmePixelSourceMeta({ Pixels }: OMEXML[0]): {
+    labels: import("../../types").Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
+    getShape: (level: number) => number[];
+    physicalSizes: {
+        [k: string]: {
+            size: number;
+            unit: UnitsLength;
+        };
+    };
+    dtype: "Uint8" | "Uint16" | "Uint32" | "Float32" | "Float64" | "Int8" | "Int16" | "Int32";
+} | {
+    labels: import("../../types").Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
+    getShape: (level: number) => number[];
+    dtype: "Uint8" | "Uint16" | "Uint32" | "Float32" | "Float64" | "Int8" | "Int16" | "Int32";
+    physicalSizes?: undefined;
+};
+//# sourceMappingURL=ome-utils.d.ts.map

package/dist/lib/ome/ome-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ome-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAE,WAAW,EAAC,MAAM,UAAU,CAAC;AAElD,eAAO,MAAM,YAAY;;;;;;;;;CASf,CAAC;AAEX,wBAAgB,qBAAqB,CAAC,EAAC,MAAM,EAAC,EAAE,MAAM,CAAC,CAAC,CAAC;;sBAoB9B,MAAM;;;kBAcP,MAAM;kBAAQ,WAAW;;;;;;sBAdxB,MAAM;;;EAmChC"}

package/dist/lib/ome/ome-utils.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOmePixelSourceMeta = exports.DTYPE_LOOKUP = void 0;
+const utils_1 = require("./utils");
+exports.DTYPE_LOOKUP = {
+    uint8: 'Uint8',
+    uint16: 'Uint16',
+    uint32: 'Uint32',
+    float: 'Float32',
+    double: 'Float64',
+    int8: 'Int8',
+    int16: 'Int16',
+    int32: 'Int32'
+};
+function getOmePixelSourceMeta({ Pixels }) {
+    // e.g. 'XYZCT' -> ['t', 'c', 'z', 'y', 'x']
+    const labels = (0, utils_1.getLabels)(Pixels.DimensionOrder);
+    // Compute "shape" of image
+    const dims = (0, utils_1.getDims)(labels);
+    const shape = Array(labels.length).fill(0);
+    shape[dims('t')] = Pixels.SizeT;
+    shape[dims('c')] = Pixels.SizeC;
+    shape[dims('z')] = Pixels.SizeZ;
+    // Push extra dimension if data are interleaved.
+    if (Pixels.Interleaved) {
+        // @ts-ignore
+        labels.push('_c');
+        shape.push(3);
+    }
+    // Creates a new shape for different level of pyramid.
+    // Assumes factor-of-two downsampling.
+    const getShape = (level) => {
+        const s = [...shape];
+        s[dims('x')] = Pixels.SizeX >> level;
+        s[dims('y')] = Pixels.SizeY >> level;
+        return s;
+    };
+    if (!(Pixels.Type in exports.DTYPE_LOOKUP)) {
+        throw Error(`Pixel type ${Pixels.Type} not supported.`);
+    }
+    const dtype = exports.DTYPE_LOOKUP[Pixels.Type];
+    if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {
+        const physicalSizes = {
+            x: {
+                size: Pixels.PhysicalSizeX,
+                unit: Pixels.PhysicalSizeXUnit
+            },
+            y: {
+                size: Pixels.PhysicalSizeY,
+                unit: Pixels.PhysicalSizeYUnit
+            }
+        };
+        if (Pixels.PhysicalSizeZ) {
+            physicalSizes.z = {
+                size: Pixels.PhysicalSizeZ,
+                unit: Pixels.PhysicalSizeZUnit
+            };
+        }
+        return { labels, getShape, physicalSizes, dtype };
+    }
+    return { labels, getShape, dtype };
+}
+exports.getOmePixelSourceMeta = getOmePixelSourceMeta;

package/dist/lib/ome/omexml.d.ts

@@ -0,0 +1,49 @@
+export declare function fromString(str: string): {
+    format(): {
+        'Acquisition Date': string;
+        'Dimensions (XY)': string;
+        'Pixels Type': PixelType;
+        'Pixels Size (XYZ)': string;
+        'Z-sections/Timepoints': string;
+        Channels: number;
+    };
+    AquisitionDate: string;
+    Description: string;
+    Pixels: {
+        Channels: ({
+            Color: [number, number, number, number];
+            ID: string;
+            SamplesPerPixel: number;
+            Name?: string | undefined;
+        } | {
+            ID: string;
+            SamplesPerPixel: number;
+            Name?: string | undefined;
+        })[];
+        PhysicalSizeX: number;
+        PhysicalSizeY: number;
+        PhysicalSizeZ: number;
+        SignificantBits: number;
+        SizeX: number;
+        SizeY: number;
+        SizeZ: number;
+        SizeT: number;
+        SizeC: number;
+        PhysicalSizeXUnit: UnitsLength;
+        PhysicalSizeYUnit: UnitsLength;
+        PhysicalSizeZUnit: UnitsLength;
+        BigEndian: boolean;
+        Interleaved: boolean;
+        ID: string;
+        DimensionOrder: DimensionOrder;
+        Type: PixelType;
+    };
+    ID: string;
+    Name: string;
+}[];
+export declare type OMEXML = ReturnType<typeof fromString>;
+export declare type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';
+declare type PixelType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float' | 'bit' | 'double' | 'complex' | 'double-complex';
+export declare type UnitsLength = 'Ym' | 'Zm' | 'Em' | 'Pm' | 'Tm' | 'Gm' | 'Mm' | 'km' | 'hm' | 'dam' | 'm' | 'dm' | 'cm' | 'mm' | 'µm' | 'nm' | 'pm' | 'fm' | 'am' | 'zm' | 'ym' | 'Å' | 'thou' | 'li' | 'in' | 'ft' | 'yd' | 'mi' | 'ua' | 'ly' | 'pc' | 'pt' | 'pixel' | 'reference frame';
+export {};
+//# sourceMappingURL=omexml.d.ts.map

package/dist/lib/ome/omexml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omexml.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/omexml.ts"],"names":[],"mappings":"AAmBA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8CrC;AAED,oBAAY,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AACnD,oBAAY,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAuBvF,aAAK,SAAS,GACV,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,KAAK,GACL,QAAQ,GACR,SAAS,GACT,gBAAgB,CAAC;AAErB,oBAAY,WAAW,GACnB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,OAAO,GACP,iBAAiB,CAAC"}

package/dist/lib/ome/omexml.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromString = void 0;
+const fast_xml_parser_1 = __importDefault(require("fast-xml-parser"));
+const tiff_utils_1 = require("../utils/tiff-utils");
+// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.
+const PARSER_OPTIONS = {
+    // Nests attributes withtout prefix under 'attr' key for each node
+    attributeNamePrefix: '',
+    attrNodeName: 'attr',
+    // Parses numbers for both attributes and nodes
+    parseNodeValue: true,
+    parseAttributeValue: true,
+    // Forces attributes to be parsed
+    ignoreAttributes: false
+};
+const parse = (str) => fast_xml_parser_1.default.parse(str, PARSER_OPTIONS);
+function fromString(str) {
+    const res = parse(str);
+    if (!res.OME) {
+        throw Error('Failed to parse OME-XML metadata.');
+    }
+    return (0, tiff_utils_1.ensureArray)(res.OME.Image).map((img) => {
+        const Channels = (0, tiff_utils_1.ensureArray)(img.Pixels.Channel).map((c) => {
+            if ('Color' in c.attr) {
+                return { ...c.attr, Color: (0, tiff_utils_1.intToRgba)(c.attr.Color) };
+            }
+            return { ...c.attr };
+        });
+        const { AquisitionDate = '', Description = '' } = img;
+        const image = {
+            ...img.attr,
+            AquisitionDate,
+            Description,
+            Pixels: {
+                ...img.Pixels.attr,
+                Channels
+            }
+        };
+        return {
+            ...image,
+            format() {
+                const { Pixels } = image;
+                const sizes = ['X', 'Y', 'Z']
+                    .map((name) => {
+                    const size = Pixels[`PhysicalSize${name}`];
+                    const unit = Pixels[`PhysicalSize${name}Unit`];
+                    return size && unit ? `${size} ${unit}` : '-';
+                })
+                    .join(' x ');
+                return {
+                    'Acquisition Date': image.AquisitionDate,
+                    'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,
+                    'Pixels Type': Pixels.Type,
+                    'Pixels Size (XYZ)': sizes,
+                    'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,
+                    Channels: Pixels.SizeC
+                };
+            }
+        };
+    });
+}
+exports.fromString = fromString;

package/dist/lib/ome/utils.d.ts

@@ -0,0 +1,5 @@
+import type { OMEXML } from '../ome/omexml';
+import type { Labels } from '../../types';
+export declare function getLabels(dimOrder: OMEXML[0]['Pixels']['DimensionOrder']): Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
+export declare function getDims<S extends string>(labels: S[]): (name: S) => number;
+//# sourceMappingURL=utils.d.ts.map