@ndes/iiif-images 0.0.1 → 0.1.0

package/README.md

@@ -5,8 +5,9 @@ represents them, so a frontend can reserve the right aspect ratio and pick a siz
 before the image loads.
 
 It is a quad transform for `@lde/search-indexer`. For each work with a IIIF
-Presentation manifest in `associatedMedia`, it reads the manifest, selects an image
-service, reads that service’s `info.json` and mints a nested `representativeImage`.
+Presentation manifest in `associatedMedia`, it reads the manifest, selects an image,
+reads its image service’s `info.json` if it has one and mints a nested
+`representativeImage`.
 
 ## Usage
 
@@ -62,6 +63,7 @@ again.
 ```json
 {
   "representativeImage": {
+    "url": "https://example.org/iiif/image/full/max/0/default.jpg",
     "width": 1335,
     "height": 2750,
     "sizes": [
@@ -82,14 +84,22 @@ again.
   sizes the server lists or its tiles precompute, so they are served fastest. Do not
   rely on the array’s order.
 - Use `service` only for deep zoom or region crops.
+- `url` is the image as the manifest paints it, at full size.
+- A static image, one without an image service, has only `url`, `width` and
+  `height`: no `sizes` and no `service`, because it is the only version there is
+  and cannot be resized.
 - Without `representativeImage`, use `associatedMedia[].thumbnailUrl`, with no
-  dimensions. That is the case for a work with no manifest, no image service in its
-  manifest, or a fetch that has not succeeded yet.
+  dimensions. That is the case for a work with no manifest, no image in its manifest
+  with an image service or a stated size, or a fetch that has not succeeded yet.
 
 ## Behaviour
 
-- **Selection:** the first painted image in the manifest that has an image service,
-  found by [@lde/iiif-image](https://ldelements.org/reference/iiif-image).
+- **Selection:** the first painted image in the manifest that has an image service
+  or whose width and height the manifest states, found by
+  [@lde/iiif-image](https://ldelements.org/reference/iiif-image). A static image’s
+  size comes from the manifest; an image service’s from its `info.json`. Where that
+  `info.json` is gone, the image counts as static, if the manifest states its size.
+  An image whose `id` is not an absolute `http(s)` URL is passed over.
 - **Freshness:** manifest facts are refetched after 30 days, because which image
   represents a work can change. `info.json` facts are refetched after 180 days: an
   image’s dimensions do not change, but its server’s size URLs can.

package/dist/lib/iiif-images.d.ts

@@ -39,9 +39,10 @@ export interface IiifImages {
     check(): Promise<void>;
 }
 /**
- * Enrich works with the image that represents them: its dimensions and a ladder
- * of precomputed sizes, resolved from the work’s IIIF Presentation manifest and
- * the selected image’s `info.json`.
+ * Enrich works with the image that represents them: its URL and dimensions, and
+ * for an image with an image service, a ladder of precomputed sizes, resolved
+ * from the work’s IIIF Presentation manifest and the selected image’s
+ * `info.json`. A static image is read from the manifest alone.
  *
  * A work with no manifest, or whose resolution has not succeeded, gets no
  * `representativeImage`; consumers then fall back to the `thumbnailUrl` already

package/dist/lib/iiif-images.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"iiif-images.d.ts","sourceRoot":"","sources":["../../src/lib/iiif-images.ts"],"names":[],"mappings":"AAUA,OAAO,EAIL,KAAK,iBAAiB,EAEvB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,QAAQ,EAER,YAAY,EAEb,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,IAAI,EAA6B,MAAM,cAAc,CAAC;AASpE,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACxD;AAED,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;CACzC;AAED,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,EAC1B,OAAO,EAAE,iBAAiB,KACvB,aAAa,CAAC,IAAI,CAAC,CAAC;AAEzB,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAClE,4EAA4E;IAC5E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,iBAAiB,GACzB,UAAU,CAiHZ"}
+{"version":3,"file":"iiif-images.d.ts","sourceRoot":"","sources":["../../src/lib/iiif-images.ts"],"names":[],"mappings":"AAWA,OAAO,EAKL,KAAK,iBAAiB,EAEvB,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EACV,QAAQ,EAER,YAAY,EAEb,MAAM,aAAa,CAAC;AAErB,OAAO,KAAK,EAAE,IAAI,EAA6B,MAAM,cAAc,CAAC;AASpE,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACxD;AAED,kEAAkE;AAClE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE;QAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;KAAE,CAAC;CACzC;AAED,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,CAChC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,EAC1B,OAAO,EAAE,iBAAiB,KACvB,aAAa,CAAC,IAAI,CAAC,CAAC;AAEzB,MAAM,WAAW,UAAU;IACzB;;;;;OAKG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,mBAAmB,GAAG,SAAS,CAAC;IAClE,4EAA4E;IAC5E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,iBAAiB,GACzB,UAAU,CAoHZ"}

package/dist/lib/iiif-images.js

@@ -1,13 +1,14 @@
-import { imageServices, readImageService, } from '@lde/iiif-image';
+import { images, readImageService, } from '@lde/iiif-image';
 import { fetchPublic, RefusedUrlError, ResponseTooLargeError, } from '@lde/public-fetch';
 import { createResolver, sqliteFactStore, urlHost, } from '@lde/resolver';
 import { fieldNamed, irAlias, referenceTypeNamed } from '@lde/search/adapter';
 import { DataFactory } from 'rdf-data-factory';
 import { iiifImage, iiifImageService, iiifImageSize, representativeImageField, } from '../schema.js';
 /**
- * Enrich works with the image that represents them: its dimensions and a ladder
- * of precomputed sizes, resolved from the work’s IIIF Presentation manifest and
- * the selected image’s `info.json`.
+ * Enrich works with the image that represents them: its URL and dimensions, and
+ * for an image with an image service, a ladder of precomputed sizes, resolved
+ * from the work’s IIIF Presentation manifest and the selected image’s
+ * `info.json`. A static image is read from the manifest alone.
  *
  * A work with no manifest, or whose resolution has not succeeded, gets no
  * `representativeImage`; consumers then fall back to the `thumbnailUrl` already
@@ -28,8 +29,7 @@ export function iiifImages(schema, options) {
         host: (reference) => reference.dataset,
         fetch: (references, { signal }) => fetchFacts(references.map(({ url }) => url), (url) => url, (document) => {
             try {
-                const [service] = imageServices(document);
-                return service;
+                return firstUsable(images(document));
             }
             catch (error) {
                 // A document that says it is a collection, or a manifest too broken
@@ -46,10 +46,12 @@ export function iiifImages(schema, options) {
             path: options.storePath,
             table: 'manifests',
         }),
+        // 2: the selected image rather than its service’s URL, and static images too.
+        version: '2',
         limits: { ...limits, ttlMs: MANIFEST_TTL_MS },
         report,
     });
-    const images = createResolver({
+    const services = createResolver({
         key: (service) => service,
         host: urlHost,
         fetch: (services, { signal }) => fetchFacts(services, (service) => `${service}/info.json`, (info, service) => {
@@ -84,27 +86,25 @@ export function iiifImages(schema, options) {
                     const manifestOfWork = manifestsIn(batch, aliases);
                     const dataset = context.dataset.iri.toString();
                     const selected = await manifests.resolveAll([...manifestOfWork.values()].map((url) => ({ url, dataset })));
-                    const serviceOfWork = new Map();
+                    const imageOfWork = new Map();
                     for (const [work, manifest] of manifestOfWork) {
                         const resolution = selected.get(manifest);
                         if (resolution?.outcome === 'resolved') {
-                            serviceOfWork.set(work, resolution.fact);
+                            imageOfWork.set(work, resolution.fact);
                         }
                     }
-                    const resolved = await images.resolveAll([
-                        ...serviceOfWork.values(),
-                    ]);
-                    for (const [work, service] of serviceOfWork) {
-                        const resolution = resolved.get(service);
-                        if (resolution?.outcome === 'resolved') {
-                            yield* mint(factory.namedNode(work), resolution.fact, aliases);
+                    const resolved = await services.resolveAll([...imageOfWork.values()].flatMap(({ service }) => service === undefined ? [] : [service]));
+                    for (const [work, image] of imageOfWork) {
+                        const representative = representativeOf(image, resolved);
+                        if (representative !== undefined) {
+                            yield* mint(factory.namedNode(work), representative, aliases);
                         }
                     }
                 };
         },
         async check() {
             await manifests.check();
-            await images.check();
+            await services.check();
         },
     };
 }
@@ -128,6 +128,50 @@ const IIIF_TYPES = new Set([
 ]);
 /** Answers meaning this document is not ours to have, now or on a retry. */
 const ABSENT_STATUSES = new Set([401, 403, 404, 410]);
+/**
+ * The first image that can represent the work: one with an image service, whose
+ * `info.json` states its dimensions, or a static image whose manifest states
+ * them. Without a size to state, a static image adds nothing to the
+ * `thumbnailUrl` consumers already have. Its URL is minted as an IRI, so an image
+ * whose `id` is not an absolute web address is passed over.
+ */
+function firstUsable(painted) {
+    for (const image of painted) {
+        const url = webAddress(image.url);
+        if (url !== undefined &&
+            (image.service !== undefined || staticOf(image) !== undefined)) {
+            return { ...image, url };
+        }
+    }
+    return undefined;
+}
+/**
+ * The image to mint, or `undefined` while its image service is not resolved.
+ * An image service found to be gone leaves the size the manifest states, if any.
+ */
+function representativeOf(image, resolved) {
+    const resolution = image.service === undefined ? undefined : resolved.get(image.service);
+    if (resolution?.outcome === 'resolved') {
+        return { ...resolution.fact, url: image.url, service: resolution.fact.url };
+    }
+    return image.service === undefined || resolution?.outcome === 'absent'
+        ? staticOf(image)
+        : undefined;
+}
+/** The image as the manifest states it, without sizes or a service. */
+function staticOf(image) {
+    return image.width === undefined || image.height === undefined
+        ? undefined
+        : { url: image.url, width: image.width, height: image.height, sizes: [] };
+}
+/** The URL, normalised, if it is an absolute `http(s)` one. */
+function webAddress(url) {
+    if (!URL.canParse(url)) {
+        return undefined;
+    }
+    const { protocol, href } = new URL(url);
+    return protocol === 'http:' || protocol === 'https:' ? href : undefined;
+}
 function aliasesOf(rootType, schema) {
     const media = fieldNamed(rootType, 'associatedMedia');
     const image = fieldNamed(rootType, representativeImageField.name);
@@ -269,6 +313,7 @@ function declaresIiifType(document) {
 function* mint(work, fact, aliases) {
     const image = factory.blankNode();
     yield triple(work, aliases.representativeImage, image);
+    yield triple(image, aliases.image.url, factory.namedNode(fact.url));
     yield triple(image, aliases.image.width, integer(fact.width));
     yield triple(image, aliases.image.height, integer(fact.height));
     for (const size of fact.sizes) {
@@ -278,9 +323,11 @@ function* mint(work, fact, aliases) {
         yield triple(node, aliases.size.height, integer(size.height));
         yield triple(node, aliases.size.url, factory.namedNode(size.url));
     }
-    const service = factory.blankNode();
-    yield triple(image, aliases.image.service, service);
-    yield triple(service, aliases.service.url, factory.namedNode(fact.url));
+    if (fact.service !== undefined) {
+        const service = factory.blankNode();
+        yield triple(image, aliases.image.service, service);
+        yield triple(service, aliases.service.url, factory.namedNode(fact.service));
+    }
 }
 function triple(subject, predicate, object) {
     return factory.quad(subject, factory.namedNode(predicate), object);

package/dist/schema.d.ts

@@ -35,12 +35,21 @@ export declare const iiifImageService: {
     }];
 };
 /**
- * The image that represents a work: the full dimensions, and the renditions a
- * consumer can pick from without knowing Image API compliance levels.
+ * The image that represents a work: the image the manifest paints, its full
+ * dimensions, and the renditions a consumer can pick from without knowing Image
+ * API compliance levels.
  */
 export declare const iiifImage: {
     readonly name: "IiifImage";
     readonly fields: readonly [{
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/contentUrl>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }, {
         readonly name: "width";
         readonly kind: "integer";
         readonly output: true;
@@ -107,6 +116,14 @@ export declare const iiifImageTypes: ({
 } | {
     readonly name: "IiifImage";
     readonly fields: readonly [{
+        readonly name: "url";
+        readonly kind: "reference";
+        readonly output: true;
+        readonly path: "<https://schema.org/contentUrl>";
+        readonly ref: {
+            readonly strategy: "idOnly";
+        };
+    }, {
         readonly name: "width";
         readonly kind: "integer";
         readonly output: true;

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAKA,6EAA6E;AAC7E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAkBK,CAAC;AAEhC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAWE,CAAC;AAEhC;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BS,CAAC;AAEhC,8EAA8E;AAC9E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA+C,CAAC;AAE3E;kCACkC;AAClC,eAAO,MAAM,wBAAwB;;;;;;;;;CAML,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAKA,6EAA6E;AAC7E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;CAkBK,CAAC;AAEhC,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAWE,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCS,CAAC;AAEhC,8EAA8E;AAC9E,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAA+C,CAAC;AAE3E;kCACkC;AAClC,eAAO,MAAM,wBAAwB;;;;;;;;;CAML,CAAC"}

package/dist/schema.js

@@ -34,12 +34,20 @@ export const iiifImageService = {
     ],
 };
 /**
- * The image that represents a work: the full dimensions, and the renditions a
- * consumer can pick from without knowing Image API compliance levels.
+ * The image that represents a work: the image the manifest paints, its full
+ * dimensions, and the renditions a consumer can pick from without knowing Image
+ * API compliance levels.
  */
 export const iiifImage = {
     name: 'IiifImage',
     fields: [
+        {
+            name: 'url',
+            kind: 'reference',
+            output: true,
+            path: `<${SCHEMA}contentUrl>`,
+            ref: { strategy: 'idOnly' },
+        },
         { name: 'width', kind: 'integer', output: true, path: `<${SCHEMA}width>` },
         {
             name: 'height',

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@ndes/iiif-images",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Enriches SCHEMA-AP-NDE works with the dimensions and sizes of their representative IIIF image, as a quad transform for the search indexer.",
+  "repository": {
+    "url": "git+https://github.com/netwerk-digitaal-erfgoed/stack.git",
+    "directory": "packages/iiif-images"
+  },
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -27,7 +31,7 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
-    "@lde/iiif-image": "^0.1.0",
+    "@lde/iiif-image": "^0.2.0",
     "@lde/public-fetch": "^0.1.0",
     "@lde/resolver": "^0.2.1",
     "@rdfjs/types": "^2.0.1",
@@ -50,4 +54,4 @@
   "nx": {
     "name": "iiif-images"
   }
-}
+}

package/dist/lib/image-service.d.ts

@@ -1,26 +0,0 @@
-/** What an image service’s `info.json` tells a consumer, in the consumer’s terms. */
-export interface ImageFact {
-    readonly width: number;
-    readonly height: number;
-    /** Renditions to pick from, smallest first. */
-    readonly sizes: readonly ImageSize[];
-    /** The service itself, for consumers doing deep zoom or region crops. */
-    readonly service: {
-        readonly url: string;
-        readonly type: string;
-        readonly profile: string;
-    };
-}
-export interface ImageSize {
-    readonly width: number;
-    readonly height: number;
-    readonly url: string;
-}
-/**
- * An `info.json` as an {@link ImageFact}, or `undefined` where it states no
- * dimensions. `serviceUrl` rather than the document’s own `id` names the service,
- * because that is what the manifest resolved and what a proxied server’s
- * self-reported `id` need not be.
- */
-export declare function imageFactFrom(serviceUrl: string, info: unknown): ImageFact | undefined;
-//# sourceMappingURL=image-service.d.ts.map

package/dist/lib/image-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"image-service.d.ts","sourceRoot":"","sources":["../../src/lib/image-service.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,CAAC;IACrC,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE;QAChB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,OAAO,GACZ,SAAS,GAAG,SAAS,CA4BvB"}

package/dist/lib/image-service.js

@@ -1,116 +0,0 @@
-/**
- * An `info.json` as an {@link ImageFact}, or `undefined` where it states no
- * dimensions. `serviceUrl` rather than the document’s own `id` names the service,
- * because that is what the manifest resolved and what a proxied server’s
- * self-reported `id` need not be.
- */
-export function imageFactFrom(serviceUrl, info) {
-    if (typeof info !== 'object' || info === null) {
-        return undefined;
-    }
-    const document = info;
-    const { width, height } = document;
-    if (!isPositive(width) || !isPositive(height)) {
-        return undefined;
-    }
-    const type = serviceTypeOf(document);
-    const profile = profileOf(document);
-    const isVersion3 = type === 'ImageService3';
-    // Image API 1.1 names its qualities differently (`native`, not `default`) and has
-    // no `sizes`, and is rare enough that its dimensions alone will do.
-    const sizes = (type === 'ImageService1' ? [] : sizesOf(document, width, height, profile))
-        .sort((left, right) => left.width - right.width)
-        .map((size) => ({
-        ...size,
-        url: `${serviceUrl}/full/${isVersion3 ? `${size.width},${size.height}` : `${size.width},`}/0/default.jpg`,
-    }));
-    return {
-        width,
-        height,
-        sizes,
-        service: { url: serviceUrl, type, profile },
-    };
-}
-/** Rungs below this width are too small to be worth a request. */
-const MINIMUM_SYNTHESISED_WIDTH = 64;
-function sizesOf(document, width, height, profile) {
-    const declared = Array.isArray(document.sizes)
-        ? document.sizes.filter((size) => isPositive(size?.width) && isPositive(size?.height))
-        : [];
-    if (declared.length > 0) {
-        return declared.map((size) => ({ width: size.width, height: size.height }));
-    }
-    // A level-0 server only serves what it lists, so nothing can be asked of it.
-    if (/level0/.test(profile)) {
-        return [];
-    }
-    const rungs = new Map();
-    for (const scaleFactor of scaleFactorsOf(document, width)) {
-        const rung = {
-            width: Math.round(width / scaleFactor),
-            height: Math.round(height / scaleFactor),
-        };
-        if (rung.width >= MINIMUM_SYNTHESISED_WIDTH &&
-            rung.height >= 1 &&
-            isWithinMaximums(rung, document)) {
-            rungs.set(rung.width, rung);
-        }
-    }
-    return [...rungs.values()];
-}
-/** The server’s own precomputed factors where it has tiles, else powers of two. */
-function scaleFactorsOf(document, width) {
-    const tiles = Array.isArray(document.tiles) ? document.tiles : [];
-    const declared = tiles
-        .flatMap((tile) => Array.isArray(tile?.scaleFactors) ? tile.scaleFactors : [])
-        .filter(isPositive);
-    if (declared.length > 0) {
-        return declared;
-    }
-    const factors = [];
-    for (let factor = 1; width / factor >= MINIMUM_SYNTHESISED_WIDTH; factor *= 2) {
-        factors.push(factor);
-    }
-    return factors;
-}
-/**
- * Asking above a declared maximum answers 404, not 400 (Image API 3.0 § 7.3),
- * which would read as a dead link. `maxWidth` alone also bounds the height
- * (§ 5.3), so it is the fallback for a missing `maxHeight`.
- */
-function isWithinMaximums(rung, document) {
-    const { maxWidth, maxHeight, maxArea } = document;
-    const heightLimit = isPositive(maxHeight) ? maxHeight : maxWidth;
-    return ((!isPositive(maxWidth) || rung.width <= maxWidth) &&
-        (!isPositive(heightLimit) || rung.height <= heightLimit) &&
-        (!isPositive(maxArea) || rung.width * rung.height <= maxArea));
-}
-function serviceTypeOf(document) {
-    // Only this family: Image API 2 documents commonly say `@type: iiif:Image`, which
-    // names what they describe and not the kind of service.
-    const type = document.type ?? document['@type'];
-    if (typeof type === 'string' && type.startsWith('ImageService')) {
-        return type;
-    }
-    const context = JSON.stringify(document['@context'] ?? '');
-    if (context.includes('image/3')) {
-        return 'ImageService3';
-    }
-    if (context.includes('image/2')) {
-        return 'ImageService2';
-    }
-    // A 1.0 document may state no context, so the profile has to answer as well.
-    return /image-api|api\/image\/1/.test(`${context} ${profileOf(document)}`)
-        ? 'ImageService1'
-        : 'ImageService2';
-}
-/** The compliance level, which Image API 2 states first in an array. */
-function profileOf(document) {
-    const profile = Array.isArray(document.profile)
-        ? document.profile[0]
-        : document.profile;
-    return typeof profile === 'string' ? profile : '';
-}
-function isPositive(value) {
-    return Number.isInteger(value) && value > 0;
-}

package/dist/lib/manifest.d.ts

@@ -1,14 +0,0 @@
-/**
- * The image service of a manifest’s first painted image that has one, in either
- * Presentation version.
- *
- * A walk over the plain JSON rather than a vault: real manifests carry shapes a
- * normalising parser rejects outright – Deventit Atlantis writes
- * `"annotations": [null]` – and only this path matters here. Which image
- * represents a work is a rule that lives in this one function, so a better one
- * can replace it without touching what it feeds.
- */
-export declare function selectImageService(manifest: unknown): string | undefined;
-/** Whether a document has the canvases every manifest must have, in either version. */
-export declare function listsCanvases(document: unknown): boolean;
-//# sourceMappingURL=manifest.d.ts.map

package/dist/lib/manifest.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/lib/manifest.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAcxE;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAKxD"}

package/dist/lib/manifest.js

@@ -1,98 +0,0 @@
-import { isImageService as isKnownImageService } from '@iiif/parser/image-3';
-import { convertPresentation2 } from '@iiif/parser/presentation-2';
-/**
- * The image service of a manifest’s first painted image that has one, in either
- * Presentation version.
- *
- * A walk over the plain JSON rather than a vault: real manifests carry shapes a
- * normalising parser rejects outright – Deventit Atlantis writes
- * `"annotations": [null]` – and only this path matters here. Which image
- * represents a work is a rule that lives in this one function, so a better one
- * can replace it without touching what it feeds.
- */
-export function selectImageService(manifest) {
-    for (const canvas of arrayOf(fieldOf(upgraded(manifest), 'items'))) {
-        for (const page of arrayOf(fieldOf(canvas, 'items'))) {
-            for (const annotation of arrayOf(fieldOf(page, 'items'))) {
-                for (const body of paintedResources(fieldOf(annotation, 'body'))) {
-                    const service = imageServiceOf(body);
-                    if (service !== undefined) {
-                        return service;
-                    }
-                }
-            }
-        }
-    }
-    return undefined;
-}
-/** Whether a document has the canvases every manifest must have, in either version. */
-export function listsCanvases(document) {
-    return (arrayOf(fieldOf(document, 'items')).length > 0 ||
-        arrayOf(fieldOf(document, 'sequences')).length > 0);
-}
-/**
- * The manifest in Presentation 3 terms. A Presentation 2 manifest the upgrade
- * chokes on, such as one with `"images": [null]`, has nothing to find: retrying
- * cannot help, and a run of them must not write off a dataset’s other manifests.
- */
-function upgraded(manifest) {
-    if (fieldOf(manifest, 'sequences') === undefined) {
-        return manifest;
-    }
-    try {
-        return convertPresentation2(manifest);
-    }
-    catch {
-        return undefined;
-    }
-}
-/** A body’s resources in order, with each `Choice` opened up and each
- *  `SpecificResource`, which is how a cropped painting is stated, unwrapped. */
-function paintedResources(body) {
-    return arrayOf(body).flatMap((resource) => {
-        const type = fieldOf(resource, 'type');
-        if (type === 'Choice') {
-            return paintedResources(fieldOf(resource, 'items'));
-        }
-        return type === 'SpecificResource'
-            ? paintedResources(fieldOf(resource, 'source'))
-            : [resource];
-    });
-}
-function imageServiceOf(resource) {
-    for (const service of arrayOf(fieldOf(resource, 'service'))) {
-        const id = fieldOf(service, 'id') ?? fieldOf(service, '@id');
-        if (typeof id === 'string' && isImageService(service)) {
-            return serviceBase(id);
-        }
-    }
-    return undefined;
-}
-/** The URL `/info.json` and sizes are appended to. Some manifests state the
- *  service with a trailing slash or as the `info.json` itself. */
-function serviceBase(id) {
-    return id.replace(/\/info\.json$/, '').replace(/\/+$/, '');
-}
-/**
- * The parser’s test, plus the two forms it misses: a `type` with no `profile`, and
- * a profile merely naming a compliance level. Limb Gallery’s is the `https` form
- * of the Stanford URL from Image API 1.1, which the parser’s list does not include.
- */
-function isImageService(service) {
-    const type = fieldOf(service, 'type') ?? fieldOf(service, '@type');
-    const profile = fieldOf(service, 'profile');
-    return (isKnownImageService(service) ||
-        (typeof type === 'string' && type.startsWith('ImageService')) ||
-        (typeof profile === 'string' && /level[012]/.test(profile)));
-}
-function fieldOf(value, name) {
-    return typeof value === 'object' && value !== null
-        ? value[name]
-        : undefined;
-}
-function arrayOf(value) {
-    if (value === undefined || value === null) {
-        return [];
-    }
-    return Array.isArray(value) ? value : [value];
-}

package/dist/lib/public-url.d.ts

@@ -1,11 +0,0 @@
-/**
- * Whether a URL taken from a publisher’s data may be fetched from inside the
- * cluster: a web URL that does not name a private, loopback or link-local address
- * or a cluster-internal host.
- *
- * This looks only at the URL, so it cannot see a public name resolving to a private
- * address, or a redirect to one. It stops the plain case, and a cluster egress
- * policy has to cover the rest.
- */
-export declare function isPublicWebUrl(url: string): boolean;
-//# sourceMappingURL=public-url.d.ts.map

package/dist/lib/public-url.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"public-url.d.ts","sourceRoot":"","sources":["../../src/lib/public-url.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAoBnD"}

package/dist/lib/public-url.js

@@ -1,53 +0,0 @@
-import { BlockList, isIP } from 'node:net';
-/**
- * Whether a URL taken from a publisher’s data may be fetched from inside the
- * cluster: a web URL that does not name a private, loopback or link-local address
- * or a cluster-internal host.
- *
- * This looks only at the URL, so it cannot see a public name resolving to a private
- * address, or a redirect to one. It stops the plain case, and a cluster egress
- * policy has to cover the rest.
- */
-export function isPublicWebUrl(url) {
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        return false;
-    }
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
-        return false;
-    }
-    const host = parsed.hostname.replace(/^\[|\]$/g, '').toLowerCase();
-    const family = isIP(host);
-    if (family === 4) {
-        return !PRIVATE_ADDRESSES.check(host, 'ipv4');
-    }
-    if (family === 6) {
-        return !PRIVATE_ADDRESSES.check(host, 'ipv6');
-    }
-    // A single label is a Kubernetes service or a machine on the local network.
-    return host.includes('.') && !INTERNAL_SUFFIX.test(host);
-}
-const INTERNAL_SUFFIX = /\.(localhost|local|internal|svc)$/;
-const PRIVATE_ADDRESSES = new BlockList();
-for (const [network, prefix] of [
-    ['0.0.0.0', 8],
-    ['10.0.0.0', 8],
-    ['100.64.0.0', 10],
-    ['127.0.0.0', 8],
-    ['169.254.0.0', 16],
-    ['172.16.0.0', 12],
-    ['192.168.0.0', 16],
-]) {
-    PRIVATE_ADDRESSES.addSubnet(network, prefix, 'ipv4');
-}
-for (const [network, prefix] of [
-    ['::', 128],
-    ['::1', 128],
-    ['fc00::', 7],
-    ['fe80::', 10],
-]) {
-    PRIVATE_ADDRESSES.addSubnet(network, prefix, 'ipv6');
-}