@azure/ai-form-recognizer 5.0.0 → 5.1.0

package/dist/commonjs/lro/administration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"administration.d.ts","sourceRoot":"","sources":["../../../src/lro/administration.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,OAAO,KAAK,EACV,oBAAoB,EACpB,eAAe,EACf,kCAAkC,EAClC,mCAAmC,EACnC,oCAAoC,EACpC,yBAAyB,EACzB,uCAAuC,EACxC,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GACpC,2BAA2B,GAC3B,gCAAgC,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,uCAAuC;IACtD;;;;;;;;OAQG;IACH,MAAM,EAAE,eAAe,CAAC;IAExB;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,SAAS,EAAE,IAAI,CAAC;IAEhB;;OAEG;IACH,aAAa,EAAE,IAAI,CAAC;IAEpB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,2BACf,SAAQ,kBAAkB,CAAC,oBAAoB,CAAC,EAC9C,uCAAuC;CAAG;AAE9C;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAClC,kCAAkC,GAClC,mCAAmC,GACnC,oCAAoC,CAAC;AAEzC;;;GAGG;AACH,MAAM,MAAM,mCAAmC,GAC3C,0BAA0B,GAC1B,uCAAuC,CAAC;AAE5C;;;GAGG;AACH,wBAAsB,4BAA4B,CAChD,QAAQ,EAAE,mCAAmC,GAC5C,OAAO,CAAC,2BAA2B,GAAG,gCAAgC,CAAC,CAoBzE;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,2BAA2B,EAAE,oBAAoB,CAAC,CAAC;AAEhG;;;GAGG;AACH,MAAM,WAAW,2BAA2B,CAAC,KAAK,SAAS,4BAA4B;IACrF;;OAEG;IACH,KAAK,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;QAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1E;;OAEG;IACH,OAAO,EAAE,aAAa,CAAC,KAAK,CAAC,GAAG,gBAAgB,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,UAAU,CAC/C,gCAAgC,EAChC,yBAAyB,CAC1B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,gCACf,SAAQ,kBAAkB,CAAC,yBAAyB,CAAC,EACnD,uCAAuC;CAAG"}

package/dist/commonjs/lro/administration.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toTrainingPollOperationState = toTrainingPollOperationState;
+const error_js_1 = require("../error.js");
+/**
+ * Convert an operation result into a training poller state.
+ * @internal
+ */
+async function toTrainingPollOperationState(response) {
+    var _a;
+    return {
+        operationId: response.operationId,
+        status: response.status,
+        apiVersion: response.apiVersion,
+        percentCompleted: (_a = response.percentCompleted) !== null && _a !== void 0 ? _a : 0,
+        lastUpdatedOn: response.lastUpdatedOn,
+        createdOn: response.createdOn,
+        error: response.error && new error_js_1.FormRecognizerError(response.error),
+        isCancelled: response.status === "canceled",
+        isCompleted: response.status === "succeeded",
+        isStarted: response.status !== "notStarted",
+        tags: response.tags,
+        // The following assertion is required. Technically the type of `response.result` is
+        // `DocumentModelDetails | DocumentClassifierDetails | undefined`, which isn't assignable to the type of
+        // either operation state's result. We would need some kind of dependent typing to express how the type of `result`
+        // actually _determines_ the type of the resulting return value.
+        result: response.result,
+    };
+}
+//# sourceMappingURL=administration.js.map

package/dist/commonjs/lro/administration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"administration.js","sourceRoot":"","sources":["../../../src/lro/administration.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;AAmGlC,oEAsBC;AArHD,0CAAkD;AA2FlD;;;GAGG;AACI,KAAK,UAAU,4BAA4B,CAChD,QAA6C;;IAE7C,OAAO;QACL,WAAW,EAAE,QAAQ,CAAC,WAAW;QACjC,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,UAAU,EAAE,QAAQ,CAAC,UAAU;QAC/B,gBAAgB,EAAE,MAAA,QAAQ,CAAC,gBAAgB,mCAAI,CAAC;QAChD,aAAa,EAAE,QAAQ,CAAC,aAAa;QACrC,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,KAAK,EAAE,QAAQ,CAAC,KAAK,IAAI,IAAI,8BAAmB,CAAC,QAAQ,CAAC,KAAK,CAAC;QAChE,WAAW,EAAE,QAAQ,CAAC,MAAM,KAAK,UAAU;QAC3C,WAAW,EAAE,QAAQ,CAAC,MAAM,KAAK,WAAW;QAC5C,SAAS,EAAE,QAAQ,CAAC,MAAM,KAAK,YAAY;QAC3C,IAAI,EAAE,QAAQ,CAAC,IAAI;QAEnB,oFAAoF;QACpF,wGAAwG;QACxG,mHAAmH;QACnH,gEAAgE;QAChE,MAAM,EAAE,QAAQ,CAAC,MAAM;KAC0C,CAAC;AACtE,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PollOperationState, PollerLike } from \"@azure/core-lro\";\nimport type { OperationOptions } from \"@azure/core-client\";\nimport { FormRecognizerError } from \"../error.js\";\nimport type {\n  DocumentModelDetails,\n  OperationStatus,\n  DocumentModelBuildOperationDetails,\n  DocumentModelCopyToOperationDetails,\n  DocumentModelComposeOperationDetails,\n  DocumentClassifierDetails,\n  DocumentClassifierBuildOperationDetails,\n} from \"../generated/index.js\";\nimport type { PollerOptions } from \"../options/PollerOptions.js\";\nimport type { OperationContext } from \"./util/poller.js\";\n\n/**\n * The possible types of all administration operation states.\n * @internal\n */\nexport type AdministrationOperationState =\n  | DocumentModelOperationState\n  | DocumentClassifierOperationState;\n\n/**\n * The set of fields common to all administration operations.\n */\nexport interface ModelAdministrationOperationStateCommon {\n  /**\n   * The status of the operation. One of:\n   *\n   * - \"notStarted\"\n   * - \"running\"\n   * - \"succeeded\"\n   * - \"failed\"\n   * - \"canceled\"\n   */\n  status: OperationStatus;\n\n  /**\n   * The API version used to train this model.\n   */\n  apiVersion?: string;\n\n  /**\n   * The unique ID of this operation.\n   */\n  operationId: string;\n\n  /**\n   * A number between 0 and 100 representing the progress of the operation.\n   */\n  percentCompleted: number;\n\n  /**\n   * The Date and Time that the operation was created.\n   */\n  createdOn: Date;\n\n  /**\n   * The date & time that the operation state was last modified.\n   */\n  lastUpdatedOn: Date;\n\n  /**\n   * Additional, user-defined key-value pairs associated with the model as metadata.\n   */\n  tags?: Record<string, string>;\n}\n\n/**\n * The state of a model creation operation.\n */\nexport interface DocumentModelOperationState\n  extends PollOperationState<DocumentModelDetails>,\n    ModelAdministrationOperationStateCommon {}\n\n/**\n * The respones of a model creation operation.\n * @internal\n */\nexport type DocumentModelBuildResponse =\n  | DocumentModelBuildOperationDetails\n  | DocumentModelCopyToOperationDetails\n  | DocumentModelComposeOperationDetails;\n\n/**\n * The possible responses of an administration operation.\n * @internal\n */\nexport type DocumentModelAdministrationResponse =\n  | DocumentModelBuildResponse\n  | DocumentClassifierBuildOperationDetails;\n\n/**\n * Convert an operation result into a training poller state.\n * @internal\n */\nexport async function toTrainingPollOperationState(\n  response: DocumentModelAdministrationResponse,\n): Promise<DocumentModelOperationState | DocumentClassifierOperationState> {\n  return {\n    operationId: response.operationId,\n    status: response.status,\n    apiVersion: response.apiVersion,\n    percentCompleted: response.percentCompleted ?? 0,\n    lastUpdatedOn: response.lastUpdatedOn,\n    createdOn: response.createdOn,\n    error: response.error && new FormRecognizerError(response.error),\n    isCancelled: response.status === \"canceled\",\n    isCompleted: response.status === \"succeeded\",\n    isStarted: response.status !== \"notStarted\",\n    tags: response.tags,\n\n    // The following assertion is required. Technically the type of `response.result` is\n    // `DocumentModelDetails | DocumentClassifierDetails | undefined`, which isn't assignable to the type of\n    // either operation state's result. We would need some kind of dependent typing to express how the type of `result`\n    // actually _determines_ the type of the resulting return value.\n    result: response.result,\n  } as DocumentModelOperationState | DocumentClassifierOperationState;\n}\n\n/**\n * A long-running operation (poller) that tracks the state of a model creation operation, eventually producing a\n * {@link DocumentModelDetails}.\n */\nexport type DocumentModelPoller = PollerLike<DocumentModelOperationState, DocumentModelDetails>;\n\n/**\n * Defines a training operation.\n * @internal\n */\nexport interface TrainingOperationDefinition<State extends AdministrationOperationState> {\n  /**\n   * A function to start the operation, producing an operationLocation.\n   */\n  start: (ctx: OperationContext) => Promise<{ operationLocation?: string }>;\n  /**\n   * Options for the poller and requests.\n   */\n  options: PollerOptions<State> & OperationOptions;\n}\n\n/**\n * A long-running operation (poller) that tracks the state of a custom classifier creation operation, eventually\n * producing a {@link DocumentClassifierDetails}.\n */\nexport type DocumentClassifierPoller = PollerLike<\n  DocumentClassifierOperationState,\n  DocumentClassifierDetails\n>;\n\n/**\n * The state of a model creation operation.\n */\nexport interface DocumentClassifierOperationState\n  extends PollOperationState<DocumentClassifierDetails>,\n    ModelAdministrationOperationStateCommon {}\n"]}

package/dist/commonjs/lro/analysis.d.ts

@@ -0,0 +1,210 @@
+import type { PollOperationState, PollerLike } from "@azure/core-lro";
+import type { AnalyzeResult as GeneratedAnalyzeResult, AnalyzeResultOperation, AnalyzeResultOperationStatus as AnalyzeOperationStatus, DocumentLanguage, DocumentSpan, DocumentStyle } from "../generated/index.js";
+import type { DocumentField } from "../models/fields.js";
+import type { PollerOptions } from "../options/index.js";
+import type { AnalyzeDocumentOptions } from "../options/AnalyzeDocumentOptions.js";
+import type { BoundingRegion, DocumentTable, DocumentKeyValuePair, DocumentPage, DocumentLine, DocumentParagraph } from "../models/documentElements.js";
+import type { Document as GeneratedDocument, DocumentPage as GeneratedDocumentPage, DocumentLine as GeneratedDocumentLine } from "../generated/index.js";
+/**
+ * A request input that can be uploaded as binary data to the Form Recognizer service. Form Recognizer treats `string`
+ * inputs as URLs, so to send a string as a _binary_ input, first convert the string to one of the following input
+ * types.
+ */
+export type FormRecognizerRequestBody = NodeJS.ReadableStream | Blob | ArrayBuffer | ArrayBufferView;
+/**
+ * An extracted document object.
+ *
+ * An AnalyzedDocument is an instance of one of the document types within a model. Its fields correspond to the field
+ * schema of the document type.
+ */
+export interface AnalyzedDocument {
+    /**
+     * The type of the document that was extracted. A model can have multiple document types (for example, in a composed
+     * model), so this property indicates which document type the fields of this document correspond to.
+     */
+    docType: string;
+    /**
+     * The extracted fields, which correspond to the document type's field schema.
+     */
+    fields: {
+        [field: string]: DocumentField;
+    };
+    /**
+     * Bounding regions covering the document.
+     */
+    boundingRegions?: BoundingRegion[];
+    /**
+     * Locations of the document's elements in the `content` text (reading-order-concatenated content).
+     */
+    spans: DocumentSpan[];
+    /**
+     * The service's confidence that it has correctly extracted the document.
+     */
+    confidence: number;
+}
+/**
+ * Transform a REST-level Document response object into the more strongly-typed AnalyzedDocument.
+ *
+ * @internal
+ * @param document - a REST-level document response object
+ * @returns an AnalyzedDocument (which has had its fields mapped to stronger DocumentField types)
+ */
+export declare function toAnalyzedDocumentFromGenerated(document: GeneratedDocument): AnalyzedDocument;
+/**
+ * The common fields of all AnalyzeResult-like types, such as LayoutResult, ReadResult, and GeneralDocumentResult.
+ */
+export interface AnalyzeResultCommon {
+    /**
+     * The service API version used to produce this result.
+     */
+    apiVersion: string;
+    /**
+     * The unique ID of the model that was used to produce this result.
+     */
+    modelId: string;
+    /**
+     * A string representation of all textual and visual elements in the input, concatenated by reading order (the order
+     * in which the service "reads" or extracts the textual and visual content from the document).
+     */
+    content: string;
+}
+/**
+ * The result of an analysis operation. The type of the Document may be determined by the model used to perform the
+ * analysis.
+ */
+export interface AnalyzeResult<Document = AnalyzedDocument> extends AnalyzeResultCommon {
+    /**
+     * Extracted pages.
+     */
+    pages?: DocumentPage[];
+    /**
+     * Extracted tables.
+     */
+    tables?: DocumentTable[];
+    /**
+     * Extracted key-value pairs.
+     */
+    keyValuePairs?: DocumentKeyValuePair[];
+    /**
+     * Extracted text languages.
+     */
+    languages?: DocumentLanguage[];
+    /**
+     * Extracted font styles.
+     */
+    styles?: DocumentStyle[];
+    /**
+     * Extracted documents (instances of any of the model's document types and corresponding field schemas).
+     */
+    documents?: Document[];
+    /**
+     * Extracted document paragraphs.
+     */
+    paragraphs?: DocumentParagraph[];
+}
+/**
+ * Tests if one span contains another, by testing that the outer span starts before or at the same character as the
+ * inner span, and that the end position of the outer span is greater than or equal to the end position of the inner
+ * span.
+ *
+ * @internal
+ * @param outer - the outer (potentially containing) span
+ * @param inner - the span to test if `outer` contains
+ * @returns true if `inner` is contained inside of `outer`.
+ */
+export declare function contains(outer: DocumentSpan, inner: DocumentSpan): boolean;
+/**
+ * Produces an iterator of the given items starting from the given index.
+ *
+ * @param items - the items to iterate over
+ * @param idx - the index of the first item to begin iterating from
+ */
+export declare function iterFrom<T>(items: T[], idx: number): Generator<T>;
+export declare function toDocumentLineFromGenerated(generated: GeneratedDocumentLine, page: GeneratedDocumentPage): DocumentLine;
+export declare function toDocumentPageFromGenerated(generated: GeneratedDocumentPage): DocumentPage;
+/**
+ * Binary search through an array of items to find the first item that could possibly be contained by the given span,
+ * then return an iterator beginning from that item.
+ *
+ * This allows a program to quickly find the first relevant item in the array for consideration when testing for span
+ * inclusion.
+ *
+ * @internal
+ * @param span - the span to use when testing each individual item
+ * @param items - an array of items to binary search through
+ * @returns an iterator beginning from the item identified by the search
+ */
+export declare function iteratorFromFirstMatchBinarySearch<Spanned extends {
+    span: DocumentSpan;
+}>(span: DocumentSpan, items: Spanned[]): IterableIterator<Spanned>;
+/**
+ * This fast algorithm tests the elements of `childArray` for inclusion in any of the given `spans`, assuming that both
+ * the spans and child items are sorted.
+ *
+ * INVARIANT: the items in both the `spans` iterator and `childrenArray` MUST BE SORTED INCREASING by span _offset_.
+ *
+ * @internal
+ * @param spans - the spans that contain the child elements
+ * @param childrenArray - an array of child items (items that have spans) to test for inclusion in the spans
+ * @returns - an IterableIterator of child items that are included in any span in the `spans` iterator
+ */
+export declare function fastGetChildren<Spanned extends {
+    span: DocumentSpan;
+}>(spans: Iterator<DocumentSpan>, childrenArray: Spanned[]): Generator<Spanned>;
+/**
+ * The state of an analysis operation, which will eventually produce the result type that corresponds to the model.
+ */
+export interface DocumentAnalysisPollOperationState<Result = AnalyzeResult<AnalyzedDocument>> extends PollOperationState<Result> {
+    /**
+     * The status of the operation. One of:
+     *
+     * - "notStarted"
+     * - "running"
+     * - "succeeded"
+     * - "failed"
+     */
+    status: AnalyzeOperationStatus;
+    /**
+     * The model ID that the analysis operation will use to produce the result.
+     */
+    modelId: string;
+    /**
+     * The URL to the operation.
+     */
+    operationLocation: string;
+    /**
+     * The Date and Time that the operation was created.
+     */
+    createdOn: Date;
+    /**
+     * The date & time that the operation state was last modified.
+     */
+    lastUpdatedOn: Date;
+}
+/**
+ * A long-running operation (poller) that tracks the state of an analysis operation, eventually producing the result
+ * type that corresponds to the model.
+ */
+export type AnalysisPoller<Result = AnalyzeResult<AnalyzedDocument>> = PollerLike<DocumentAnalysisPollOperationState<Result>, Result>;
+/**
+ * Convert a generated AnalyzeResult into a convenience layer AnalyzeResult.
+ * @internal
+ */
+export declare function toAnalyzeResultFromGenerated(result: GeneratedAnalyzeResult): AnalyzeResult;
+/**
+ * Defines an analysis operation by the initial request model ID, poller options, and a transform to apply to the
+ * eventual result,
+ *
+ * @internal
+ */
+export interface AnalysisOperationDefinition<Result = AnalyzeResult> {
+    transformResult: (primitiveResult: GeneratedAnalyzeResult) => Result;
+    initialModelId: string;
+    options: PollerOptions<DocumentAnalysisPollOperationState<Result>> & AnalyzeDocumentOptions<Result>;
+}
+/**
+ * Converts an AnalyzeResultOperation (LRO response) to a DocumentAnalysisPollOperationState
+ * @internal
+ */
+export declare function toDocumentAnalysisPollOperationState<Result>(definition: AnalysisOperationDefinition<Result>, modelId: string, operationLocation: string, response: AnalyzeResultOperation): DocumentAnalysisPollOperationState<Result>;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/commonjs/lro/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../../../src/lro/analysis.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/lro/analysis.js

@@ -0,0 +1,186 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAnalyzedDocumentFromGenerated = toAnalyzedDocumentFromGenerated;
+exports.contains = contains;
+exports.iterFrom = iterFrom;
+exports.toDocumentLineFromGenerated = toDocumentLineFromGenerated;
+exports.toDocumentPageFromGenerated = toDocumentPageFromGenerated;
+exports.iteratorFromFirstMatchBinarySearch = iteratorFromFirstMatchBinarySearch;
+exports.fastGetChildren = fastGetChildren;
+exports.toAnalyzeResultFromGenerated = toAnalyzeResultFromGenerated;
+exports.toDocumentAnalysisPollOperationState = toDocumentAnalysisPollOperationState;
+const error_js_1 = require("../error.js");
+const fields_js_1 = require("../models/fields.js");
+const polygon_js_1 = require("../transforms/polygon.js");
+/**
+ * Transform a REST-level Document response object into the more strongly-typed AnalyzedDocument.
+ *
+ * @internal
+ * @param document - a REST-level document response object
+ * @returns an AnalyzedDocument (which has had its fields mapped to stronger DocumentField types)
+ */
+function toAnalyzedDocumentFromGenerated(document) {
+    var _a;
+    return Object.assign(Object.assign({}, document), { boundingRegions: (0, polygon_js_1.toBoundingRegions)(document.boundingRegions), fields: (0, fields_js_1.toAnalyzedDocumentFieldsFromGenerated)((_a = document.fields) !== null && _a !== void 0 ? _a : {}) });
+}
+/**
+ * Tests if one span contains another, by testing that the outer span starts before or at the same character as the
+ * inner span, and that the end position of the outer span is greater than or equal to the end position of the inner
+ * span.
+ *
+ * @internal
+ * @param outer - the outer (potentially containing) span
+ * @param inner - the span to test if `outer` contains
+ * @returns true if `inner` is contained inside of `outer`.
+ */
+function contains(outer, inner) {
+    return outer.offset <= inner.offset && outer.offset + outer.length >= inner.offset + inner.length;
+}
+/**
+ * Make an empty generator. This might seem silly, but it's useful for satisfying invariants.
+ */
+function* empty() {
+    /* intentionally empty */
+}
+/**
+ * Produces an iterator of the given items starting from the given index.
+ *
+ * @param items - the items to iterate over
+ * @param idx - the index of the first item to begin iterating from
+ */
+function* iterFrom(items, idx) {
+    let i = idx;
+    while (i < items.length) {
+        yield items[i++];
+    }
+}
+function toDocumentLineFromGenerated(generated, page) {
+    generated.words = () => {
+        var _a, _b;
+        return fastGetChildren(iterFrom(generated.spans, 0), (_b = (_a = page.words) === null || _a === void 0 ? void 0 : _a.map((word) => {
+            return Object.assign(Object.assign({}, word), { polygon: (0, polygon_js_1.toBoundingPolygon)(word.polygon) });
+        })) !== null && _b !== void 0 ? _b : []);
+    };
+    generated.polygon = (0, polygon_js_1.toBoundingPolygon)(generated.polygon);
+    Object.defineProperty(generated, "words", {
+        enumerable: false,
+    });
+    return generated;
+}
+function toDocumentPageFromGenerated(generated) {
+    var _a, _b, _c, _d, _e;
+    return Object.assign(Object.assign({}, generated), { lines: (_a = generated.lines) === null || _a === void 0 ? void 0 : _a.map((line) => toDocumentLineFromGenerated(line, generated)), selectionMarks: (_b = generated.selectionMarks) === null || _b === void 0 ? void 0 : _b.map((mark) => (Object.assign(Object.assign({}, mark), { polygon: (0, polygon_js_1.toBoundingPolygon)(mark.polygon) }))), words: (_c = generated.words) === null || _c === void 0 ? void 0 : _c.map((word) => (Object.assign(Object.assign({}, word), { polygon: (0, polygon_js_1.toBoundingPolygon)(word.polygon) }))), barcodes: (_d = generated.barcodes) === null || _d === void 0 ? void 0 : _d.map((barcode) => (Object.assign(Object.assign({}, barcode), { polygon: (0, polygon_js_1.toBoundingPolygon)(barcode.polygon) }))), formulas: (_e = generated.formulas) === null || _e === void 0 ? void 0 : _e.map((formula) => (Object.assign(Object.assign({}, formula), { polygon: (0, polygon_js_1.toBoundingPolygon)(formula.polygon) }))) });
+}
+/**
+ * Binary search through an array of items to find the first item that could possibly be contained by the given span,
+ * then return an iterator beginning from that item.
+ *
+ * This allows a program to quickly find the first relevant item in the array for consideration when testing for span
+ * inclusion.
+ *
+ * @internal
+ * @param span - the span to use when testing each individual item
+ * @param items - an array of items to binary search through
+ * @returns an iterator beginning from the item identified by the search
+ */
+function iteratorFromFirstMatchBinarySearch(span, items) {
+    let idx = Math.floor(items.length / 2);
+    let prevIdx = idx;
+    let min = 0;
+    let max = items.length;
+    const found = () => { var _a, _b, _c; 
+    // The item is found if it starts after the current span and the item before it does not. That means it is the first
+    // item in the array that could be a child if the spans are sorted.
+    return items[idx].span.offset >= span.offset && ((_c = (_b = (_a = items[idx - 1]) === null || _a === void 0 ? void 0 : _a.span) === null || _b === void 0 ? void 0 : _b.offset) !== null && _c !== void 0 ? _c : -1) < span.offset; };
+    // Binary search to find the first element that could be a child
+    do {
+        if (found()) {
+            return iterFrom(items, idx);
+        }
+        else if (span.offset > items[idx].span.offset) {
+            min = prevIdx = idx;
+            idx = Math.floor(idx + (max - idx) / 2);
+        }
+        else {
+            max = prevIdx = idx;
+            idx = Math.floor(idx - (idx - min) / 2);
+        }
+    } while (idx !== prevIdx);
+    // This might seem weird, but it's a simple way to make the types a little more elegant.
+    return empty();
+}
+/**
+ * This fast algorithm tests the elements of `childArray` for inclusion in any of the given `spans`, assuming that both
+ * the spans and child items are sorted.
+ *
+ * INVARIANT: the items in both the `spans` iterator and `childrenArray` MUST BE SORTED INCREASING by span _offset_.
+ *
+ * @internal
+ * @param spans - the spans that contain the child elements
+ * @param childrenArray - an array of child items (items that have spans) to test for inclusion in the spans
+ * @returns - an IterableIterator of child items that are included in any span in the `spans` iterator
+ */
+function* fastGetChildren(spans, childrenArray) {
+    let curSpan = spans.next();
+    // Need to exit early if there are no spans.
+    if (curSpan.done) {
+        return;
+    }
+    const children = iteratorFromFirstMatchBinarySearch(curSpan.value, childrenArray);
+    let curChild = children.next();
+    while (!(curChild.done || curSpan.done)) {
+        if (contains(curSpan.value, curChild.value.span)) {
+            // The span is contained, so yield the current child and advance it.
+            yield curChild.value;
+            curChild = children.next();
+        }
+        else if (curSpan.value.offset + curSpan.value.length < curChild.value.span.offset) {
+            // The current span ends before the next potential child starts, so advance the span
+            curSpan = spans.next();
+        }
+        else {
+            // The current child was not contained in the current span, so advance to the next child.
+            curChild = children.next();
+        }
+    }
+}
+/**
+ * Convert a generated AnalyzeResult into a convenience layer AnalyzeResult.
+ * @internal
+ */
+function toAnalyzeResultFromGenerated(result) {
+    var _a, _b, _c, _d;
+    return {
+        apiVersion: result.apiVersion,
+        modelId: result.modelId,
+        content: result.content,
+        pages: result.pages.map((page) => toDocumentPageFromGenerated(page)),
+        tables: (_a = result.tables) === null || _a === void 0 ? void 0 : _a.map((table) => (0, polygon_js_1.toDocumentTableFromGenerated)(table)),
+        keyValuePairs: (_b = result.keyValuePairs) === null || _b === void 0 ? void 0 : _b.map((pair) => (0, polygon_js_1.toKeyValuePairFromGenerated)(pair)),
+        languages: result.languages,
+        styles: result.styles,
+        paragraphs: (_c = result.paragraphs) === null || _c === void 0 ? void 0 : _c.map((para) => (Object.assign(Object.assign({}, para), { boundingRegions: (0, polygon_js_1.toBoundingRegions)(para.boundingRegions) }))),
+        documents: (_d = result.documents) === null || _d === void 0 ? void 0 : _d.map(toAnalyzedDocumentFromGenerated),
+    };
+}
+/**
+ * Converts an AnalyzeResultOperation (LRO response) to a DocumentAnalysisPollOperationState
+ * @internal
+ */
+function toDocumentAnalysisPollOperationState(definition, modelId, operationLocation, response) {
+    return {
+        status: response.status,
+        modelId: modelId,
+        lastUpdatedOn: response.lastUpdatedOn,
+        createdOn: response.createdOn,
+        operationLocation,
+        result: response.analyzeResult && definition.transformResult(response.analyzeResult),
+        error: response.error && new error_js_1.FormRecognizerError(response.error),
+        isCancelled: false, // Not supported
+        isStarted: response.status !== "notStarted",
+        isCompleted: response.status === "succeeded",
+    };
+}
+//# sourceMappingURL=analysis.js.map

package/dist/commonjs/lro/analysis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.js","sourceRoot":"","sources":["../../../src/lro/analysis.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;AAyFlC,0EAMC;AA0ED,4BAEC;AAeD,4BAMC;AAED,kEAmBC;AAED,kEAuBC;AAcD,gFA6BC;AAaD,0CA2BC;AAmDD,oEAgBC;AAmBD,oFAkBC;AAtaD,0CAAkD;AAUlD,mDAA4E;AAG5E,yDAKkC;AA6DlC;;;;;;GAMG;AACH,SAAgB,+BAA+B,CAAC,QAA2B;;IACzE,uCACK,QAAQ,KACX,eAAe,EAAE,IAAA,8BAAiB,EAAC,QAAQ,CAAC,eAAe,CAAC,EAC5D,MAAM,EAAE,IAAA,iDAAqC,EAAC,MAAA,QAAQ,CAAC,MAAM,mCAAI,EAAE,CAAC,IACpE;AACJ,CAAC;AAgED;;;;;;;;;GASG;AACH,SAAgB,QAAQ,CAAC,KAAmB,EAAE,KAAmB;IAC/D,OAAO,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;AACpG,CAAC;AAED;;GAEG;AACH,QAAQ,CAAC,CAAC,KAAK;IACb,yBAAyB;AAC3B,CAAC;AAED;;;;;GAKG;AACH,QAAe,CAAC,CAAC,QAAQ,CAAI,KAAU,EAAE,GAAW;IAClD,IAAI,CAAC,GAAG,GAAG,CAAC;IAEZ,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QACxB,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;IACnB,CAAC;AACH,CAAC;AAED,SAAgB,2BAA2B,CACzC,SAAgC,EAChC,IAA2B;IAE1B,SAA0B,CAAC,KAAK,GAAG,GAAG,EAAE;;QACvC,OAAA,eAAe,CACb,QAAQ,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC,EAC5B,MAAA,MAAA,IAAI,CAAC,KAAK,0CAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACvB,uCAAY,IAAI,KAAE,OAAO,EAAE,IAAA,8BAAiB,EAAC,IAAI,CAAC,OAAO,CAAC,IAAG;QAC/D,CAAC,CAAC,mCAAI,EAAE,CACT,CAAA;KAAA,CAAC;IAEH,SAA0B,CAAC,OAAO,GAAG,IAAA,8BAAiB,EAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IAE3E,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,OAAO,EAAE;QACxC,UAAU,EAAE,KAAK;KAClB,CAAC,CAAC;IAEH,OAAO,SAAyB,CAAC;AACnC,CAAC;AAED,SAAgB,2BAA2B,CAAC,SAAgC;;IAC1E,uCACK,SAAS,KACZ,KAAK,EAAE,MAAA,SAAS,CAAC,KAAK,0CAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,2BAA2B,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,EACnF,cAAc,EAAE,MAAA,SAAS,CAAC,cAAc,0CAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iCACnD,IAAI,KACP,OAAO,EAAE,IAAA,8BAAiB,EAAC,IAAI,CAAC,OAAO,CAAC,IACxC,CAAC,EACH,KAAK,EAAE,MAAA,SAAS,CAAC,KAAK,0CAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iCACjC,IAAI,KACP,OAAO,EAAE,IAAA,8BAAiB,EAAC,IAAI,CAAC,OAAO,CAAC,IACxC,CAAC,EACH,QAAQ,EAAE,MAAA,SAAS,CAAC,QAAQ,0CAAE,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,iCAC1C,OAAO,KACV,OAAO,EAAE,IAAA,8BAAiB,EAAC,OAAO,CAAC,OAAO,CAAC,IAC3C,CAAC,EACH,QAAQ,EAAE,MAAA,SAAS,CAAC,QAAQ,0CAAE,GAAG,CAC/B,CAAC,OAAO,EAAmB,EAAE,CAAC,iCACzB,OAAO,KACV,OAAO,EAAE,IAAA,8BAAiB,EAAC,OAAO,CAAC,OAAO,CAAC,IAC3C,CACH,IACD;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,kCAAkC,CAChD,IAAkB,EAClB,KAAgB;IAEhB,IAAI,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvC,IAAI,OAAO,GAAG,GAAG,CAAC;IAClB,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,IAAI,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC;IAEvB,MAAM,KAAK,GAAG,GAAY,EAAE;IAC1B,oHAAoH;IACpH,mEAAmE;IACnE,OAAA,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,MAAA,MAAA,MAAA,KAAK,CAAC,GAAG,GAAG,CAAC,CAAC,0CAAE,IAAI,0CAAE,MAAM,mCAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAA,EAAA,CAAC;IAE9F,gEAAgE;IAChE,GAAG,CAAC;QACF,IAAI,KAAK,EAAE,EAAE,CAAC;YACZ,OAAO,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;QAC9B,CAAC;aAAM,IAAI,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YAChD,GAAG,GAAG,OAAO,GAAG,GAAG,CAAC;YACpB,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,GAAG,GAAG,OAAO,GAAG,GAAG,CAAC;YACpB,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC,QAAQ,GAAG,KAAK,OAAO,EAAE;IAE1B,wFAAwF;IACxF,OAAO,KAAK,EAAE,CAAC;AACjB,CAAC;AAED;;;;;;;;;;GAUG;AACH,QAAe,CAAC,CAAC,eAAe,CAC9B,KAA6B,EAC7B,aAAwB;IAExB,IAAI,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;IAE3B,4CAA4C;IAC5C,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,OAAO;IACT,CAAC;IAED,MAAM,QAAQ,GAAG,kCAAkC,CAAC,OAAO,CAAC,KAAqB,EAAE,aAAa,CAAC,CAAC;IAClG,IAAI,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAE/B,OAAO,CAAC,CAAC,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACxC,IAAI,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACjD,oEAAoE;YACpE,MAAM,QAAQ,CAAC,KAAK,CAAC;YACrB,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC7B,CAAC;aAAM,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACpF,oFAAoF;YACpF,OAAO,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;QACzB,CAAC;aAAM,CAAC;YACN,yFAAyF;YACzF,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;QAC7B,CAAC;IACH,CAAC;AACH,CAAC;AA+CD;;;GAGG;AACH,SAAgB,4BAA4B,CAAC,MAA8B;;IACzE,OAAO;QACL,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,OAAO,EAAE,MAAM,CAAC,OAAO;QACvB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;QACpE,MAAM,EAAE,MAAA,MAAM,CAAC,MAAM,0CAAE,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,yCAA4B,EAAC,KAAK,CAAC,CAAC;QAC1E,aAAa,EAAE,MAAA,MAAM,CAAC,aAAa,0CAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAA,wCAA2B,EAAC,IAAI,CAAC,CAAC;QACrF,SAAS,EAAE,MAAM,CAAC,SAAS;QAC3B,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,UAAU,EAAE,MAAA,MAAM,CAAC,UAAU,0CAAE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,iCACxC,IAAI,KACP,eAAe,EAAE,IAAA,8BAAiB,EAAC,IAAI,CAAC,eAAe,CAAC,IACxD,CAAC;QACH,SAAS,EAAE,MAAA,MAAM,CAAC,SAAS,0CAAE,GAAG,CAAC,+BAA+B,CAAC;KAClE,CAAC;AACJ,CAAC;AAeD;;;GAGG;AACH,SAAgB,oCAAoC,CAClD,UAA+C,EAC/C,OAAe,EACf,iBAAyB,EACzB,QAAgC;IAEhC,OAAO;QACL,MAAM,EAAE,QAAQ,CAAC,MAAM;QACvB,OAAO,EAAE,OAAO;QAChB,aAAa,EAAE,QAAQ,CAAC,aAAa;QACrC,SAAS,EAAE,QAAQ,CAAC,SAAS;QAC7B,iBAAiB;QACjB,MAAM,EAAE,QAAQ,CAAC,aAAa,IAAI,UAAU,CAAC,eAAe,CAAC,QAAQ,CAAC,aAAa,CAAC;QACpF,KAAK,EAAE,QAAQ,CAAC,KAAK,IAAI,IAAI,8BAAmB,CAAC,QAAQ,CAAC,KAAK,CAAC;QAChE,WAAW,EAAE,KAAK,EAAE,gBAAgB;QACpC,SAAS,EAAE,QAAQ,CAAC,MAAM,KAAK,YAAY;QAC3C,WAAW,EAAE,QAAQ,CAAC,MAAM,KAAK,WAAW;KAC7C,CAAC;AACJ,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { PollOperationState, PollerLike } from \"@azure/core-lro\";\nimport { FormRecognizerError } from \"../error.js\";\nimport type {\n  AnalyzeResult as GeneratedAnalyzeResult,\n  AnalyzeResultOperation,\n  AnalyzeResultOperationStatus as AnalyzeOperationStatus,\n  DocumentLanguage,\n  DocumentSpan,\n  DocumentStyle,\n} from \"../generated/index.js\";\nimport type { DocumentField } from \"../models/fields.js\";\nimport { toAnalyzedDocumentFieldsFromGenerated } from \"../models/fields.js\";\nimport type { PollerOptions } from \"../options/index.js\";\nimport type { AnalyzeDocumentOptions } from \"../options/AnalyzeDocumentOptions.js\";\nimport {\n  toBoundingPolygon,\n  toBoundingRegions,\n  toDocumentTableFromGenerated,\n  toKeyValuePairFromGenerated,\n} from \"../transforms/polygon.js\";\nimport type {\n  BoundingRegion,\n  DocumentTable,\n  DocumentKeyValuePair,\n  DocumentPage,\n  DocumentLine,\n  DocumentParagraph,\n  DocumentFormula,\n} from \"../models/documentElements.js\";\nimport type {\n  Document as GeneratedDocument,\n  DocumentPage as GeneratedDocumentPage,\n  DocumentLine as GeneratedDocumentLine,\n} from \"../generated/index.js\";\n\n/**\n * A request input that can be uploaded as binary data to the Form Recognizer service. Form Recognizer treats `string`\n * inputs as URLs, so to send a string as a _binary_ input, first convert the string to one of the following input\n * types.\n */\nexport type FormRecognizerRequestBody =\n  | NodeJS.ReadableStream\n  | Blob\n  | ArrayBuffer\n  | ArrayBufferView;\n\n/**\n * An extracted document object.\n *\n * An AnalyzedDocument is an instance of one of the document types within a model. Its fields correspond to the field\n * schema of the document type.\n */\nexport interface AnalyzedDocument {\n  /**\n   * The type of the document that was extracted. A model can have multiple document types (for example, in a composed\n   * model), so this property indicates which document type the fields of this document correspond to.\n   */\n  docType: string;\n\n  /**\n   * The extracted fields, which correspond to the document type's field schema.\n   */\n  fields: { [field: string]: DocumentField };\n\n  /**\n   * Bounding regions covering the document.\n   */\n  boundingRegions?: BoundingRegion[];\n\n  /**\n   * Locations of the document's elements in the `content` text (reading-order-concatenated content).\n   */\n  spans: DocumentSpan[];\n\n  /**\n   * The service's confidence that it has correctly extracted the document.\n   */\n  confidence: number;\n}\n\n/**\n * Transform a REST-level Document response object into the more strongly-typed AnalyzedDocument.\n *\n * @internal\n * @param document - a REST-level document response object\n * @returns an AnalyzedDocument (which has had its fields mapped to stronger DocumentField types)\n */\nexport function toAnalyzedDocumentFromGenerated(document: GeneratedDocument): AnalyzedDocument {\n  return {\n    ...document,\n    boundingRegions: toBoundingRegions(document.boundingRegions),\n    fields: toAnalyzedDocumentFieldsFromGenerated(document.fields ?? {}),\n  };\n}\n\n/**\n * The common fields of all AnalyzeResult-like types, such as LayoutResult, ReadResult, and GeneralDocumentResult.\n */\nexport interface AnalyzeResultCommon {\n  /**\n   * The service API version used to produce this result.\n   */\n  apiVersion: string;\n\n  /**\n   * The unique ID of the model that was used to produce this result.\n   */\n  modelId: string;\n\n  /**\n   * A string representation of all textual and visual elements in the input, concatenated by reading order (the order\n   * in which the service \"reads\" or extracts the textual and visual content from the document).\n   */\n  content: string;\n}\n\n/**\n * The result of an analysis operation. The type of the Document may be determined by the model used to perform the\n * analysis.\n */\nexport interface AnalyzeResult<Document = AnalyzedDocument> extends AnalyzeResultCommon {\n  /**\n   * Extracted pages.\n   */\n  pages?: DocumentPage[];\n\n  /**\n   * Extracted tables.\n   */\n  tables?: DocumentTable[];\n\n  /**\n   * Extracted key-value pairs.\n   */\n  keyValuePairs?: DocumentKeyValuePair[];\n\n  /**\n   * Extracted text languages.\n   */\n  languages?: DocumentLanguage[];\n\n  /**\n   * Extracted font styles.\n   */\n  styles?: DocumentStyle[];\n\n  /**\n   * Extracted documents (instances of any of the model's document types and corresponding field schemas).\n   */\n  documents?: Document[];\n\n  /**\n   * Extracted document paragraphs.\n   */\n  paragraphs?: DocumentParagraph[];\n}\n\n/**\n * Tests if one span contains another, by testing that the outer span starts before or at the same character as the\n * inner span, and that the end position of the outer span is greater than or equal to the end position of the inner\n * span.\n *\n * @internal\n * @param outer - the outer (potentially containing) span\n * @param inner - the span to test if `outer` contains\n * @returns true if `inner` is contained inside of `outer`.\n */\nexport function contains(outer: DocumentSpan, inner: DocumentSpan): boolean {\n  return outer.offset <= inner.offset && outer.offset + outer.length >= inner.offset + inner.length;\n}\n\n/**\n * Make an empty generator. This might seem silly, but it's useful for satisfying invariants.\n */\nfunction* empty(): Generator<never> {\n  /* intentionally empty */\n}\n\n/**\n * Produces an iterator of the given items starting from the given index.\n *\n * @param items - the items to iterate over\n * @param idx - the index of the first item to begin iterating from\n */\nexport function* iterFrom<T>(items: T[], idx: number): Generator<T> {\n  let i = idx;\n\n  while (i < items.length) {\n    yield items[i++];\n  }\n}\n\nexport function toDocumentLineFromGenerated(\n  generated: GeneratedDocumentLine,\n  page: GeneratedDocumentPage,\n): DocumentLine {\n  (generated as DocumentLine).words = () =>\n    fastGetChildren(\n      iterFrom(generated.spans, 0),\n      page.words?.map((word) => {\n        return { ...word, polygon: toBoundingPolygon(word.polygon) };\n      }) ?? [],\n    );\n\n  (generated as DocumentLine).polygon = toBoundingPolygon(generated.polygon);\n\n  Object.defineProperty(generated, \"words\", {\n    enumerable: false,\n  });\n\n  return generated as DocumentLine;\n}\n\nexport function toDocumentPageFromGenerated(generated: GeneratedDocumentPage): DocumentPage {\n  return {\n    ...generated,\n    lines: generated.lines?.map((line) => toDocumentLineFromGenerated(line, generated)),\n    selectionMarks: generated.selectionMarks?.map((mark) => ({\n      ...mark,\n      polygon: toBoundingPolygon(mark.polygon),\n    })),\n    words: generated.words?.map((word) => ({\n      ...word,\n      polygon: toBoundingPolygon(word.polygon),\n    })),\n    barcodes: generated.barcodes?.map((barcode) => ({\n      ...barcode,\n      polygon: toBoundingPolygon(barcode.polygon),\n    })),\n    formulas: generated.formulas?.map(\n      (formula): DocumentFormula => ({\n        ...formula,\n        polygon: toBoundingPolygon(formula.polygon),\n      }),\n    ),\n  };\n}\n\n/**\n * Binary search through an array of items to find the first item that could possibly be contained by the given span,\n * then return an iterator beginning from that item.\n *\n * This allows a program to quickly find the first relevant item in the array for consideration when testing for span\n * inclusion.\n *\n * @internal\n * @param span - the span to use when testing each individual item\n * @param items - an array of items to binary search through\n * @returns an iterator beginning from the item identified by the search\n */\nexport function iteratorFromFirstMatchBinarySearch<Spanned extends { span: DocumentSpan }>(\n  span: DocumentSpan,\n  items: Spanned[],\n): IterableIterator<Spanned> {\n  let idx = Math.floor(items.length / 2);\n  let prevIdx = idx;\n  let min = 0;\n  let max = items.length;\n\n  const found = (): boolean =>\n    // The item is found if it starts after the current span and the item before it does not. That means it is the first\n    // item in the array that could be a child if the spans are sorted.\n    items[idx].span.offset >= span.offset && (items[idx - 1]?.span?.offset ?? -1) < span.offset;\n\n  // Binary search to find the first element that could be a child\n  do {\n    if (found()) {\n      return iterFrom(items, idx);\n    } else if (span.offset > items[idx].span.offset) {\n      min = prevIdx = idx;\n      idx = Math.floor(idx + (max - idx) / 2);\n    } else {\n      max = prevIdx = idx;\n      idx = Math.floor(idx - (idx - min) / 2);\n    }\n  } while (idx !== prevIdx);\n\n  // This might seem weird, but it's a simple way to make the types a little more elegant.\n  return empty();\n}\n\n/**\n * This fast algorithm tests the elements of `childArray` for inclusion in any of the given `spans`, assuming that both\n * the spans and child items are sorted.\n *\n * INVARIANT: the items in both the `spans` iterator and `childrenArray` MUST BE SORTED INCREASING by span _offset_.\n *\n * @internal\n * @param spans - the spans that contain the child elements\n * @param childrenArray - an array of child items (items that have spans) to test for inclusion in the spans\n * @returns - an IterableIterator of child items that are included in any span in the `spans` iterator\n */\nexport function* fastGetChildren<Spanned extends { span: DocumentSpan }>(\n  spans: Iterator<DocumentSpan>,\n  childrenArray: Spanned[],\n): Generator<Spanned> {\n  let curSpan = spans.next();\n\n  // Need to exit early if there are no spans.\n  if (curSpan.done) {\n    return;\n  }\n\n  const children = iteratorFromFirstMatchBinarySearch(curSpan.value as DocumentSpan, childrenArray);\n  let curChild = children.next();\n\n  while (!(curChild.done || curSpan.done)) {\n    if (contains(curSpan.value, curChild.value.span)) {\n      // The span is contained, so yield the current child and advance it.\n      yield curChild.value;\n      curChild = children.next();\n    } else if (curSpan.value.offset + curSpan.value.length < curChild.value.span.offset) {\n      // The current span ends before the next potential child starts, so advance the span\n      curSpan = spans.next();\n    } else {\n      // The current child was not contained in the current span, so advance to the next child.\n      curChild = children.next();\n    }\n  }\n}\n\n/**\n * The state of an analysis operation, which will eventually produce the result type that corresponds to the model.\n */\nexport interface DocumentAnalysisPollOperationState<Result = AnalyzeResult<AnalyzedDocument>>\n  extends PollOperationState<Result> {\n  /**\n   * The status of the operation. One of:\n   *\n   * - \"notStarted\"\n   * - \"running\"\n   * - \"succeeded\"\n   * - \"failed\"\n   */\n  status: AnalyzeOperationStatus;\n\n  /**\n   * The model ID that the analysis operation will use to produce the result.\n   */\n  modelId: string;\n\n  /**\n   * The URL to the operation.\n   */\n  operationLocation: string;\n\n  /**\n   * The Date and Time that the operation was created.\n   */\n  createdOn: Date;\n\n  /**\n   * The date & time that the operation state was last modified.\n   */\n  lastUpdatedOn: Date;\n}\n\n/**\n * A long-running operation (poller) that tracks the state of an analysis operation, eventually producing the result\n * type that corresponds to the model.\n */\nexport type AnalysisPoller<Result = AnalyzeResult<AnalyzedDocument>> = PollerLike<\n  DocumentAnalysisPollOperationState<Result>,\n  Result\n>;\n\n/**\n * Convert a generated AnalyzeResult into a convenience layer AnalyzeResult.\n * @internal\n */\nexport function toAnalyzeResultFromGenerated(result: GeneratedAnalyzeResult): AnalyzeResult {\n  return {\n    apiVersion: result.apiVersion,\n    modelId: result.modelId,\n    content: result.content,\n    pages: result.pages.map((page) => toDocumentPageFromGenerated(page)),\n    tables: result.tables?.map((table) => toDocumentTableFromGenerated(table)),\n    keyValuePairs: result.keyValuePairs?.map((pair) => toKeyValuePairFromGenerated(pair)),\n    languages: result.languages,\n    styles: result.styles,\n    paragraphs: result.paragraphs?.map((para) => ({\n      ...para,\n      boundingRegions: toBoundingRegions(para.boundingRegions),\n    })),\n    documents: result.documents?.map(toAnalyzedDocumentFromGenerated),\n  };\n}\n\n/**\n * Defines an analysis operation by the initial request model ID, poller options, and a transform to apply to the\n * eventual result,\n *\n * @internal\n */\nexport interface AnalysisOperationDefinition<Result = AnalyzeResult> {\n  transformResult: (primitiveResult: GeneratedAnalyzeResult) => Result;\n  initialModelId: string;\n  options: PollerOptions<DocumentAnalysisPollOperationState<Result>> &\n    AnalyzeDocumentOptions<Result>;\n}\n\n/**\n * Converts an AnalyzeResultOperation (LRO response) to a DocumentAnalysisPollOperationState\n * @internal\n */\nexport function toDocumentAnalysisPollOperationState<Result>(\n  definition: AnalysisOperationDefinition<Result>,\n  modelId: string,\n  operationLocation: string,\n  response: AnalyzeResultOperation,\n): DocumentAnalysisPollOperationState<Result> {\n  return {\n    status: response.status,\n    modelId: modelId,\n    lastUpdatedOn: response.lastUpdatedOn,\n    createdOn: response.createdOn,\n    operationLocation,\n    result: response.analyzeResult && definition.transformResult(response.analyzeResult),\n    error: response.error && new FormRecognizerError(response.error),\n    isCancelled: false, // Not supported\n    isStarted: response.status !== \"notStarted\",\n    isCompleted: response.status === \"succeeded\",\n  };\n}\n"]}

package/dist/commonjs/lro/util/delayMs.d.ts

@@ -0,0 +1,32 @@
+import type { AbortSignalLike } from "@azure/abort-controller";
+/**
+ * A PromiseLike object that supports cancellation.
+ * @internal
+ */
+export interface CancelablePromiseLike<T> extends PromiseLike<T> {
+    /**
+     * Cancel the promise (cause it to reject).
+     */
+    cancel(): void;
+}
+/**
+ * A promise that delays resolution until a certain amount of time (in milliseconds) has passed, with facilities for
+ * robust cancellation.
+ *
+ * ### Example:
+ *
+ * ```ts snippet:ignore
+ * let toCancel;
+ *
+ * // Wait 20 seconds, and optionally allow the function to be cancelled.
+ * await delayMs(20000, (cancel) => { toCancel = cancel });
+ *
+ * // ... if `toCancel` is called before the 20 second timer expires, then the delayMs promise will reject.
+ * ```
+ *
+ * @internal
+ * @param ms - the number of milliseconds to wait before resolving
+ * @param cb - a callback that can provide the caller with a cancellation function
+ */
+export declare function delayMs(ms: number, abortSignal: AbortSignalLike | undefined): CancelablePromiseLike<void>;
+//# sourceMappingURL=delayMs.d.ts.map

package/dist/commonjs/lro/util/delayMs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayMs.d.ts","sourceRoot":"","sources":["../../../../src/lro/util/delayMs.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAM/D;;;GAGG;AACH,MAAM,WAAW,qBAAqB,CAAC,CAAC,CAAE,SAAQ,WAAW,CAAC,CAAC,CAAC;IAC9D;;OAEG;IACH,MAAM,IAAI,IAAI,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,OAAO,CACrB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,eAAe,GAAG,SAAS,GACvC,qBAAqB,CAAC,IAAI,CAAC,CAgC7B"}

package/dist/commonjs/lro/util/delayMs.js

@@ -0,0 +1,55 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delayMs = delayMs;
+const abort_controller_1 = require("@azure/abort-controller");
+const util_js_1 = require("../../util.js");
+/**
+ * A promise that delays resolution until a certain amount of time (in milliseconds) has passed, with facilities for
+ * robust cancellation.
+ *
+ * ### Example:
+ *
+ * ```ts snippet:ignore
+ * let toCancel;
+ *
+ * // Wait 20 seconds, and optionally allow the function to be cancelled.
+ * await delayMs(20000, (cancel) => { toCancel = cancel });
+ *
+ * // ... if `toCancel` is called before the 20 second timer expires, then the delayMs promise will reject.
+ * ```
+ *
+ * @internal
+ * @param ms - the number of milliseconds to wait before resolving
+ * @param cb - a callback that can provide the caller with a cancellation function
+ */
+function delayMs(ms, abortSignal) {
+    let aborted = false;
+    let toReject;
+    abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.addEventListener("abort", () => {
+        aborted = true;
+        toReject === null || toReject === void 0 ? void 0 : toReject(new abort_controller_1.AbortError("The operation was aborted."));
+    });
+    return Object.assign(new Promise((resolve, reject) => {
+        let token;
+        toReject = (e) => {
+            (0, util_js_1.maybemap)(token, clearTimeout);
+            reject(e);
+        };
+        // In the rare case that the operation is _already_ aborted, we will reject instantly. This could happen, for
+        // example, if the user calls the cancellation function immediately without yielding execution.
+        if (aborted) {
+            toReject(new Error("The operation was cancelled prematurely."));
+        }
+        else {
+            token = setTimeout(resolve, ms);
+        }
+    }), {
+        cancel: () => {
+            aborted = true;
+            toReject === null || toReject === void 0 ? void 0 : toReject(new Error("The operation was cancelled."));
+        },
+    });
+}
+//# sourceMappingURL=delayMs.js.map

package/dist/commonjs/lro/util/delayMs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delayMs.js","sourceRoot":"","sources":["../../../../src/lro/util/delayMs.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;AAsClC,0BAmCC;AAtED,8DAAqD;AACrD,2CAAyC;AAezC;;;;;;;;;;;;;;;;;;GAkBG;AACH,SAAgB,OAAO,CACrB,EAAU,EACV,WAAwC;IAExC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,IAAI,QAA0C,CAAC;IAE/C,WAAW,aAAX,WAAW,uBAAX,WAAW,CAAE,gBAAgB,CAAC,OAAO,EAAE,GAAG,EAAE;QAC1C,OAAO,GAAG,IAAI,CAAC;QACf,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAG,IAAI,6BAAU,CAAC,4BAA4B,CAAC,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC,MAAM,CAClB,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACpC,IAAI,KAAoC,CAAC;QACzC,QAAQ,GAAG,CAAC,CAAC,EAAE,EAAE;YACf,IAAA,kBAAQ,EAAC,KAAK,EAAE,YAAY,CAAC,CAAC;YAC9B,MAAM,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC,CAAC;QAEF,6GAA6G;QAC7G,+FAA+F;QAC/F,IAAI,OAAO,EAAE,CAAC;YACZ,QAAQ,CAAC,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC,CAAC;QAClE,CAAC;aAAM,CAAC;YACN,KAAK,GAAG,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;QAClC,CAAC;IACH,CAAC,CAAC,EACF;QACE,MAAM,EAAE,GAAG,EAAE;YACX,OAAO,GAAG,IAAI,CAAC;YACf,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAG,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC,CAAC;QACxD,CAAC;KACF,CACF,CAAC;AACJ,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation.\n// Licensed under the MIT License.\n\nimport type { AbortSignalLike } from \"@azure/abort-controller\";\nimport { AbortError } from \"@azure/abort-controller\";\nimport { maybemap } from \"../../util.js\";\n\ntype CancellationToken = Parameters<typeof clearTimeout>[0];\n\n/**\n * A PromiseLike object that supports cancellation.\n * @internal\n */\nexport interface CancelablePromiseLike<T> extends PromiseLike<T> {\n  /**\n   * Cancel the promise (cause it to reject).\n   */\n  cancel(): void;\n}\n\n/**\n * A promise that delays resolution until a certain amount of time (in milliseconds) has passed, with facilities for\n * robust cancellation.\n *\n * ### Example:\n *\n * ```ts snippet:ignore\n * let toCancel;\n *\n * // Wait 20 seconds, and optionally allow the function to be cancelled.\n * await delayMs(20000, (cancel) => { toCancel = cancel });\n *\n * // ... if `toCancel` is called before the 20 second timer expires, then the delayMs promise will reject.\n * ```\n *\n * @internal\n * @param ms - the number of milliseconds to wait before resolving\n * @param cb - a callback that can provide the caller with a cancellation function\n */\nexport function delayMs(\n  ms: number,\n  abortSignal: AbortSignalLike | undefined,\n): CancelablePromiseLike<void> {\n  let aborted = false;\n  let toReject: ((e: Error) => void) | undefined;\n\n  abortSignal?.addEventListener(\"abort\", () => {\n    aborted = true;\n    toReject?.(new AbortError(\"The operation was aborted.\"));\n  });\n\n  return Object.assign(\n    new Promise<void>((resolve, reject) => {\n      let token: CancellationToken | undefined;\n      toReject = (e) => {\n        maybemap(token, clearTimeout);\n        reject(e);\n      };\n\n      // In the rare case that the operation is _already_ aborted, we will reject instantly. This could happen, for\n      // example, if the user calls the cancellation function immediately without yielding execution.\n      if (aborted) {\n        toReject(new Error(\"The operation was cancelled prematurely.\"));\n      } else {\n        token = setTimeout(resolve, ms);\n      }\n    }),\n    {\n      cancel: () => {\n        aborted = true;\n        toReject?.(new Error(\"The operation was cancelled.\"));\n      },\n    },\n  );\n}\n"]}

package/dist/commonjs/lro/util/poller.d.ts

@@ -0,0 +1,41 @@
+import type { PollOperationState, PollerLike } from "@azure/core-lro";
+import type { AbortSignalLike } from "@azure/abort-controller";
+/**
+ * Information about the Long-Running Operation (LRO) that is being performed.
+ */
+export interface OperationContext {
+    /**
+     * An AbortSignal that can be used to cancel the operation.
+     */
+    abortSignal?: AbortSignalLike;
+    /**
+     * Sets the server's preferred polling interval in milliseconds. To clear the server's preferred polling interval,
+     * pass `undefined`.
+     */
+    updateDelay: (interval: number | undefined) => void;
+}
+/**
+ * A specification for a long-running operation, which defines the poller flow.
+ * @internal
+ */
+export interface OperationSpec<TState extends PollOperationState<unknown>> {
+    /**
+     * A function that produces the first operation state for this LRO.
+     */
+    init: (ctx: OperationContext) => Promise<TState>;
+    /**
+     * A function that consumes the existing state of the poller and produces the next state.
+     */
+    poll: (ctx: OperationContext, state: TState) => Promise<TState>;
+    /**
+     * A function that serializes the state into a string.
+     */
+    serialize: (state: TState) => string;
+}
+/**
+ * Uniform poller implementation, creates a poller based on a PollerSpec.
+ *
+ * @internal
+ */
+export declare function lro<TResult, TState extends PollOperationState<TResult>>(spec: OperationSpec<TState>, pollingInterval: number | undefined, initAbortSignal: AbortSignalLike | undefined): Promise<PollerLike<TState, TResult>>;
+//# sourceMappingURL=poller.d.ts.map