survey-expression 0.0.0-stage → 4.5.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020-present Jimmy Chen
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,105 @@
-# Temporary Holding Version
+# survey-expression
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![Apache-2.0 licensed][badge-license]][url-license]
+[![NPM version][badge-npm-version]][url-npm]
+[![NPM downloads][badge-npm-downloads]][url-npm]
+[![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
+
+It parses and evaluates the survey's expression language: the conditions that show, enable or require a question, the calculated values and the validators, written over a survey's answers. It depends on no SurveyJS, and it is checked against SurveyJS's recorded answers, with every deliberate difference listed.
+
+Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/resource/survey-expression).
+
+## Table of Contents
+
+- 🚀 [Getting Started](#getting-started)
+- 🧩 [Key Exports](#key-exports)
+- 🧮 [Functions](#functions)
+- ⚖️ [License](#license)
+
+---
+
+## <a name="getting-started">🚀 Getting Started</a>
+
+```bash
+pnpm i survey-expression
+```
+
+```ts
+import { runSurveyExpression } from "survey-expression";
+
+const result = runSurveyExpression("{age} >= 18 and {country} = 'NZ'", {
+  now: new Date(),
+  scopes: {},
+  values: { age: 21, country: "NZ" },
+});
+
+result.match(
+  (value) => console.log(value), // true
+  (error) => console.error(error.message),
+);
+```
+
+- `runSurveyExpression` returns a neverthrow `Result`. A fault in the expression is an error value, never a throw.
+- Answers read from storage pass through `toSurveyLogicAnswers` first, so a stored null reads as unanswered.
+
+## <a name="key-exports">🧩 Key Exports</a>
+
+| Export                                                                                        | Kind     | Purpose                                                                                                                                              |
+| :-------------------------------------------------------------------------------------------- | :------- | :--------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `checkSurveyExpression`                                                                       | function | Refuses an expression that does not parse, calls a function the package lacks, or calls an array function's filter form, naming the first such fault |
+| `MAX_SURVEY_EXPRESSION_LENGTH`                                                                | constant | The most characters an expression source may hold; a longer source is refused at its first character past the limit, and nothing throws              |
+| `parseSurveyExpression`                                                                       | function | Parses an expression's source into its tree, or into the first fault with the character position it starts at                                        |
+| `runSurveyExpression`                                                                         | function | Parses a source and evaluates it over a context already read as answers, or returns the parse's fault                                                |
+| `SurveyExpressionNode`                                                                        | type     | A parsed expression, each node told apart by its `type`                                                                                              |
+| `SurveyExpressionNodeType`, `SurveyExpressionBinaryOperator`, `SurveyExpressionUnaryOperator` | enum     | The node types and the operators a tree holds                                                                                                        |
+| `SurveyLogicContext`                                                                          | type     | What an expression reads: the answers and calculated values, the scopes the caller passes, and the clock the caller passes                           |
+| `SurveyLogicError`                                                                            | type     | The message and the character position a parse is refused for                                                                                        |
+| `SurveyLogicStoredValue`                                                                      | type     | A value as storage holds it, where a null may appear and reads as unanswered                                                                         |
+| `SurveyLogicValue`                                                                            | type     | The values an expression reads and computes, where `undefined` is an empty answer                                                                    |
+| `tokenizeSurveyExpression`                                                                    | function | Reads an expression's source into its tokens, or returns the first fault                                                                             |
+| `toSurveyLogicAnswer`                                                                         | function | Reads one stored value as an answer at every depth, with a stored null read as unanswered                                                            |
+| `toSurveyLogicAnswers`                                                                        | function | Reads a record of stored answers as answers, each at every depth: the one boundary where a stored null reads as unanswered                           |
+
+## <a name="functions">🧮 Functions</a>
+
+Each function is called by its name, written in any case. A call to a name no function has is refused when the expression is checked.
+
+| Function       | Returns                                                                                                                                                                                                                          |
+| :------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `age`          | The whole years from a birthdate to the clock, or the whole count of the interval it names; undefined for a birthdate after the clock                                                                                            |
+| `avg`          | The average of the values passed, arrays flattened                                                                                                                                                                               |
+| `avgInArray`   | The average of a field over the items of an array value                                                                                                                                                                          |
+| `count`        | How many values are passed, arrays flattened                                                                                                                                                                                     |
+| `countInArray` | How many items of an array value hold a value in a field                                                                                                                                                                         |
+| `dateAdd`      | A date moved by an amount of an interval, in days by default; a date moved outside years zero to 9999 has no result                                                                                                              |
+| `dateDiff`     | The amount of an interval between two dates: calendar days, months or years, or hours, minutes and seconds on the clock                                                                                                          |
+| `day`          | The day of the month of a date, or of the clock's day when the date is empty                                                                                                                                                     |
+| `iif`          | The second value when the condition is `true`, otherwise the third                                                                                                                                                               |
+| `max`          | The largest of the values passed, arrays flattened                                                                                                                                                                               |
+| `maxInArray`   | The largest value of a field over an array's items, or another field of that item                                                                                                                                                |
+| `min`          | The smallest of the values passed, arrays flattened                                                                                                                                                                              |
+| `minInArray`   | The smallest value of a field over an array's items, or another field of that item                                                                                                                                               |
+| `month`        | The month of a date, from one for January, or of the clock's day when the date is empty                                                                                                                                          |
+| `round`        | The number rounded to a number of decimal places, or to a whole number when the precision is empty or absent. A value that reads as no number has no result, and so does a precision that is not a whole number from zero to 100 |
+| `substring`    | The part of a text from a start index up to an end index. A start, or a present end, that reads as no number has no result, and an empty or absent end runs to the end of the text                                               |
+| `sum`          | The sum of the values passed, arrays flattened                                                                                                                                                                                   |
+| `sumInArray`   | The sum of a field over the items of an array value                                                                                                                                                                              |
+| `today`        | The clock's day at midnight, moved by a number of days when one is given                                                                                                                                                         |
+| `trunc`        | The number cut to a number of decimal places, or to its whole part when the precision is empty or absent. A value that reads as no number has no result, and so does a precision that is not a whole number from zero to 100     |
+| `weekday`      | The day of the week of a date, from zero for Sunday                                                                                                                                                                              |
+| `year`         | The year of a date, or of the clock's day when the date is empty                                                                                                                                                                 |
+
+The `...InArray` functions take a field and, optionally, another field of the item to return. A filter, a condition over each item's fields as a last argument, is not supported: `checkSurveyExpression` refuses the call, and `runSurveyExpression` answers empty for it.
+
+The functions that read the live survey object, "displayValue", "isContainerReady", "isDisplayMode" and "propertyValue", are deliberately not implemented, since the package has no survey object to read. A call to one is refused by `checkSurveyExpression` as an unknown function, and `runSurveyExpression` answers empty for it.
+
+## <a name="license">⚖️ License</a>
+
+Licensed under [Apache-2.0][url-license].
+
+[badge-license]: https://img.shields.io/github/license/Esposter/Esposter.svg?color=blue
+[url-license]: https://github.com/Esposter/Esposter/blob/main/LICENSE
+[badge-npm-version]: https://img.shields.io/npm/v/survey-expression/latest?color=brightgreen
+[url-npm]: https://www.npmjs.com/package/survey-expression/v/latest
+[badge-npm-unpacked-size]: https://img.shields.io/npm/unpacked-size/survey-expression/latest?label=npm
+[badge-npm-downloads]: https://img.shields.io/npm/dm/survey-expression.svg

package/dist/index.d.ts

@@ -0,0 +1,259 @@
+import { Result } from "neverthrow";
+export declare enum SurveyExpressionBinaryOperator {
+  Add = "add",
+  AllOf = "allOf",
+  And = "and",
+  AnyOf = "anyOf",
+  Contains = "contains",
+  Divide = "divide",
+  Equal = "equal",
+  Greater = "greater",
+  GreaterOrEqual = "greaterOrEqual",
+  Less = "less",
+  LessOrEqual = "lessOrEqual",
+  Modulo = "modulo",
+  Multiply = "multiply",
+  NotContains = "notContains",
+  NotEqual = "notEqual",
+  Or = "or",
+  Power = "power",
+  Subtract = "subtract"
+}
+export declare enum SurveyExpressionNodeType {
+  Binary = "binary",
+  Call = "call",
+  List = "list",
+  Literal = "literal",
+  Reference = "reference",
+  Unary = "unary"
+}
+export interface SurveyExpressionCallNode {
+  args: SurveyExpressionNode[];
+  name: string;
+  position: number;
+  type: SurveyExpressionNodeType.Call;
+}
+export interface SurveyExpressionListNode {
+  items: SurveyExpressionNode[];
+  position: number;
+  type: SurveyExpressionNodeType.List;
+}
+export interface SurveyExpressionLiteralNode {
+  position: number;
+  type: SurveyExpressionNodeType.Literal;
+  value: boolean | number | string;
+}
+export interface SurveyExpressionReferenceNode {
+  name: string;
+  position: number;
+  type: SurveyExpressionNodeType.Reference;
+}
+export declare enum SurveyExpressionUnaryOperator {
+  Empty = "empty",
+  Negate = "negate",
+  Not = "not",
+  NotEmpty = "notEmpty"
+}
+export interface SurveyExpressionUnaryNode {
+  operand: SurveyExpressionNode;
+  operator: SurveyExpressionUnaryOperator;
+  position: number;
+  type: SurveyExpressionNodeType.Unary;
+}
+export type SurveyExpressionNode = SurveyExpressionBinaryNode | SurveyExpressionCallNode | SurveyExpressionListNode | SurveyExpressionLiteralNode | SurveyExpressionReferenceNode | SurveyExpressionUnaryNode;
+export interface SurveyExpressionBinaryNode {
+  left: SurveyExpressionNode;
+  operator: SurveyExpressionBinaryOperator;
+  position: number;
+  right: SurveyExpressionNode;
+  type: SurveyExpressionNodeType.Binary;
+}
+export interface SurveyExpressionBinaryOperatorDefinition {
+  operator: SurveyExpressionBinaryOperator;
+  power: number;
+  rightAssociative?: true;
+}
+export interface SurveyLogicRecord extends Record<string, SurveyLogicValue> {}
+export type SurveyLogicValue = boolean | number | string | SurveyLogicRecord | SurveyLogicValue[] | undefined;
+export interface SurveyLogicContext {
+  now: Date;
+  scopes: Record<string, Record<string, SurveyLogicValue>>;
+  values: Record<string, SurveyLogicValue>;
+}
+export type SurveyExpressionEvaluate = (node: SurveyExpressionNode, context: SurveyLogicContext) => SurveyLogicValue;
+export declare enum SurveyExpressionTokenType {
+  Boolean = "boolean",
+  End = "end",
+  Identifier = "identifier",
+  Number = "number",
+  Operator = "operator",
+  Punctuation = "punctuation",
+  Reference = "reference",
+  String = "string"
+}
+export interface SurveyExpressionToken {
+  position: number;
+  text: string;
+  type: SurveyExpressionTokenType;
+}
+export interface SurveyExpressionParserState {
+  index: number;
+  tokens: SurveyExpressionToken[];
+}
+export interface SurveyLogicError {
+  message: string;
+  position: number;
+}
+export type SurveyExpressionParse = (state: SurveyExpressionParserState, minimumPower: number) => Result<SurveyExpressionNode, SurveyLogicError>;
+export interface SurveyExpressionTokenizerState {
+  error?: SurveyLogicError;
+  index: number;
+  source: string;
+  tokens: SurveyExpressionToken[];
+}
+export interface SurveyExpressionUnaryOperatorDefinition {
+  operator: SurveyExpressionUnaryOperator;
+  power: number;
+}
+export interface SurveyLogicArrayRow {
+  field: number;
+  item: SurveyLogicRecord;
+}
+export interface SurveyLogicArrayParams {
+  returnField?: string;
+  rows: SurveyLogicArrayRow[];
+}
+export type SurveyLogicFunction = (args: SurveyLogicValue[], context: SurveyLogicContext) => SurveyLogicValue;
+export type SurveyLogicPathMemo = Map<SurveyLogicValue, Map<string, SurveyLogicValue>>;
+export type SurveyLogicStoredValue = boolean | null | number | string | SurveyLogicStoredValue[] | undefined | {
+  [name: string]: SurveyLogicStoredValue;
+};
+export declare const checkSurveyExpression: (source: string) => SurveyLogicError | undefined;
+export declare const LOWEST_POWER = 0;
+export declare const MAX_DECIMAL_PLACES = 100;
+export declare const MAX_SURVEY_EXPRESSION_LENGTH = 2e3;
+export declare const PUNCTUATION_CHARACTERS: readonly string[];
+export declare const STRING_QUOTES: readonly string[];
+export declare const SYMBOL_OPERATOR_TEXTS: string[];
+export declare const evaluateSurveyExpression: (node: SurveyExpressionNode, context: SurveyLogicContext) => SurveyLogicValue;
+export declare const evaluateBinary: (node: SurveyExpressionBinaryNode, context: SurveyLogicContext, evaluate: SurveyExpressionEvaluate) => SurveyLogicValue;
+export declare const evaluateCall: (node: SurveyExpressionCallNode, context: SurveyLogicContext, evaluate: SurveyExpressionEvaluate) => SurveyLogicValue;
+export declare const evaluateList: (node: SurveyExpressionListNode, context: SurveyLogicContext, evaluate: SurveyExpressionEvaluate) => SurveyLogicValue[];
+export declare const evaluateReference: (node: SurveyExpressionReferenceNode, context: SurveyLogicContext) => SurveyLogicValue;
+export declare const evaluateUnary: (node: SurveyExpressionUnaryNode, context: SurveyLogicContext, evaluate: SurveyExpressionEvaluate) => SurveyLogicValue;
+export declare const evaluateArithmeticOperator: (operator: SurveyExpressionBinaryOperator.Add | SurveyExpressionBinaryOperator.Divide | SurveyExpressionBinaryOperator.Modulo | SurveyExpressionBinaryOperator.Multiply | SurveyExpressionBinaryOperator.Power | SurveyExpressionBinaryOperator.Subtract, left: SurveyLogicValue, right: SurveyLogicValue) => SurveyLogicValue;
+export declare const evaluateComparisonOperator: (operator: SurveyExpressionBinaryOperator.Equal | SurveyExpressionBinaryOperator.Greater | SurveyExpressionBinaryOperator.GreaterOrEqual | SurveyExpressionBinaryOperator.Less | SurveyExpressionBinaryOperator.LessOrEqual | SurveyExpressionBinaryOperator.NotEqual, left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const evaluateLogicOperator: (operator: SurveyExpressionBinaryOperator.And | SurveyExpressionBinaryOperator.Or, left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const evaluateMembershipOperator: (operator: SurveyExpressionBinaryOperator.AllOf | SurveyExpressionBinaryOperator.AnyOf | SurveyExpressionBinaryOperator.Contains | SurveyExpressionBinaryOperator.NotContains, left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const readMemoizedSurveyLogicPath: (container: SurveyLogicValue, name: string, memo: SurveyLogicPathMemo) => SurveyLogicValue;
+export declare const readSurveyLogicKey: (container: SurveyLogicValue, key: string) => SurveyLogicValue;
+export declare const readSurveyLogicLength: (value: SurveyLogicValue) => number;
+export declare const readSurveyLogicPart: (container: SurveyLogicValue, part: string) => SurveyLogicValue;
+export declare const readSurveyLogicPath: (container: SurveyLogicValue, name: string) => SurveyLogicValue;
+export declare const readSurveyLogicPathUncached: (container: SurveyLogicValue, name: string, readTail: (head: SurveyLogicValue, tail: string) => SurveyLogicValue) => SurveyLogicValue;
+export declare const readSurveyLogicReference: (name: string, context: SurveyLogicContext) => SurveyLogicValue;
+export declare const findSurveyExpressionRefusal: (node: SurveyExpressionNode) => SurveyLogicError | undefined;
+export declare const ageFunction: SurveyLogicFunction;
+export declare const ArrayFunctionMap: Record<string, SurveyLogicFunction>;
+export declare const avgFunction: SurveyLogicFunction;
+export declare const avgInArrayFunction: SurveyLogicFunction;
+export declare const countFunction: SurveyLogicFunction;
+export declare const countInArrayFunction: SurveyLogicFunction;
+export declare const dateAddFunction: SurveyLogicFunction;
+export declare const dateDiffFunction: SurveyLogicFunction;
+export declare const DateFunctionMap: Record<string, SurveyLogicFunction>;
+export declare const dayFunction: SurveyLogicFunction;
+export declare const GeneralFunctionMap: Record<string, SurveyLogicFunction>;
+export declare const iifFunction: SurveyLogicFunction;
+export declare const maxFunction: SurveyLogicFunction;
+export declare const maxInArrayFunction: SurveyLogicFunction;
+export declare const minFunction: SurveyLogicFunction;
+export declare const minInArrayFunction: SurveyLogicFunction;
+export declare const monthFunction: SurveyLogicFunction;
+export declare const roundFunction: SurveyLogicFunction;
+export declare const substringFunction: SurveyLogicFunction;
+export declare const sumFunction: SurveyLogicFunction;
+export declare const sumInArrayFunction: SurveyLogicFunction;
+export declare const SurveyLogicFunctionMap: Record<string, SurveyLogicFunction>;
+export declare const todayFunction: SurveyLogicFunction;
+export declare const truncFunction: SurveyLogicFunction;
+export declare const weekdayFunction: SurveyLogicFunction;
+export declare const yearFunction: SurveyLogicFunction;
+export declare const getCallRefusal: (node: SurveyExpressionCallNode) => string | undefined;
+export declare const getSurveyExpressionChildren: (node: SurveyExpressionNode) => SurveyExpressionNode[];
+export declare const checkIsPunctuation: (token: SurveyExpressionToken, text: string) => boolean;
+export declare const parseBinary: SurveyExpressionParse;
+export declare const parseBinaryOperators: (state: SurveyExpressionParserState, left: SurveyExpressionNode, minimumPower: number, parse: SurveyExpressionParse) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const parseCall: (state: SurveyExpressionParserState, parse: SurveyExpressionParse) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const parseGroup: (state: SurveyExpressionParserState, parse: SurveyExpressionParse) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const parseList: (state: SurveyExpressionParserState, parse: SurveyExpressionParse) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const parseOperand: (state: SurveyExpressionParserState, parse: SurveyExpressionParse) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const parsePrefixOperator: (state: SurveyExpressionParserState, parse: SurveyExpressionParse) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const parseSequence: (state: SurveyExpressionParserState, closing: string, message: string, parse: SurveyExpressionParse) => Result<SurveyExpressionNode[], SurveyLogicError>;
+export declare const parseSequenceItems: (state: SurveyExpressionParserState, closing: string, message: string, parse: SurveyExpressionParse, items: SurveyExpressionNode[]) => Result<SurveyExpressionNode[], SurveyLogicError>;
+export declare const parseSurveyExpression: (source: string) => Result<SurveyExpressionNode, SurveyLogicError>;
+export declare const runSurveyExpression: (source: string, context: SurveyLogicContext) => Result<SurveyLogicValue, SurveyLogicError>;
+export declare const addSurveyLogicMonths: (wallClock: Date, months: number) => void;
+export declare const averageSurveyNumbers: (numbers: number[]) => number | undefined;
+export declare const checkIsCalendarDay: (year: number, month: number, day: number) => boolean;
+export declare const checkIsSurveyFieldName: (text: string) => boolean;
+export declare const checkIsSurveyLogicAllOf: (left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicAnyOf: (left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicContaining: (left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicItemHeld: (haystack: SurveyLogicValue, item: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicLess: (left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicPrimitiveEqual: (left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicValueEmpty: (value: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyLogicValueEqual: (left: SurveyLogicValue, right: SurveyLogicValue) => boolean;
+export declare const checkIsSurveyReturnField: (value: unknown) => value is string;
+export declare const compareSurveyLogicTexts: (first: string, second: string) => number;
+export declare const countSurveyLogicDecimals: (number: number) => number;
+export declare const createSurveyLogicWallClock: (year: number, monthIndex: number, day: number, { hour, millisecond, minute, second }?: {
+  hour?: number;
+  millisecond?: number;
+  minute?: number;
+  second?: number;
+}) => Date;
+export declare const flattenSurveyNumbers: (values: SurveyLogicValue[]) => number[];
+export declare const getDateDifference: (first: Date, second: Date, unit: string) => number | undefined;
+export declare const getDateOrNow: (value: SurveyLogicValue, now: Date) => Date | undefined;
+export declare const getOwnValue: <T>(record: Readonly<Record<string, T>>, key: string) => T | undefined;
+export declare const getSurveyArrayExtreme: (params: SurveyLogicArrayParams, checkReplaces: (best: number, candidate: number) => boolean) => SurveyLogicValue;
+export declare const getSurveyArrayItems: (data: SurveyLogicValue) => SurveyLogicValue[];
+export declare const getSurveyArrayParams: (args: SurveyLogicValue[]) => SurveyLogicArrayParams | undefined;
+export declare const getSurveyDateUnit: (value: SurveyLogicValue, defaultUnit: string) => string | undefined;
+export declare const getSurveyExtreme: <T>(candidates: T[], checkReplaces: (best: T, candidate: T) => boolean) => T | undefined;
+export declare const getSurveyLogicDayNumber: (wallClock: Date) => number;
+export declare const getSurveyNumberWithPrecision: (args: SurveyLogicValue[]) => [number, number] | undefined;
+export declare const getSurveyOptionalArgument: <T>(value: SurveyLogicValue, defaultValue: T, readArgument: (value: SurveyLogicValue) => T | undefined) => T | undefined;
+export declare const getSurveyTextIndex: (index: number, length: number) => number;
+export declare const mapSurveyLogicValues: <T, U>(record: Record<string, T>, mapValue: (value: T) => U) => Record<string, U>;
+export declare const parseSurveyLogicDate: (value: SurveyLogicValue) => Date | undefined;
+export declare const roundSurveyLogicProduct: (left: number, right: number, product: number) => number;
+export declare const roundSurveyLogicResult: (result: number, digits: number) => number;
+export declare const roundSurveyLogicSum: (left: number, right: number, sum: number) => number;
+export declare const sumSurveyNumbers: (numbers: number[]) => number | undefined;
+export declare const toSurveyLogicAnswer: (value: SurveyLogicStoredValue) => SurveyLogicValue;
+export declare const toSurveyLogicAnswers: (record: Record<string, SurveyLogicStoredValue>) => SurveyLogicRecord;
+export declare const toSurveyLogicDate: (wallClock: Date) => string | undefined;
+export declare const toSurveyLogicNumber: (value: SurveyLogicValue) => number | undefined;
+export declare const toSurveyLogicPrimitive: (value: SurveyLogicValue) => SurveyLogicValue;
+export declare const toSurveyLogicResult: (result: number) => number | undefined;
+export declare const toSurveyLogicText: (value: SurveyLogicValue) => string;
+export declare const toSurveyLogicWallClock: (instant: Date) => Date;
+export declare const SurveyExpressionBinaryOperatorMap: Readonly<Record<string, SurveyExpressionBinaryOperatorDefinition>>;
+export declare const SurveyExpressionPostfixOperatorMap: Readonly<Record<string, SurveyExpressionUnaryOperatorDefinition>>;
+export declare const SurveyExpressionPrefixOperatorMap: Readonly<Record<string, SurveyExpressionUnaryOperatorDefinition>>;
+export declare const advanceSurveyExpressionWhile: (state: SurveyExpressionTokenizerState, checkCharacter: (character: string) => boolean) => void;
+export declare const checkIsSurveyExpressionDigit: (character: string) => boolean;
+export declare const checkIsSurveyExpressionKeyword: (lowercasedWord: string) => boolean;
+export declare const checkIsSurveyExpressionWhitespace: (character: string) => boolean;
+export declare const checkIsSurveyExpressionWordCharacter: (character: string) => boolean;
+export declare const checkIsSurveyExpressionWordStart: (character: string) => boolean;
+export declare const readSurveyExpressionNumber: (state: SurveyExpressionTokenizerState) => void;
+export declare const readSurveyExpressionReference: (state: SurveyExpressionTokenizerState) => void;
+export declare const readSurveyExpressionString: (state: SurveyExpressionTokenizerState) => void;
+export declare const readSurveyExpressionSymbol: (state: SurveyExpressionTokenizerState) => void;
+export declare const readSurveyExpressionToken: (state: SurveyExpressionTokenizerState) => void;
+export declare const readSurveyExpressionWord: (state: SurveyExpressionTokenizerState) => void;
+export declare const tokenizeSurveyExpression: (source: string) => Result<SurveyExpressionToken[], SurveyLogicError>;